diff options
77 files changed, 6349 insertions, 5996 deletions
diff --git a/changes/ticket27924 b/changes/ticket27924 new file mode 100644 index 0000000000..7348727b3a --- /dev/null +++ b/changes/ticket27924 @@ -0,0 +1,3 @@ + o Code simplification and refactoring: + - Divide the "routerparse.c" module into separate modules for each + group of parsed objects. Closes ticket 27924. diff --git a/src/app/main/main.c b/src/app/main/main.c index 8a24df2105..ae87add67d 100644 --- a/src/app/main/main.c +++ b/src/app/main/main.c @@ -45,6 +45,7 @@ #include "feature/dirauth/process_descs.h" #include "feature/dircache/consdiffmgr.h" #include "feature/dircache/dirserv.h" +#include "feature/dirparse/routerparse.h" #include "feature/hibernate/hibernate.h" #include "feature/hs/hs_cache.h" #include "feature/nodelist/authcert.h" @@ -52,7 +53,6 @@ #include "feature/nodelist/networkstatus.h" #include "feature/nodelist/nodelist.h" #include "feature/nodelist/routerlist.h" -#include "feature/nodelist/routerparse.h" #include "feature/relay/dns.h" #include "feature/relay/ext_orport.h" #include "feature/relay/onion_queue.h" @@ -61,7 +61,6 @@ #include "feature/rend/rendcache.h" #include "feature/rend/rendclient.h" #include "feature/rend/rendservice.h" -#include "lib/geoip/geoip.h" #include "feature/stats/geoip_stats.h" #include "feature/stats/predict_ports.h" #include "feature/stats/rephist.h" @@ -70,6 +69,8 @@ #include "lib/crypt_ops/crypto_rand.h" #include "lib/crypt_ops/crypto_s2k.h" #include "lib/err/backtrace.h" +#include "lib/geoip/geoip.h" + #include "lib/process/waitpid.h" #include "lib/meminfo/meminfo.h" @@ -423,7 +424,6 @@ dumpstats(int severity) rep_hist_dump_stats(now,severity); rend_service_dump_stats(severity); - dump_distinct_digest_count(severity); } /** Called by exit() as we shut down the process. diff --git a/src/core/include.am b/src/core/include.am index e51819fa20..1b8ef2ac58 100644 --- a/src/core/include.am +++ b/src/core/include.am @@ -46,6 +46,7 @@ LIBTOR_APP_A_SOURCES = \ src/core/or/scheduler_kist.c \ src/core/or/scheduler_vanilla.c \ src/core/or/status.c \ + src/core/or/versions.c \ src/core/proto/proto_cell.c \ src/core/proto/proto_control0.c \ src/core/proto/proto_ext_or.c \ @@ -72,6 +73,15 @@ LIBTOR_APP_A_SOURCES = \ src/feature/dircommon/directory.c \ src/feature/dircommon/fp_pair.c \ src/feature/dircommon/voting_schedule.c \ + src/feature/dirparse/authcert_parse.c \ + src/feature/dirparse/microdesc_parse.c \ + src/feature/dirparse/ns_parse.c \ + src/feature/dirparse/parsecommon.c \ + src/feature/dirparse/policy_parse.c \ + src/feature/dirparse/routerparse.c \ + src/feature/dirparse/sigcommon.c \ + src/feature/dirparse/signing.c \ + src/feature/dirparse/unparseable.c \ src/feature/hibernate/hibernate.c \ src/feature/hs/hs_cache.c \ src/feature/hs/hs_cell.c \ @@ -98,10 +108,8 @@ LIBTOR_APP_A_SOURCES = \ src/feature/nodelist/nickname.c \ src/feature/nodelist/nodelist.c \ src/feature/nodelist/node_select.c \ - src/feature/nodelist/parsecommon.c \ src/feature/nodelist/routerinfo.c \ src/feature/nodelist/routerlist.c \ - src/feature/nodelist/routerparse.c \ src/feature/nodelist/routerset.c \ src/feature/nodelist/fmt_routerstatus.c \ src/feature/nodelist/torcert.c \ @@ -116,6 +124,7 @@ LIBTOR_APP_A_SOURCES = \ src/feature/rend/rendclient.c \ src/feature/rend/rendcommon.c \ src/feature/rend/rendmid.c \ + src/feature/rend/rendparse.c \ src/feature/rend/rendservice.c \ src/feature/stats/geoip_stats.c \ src/feature/stats/rephist.c \ @@ -125,6 +134,7 @@ LIBTOR_APP_A_SOURCES = \ # the separation is only in the code location. LIBTOR_APP_A_SOURCES += \ src/feature/dirauth/bwauth.c \ + src/feature/dirauth/dsigs_parse.c \ src/feature/dirauth/guardfraction.c \ src/feature/dirauth/reachability.c \ src/feature/dirauth/recommend_pkg.c \ @@ -240,6 +250,7 @@ noinst_HEADERS += \ src/core/or/status.h \ src/core/or/tor_version_st.h \ src/core/or/var_cell_st.h \ + src/core/or/versions.h \ src/core/proto/proto_cell.h \ src/core/proto/proto_control0.h \ src/core/proto/proto_ext_or.h \ @@ -260,6 +271,7 @@ noinst_HEADERS += \ src/feature/dirauth/bwauth.h \ src/feature/dirauth/dircollate.h \ src/feature/dirauth/dirvote.h \ + src/feature/dirauth/dsigs_parse.h \ src/feature/dirauth/guardfraction.h \ src/feature/dirauth/keypin.h \ src/feature/dirauth/ns_detached_signatures_st.h \ @@ -285,6 +297,16 @@ noinst_HEADERS += \ src/feature/dircommon/fp_pair.h \ src/feature/dircommon/vote_timing_st.h \ src/feature/dircommon/voting_schedule.h \ + src/feature/dirparse/authcert_members.i \ + src/feature/dirparse/authcert_parse.h \ + src/feature/dirparse/microdesc_parse.h \ + src/feature/dirparse/ns_parse.h \ + src/feature/dirparse/parsecommon.h \ + src/feature/dirparse/policy_parse.h \ + src/feature/dirparse/routerparse.h \ + src/feature/dirparse/sigcommon.h \ + src/feature/dirparse/signing.h \ + src/feature/dirparse/unparseable.h \ src/feature/hibernate/hibernate.h \ src/feature/hs/hs_cache.h \ src/feature/hs/hs_cell.h \ @@ -320,12 +342,10 @@ noinst_HEADERS += \ src/feature/nodelist/node_st.h \ src/feature/nodelist/nodelist.h \ src/feature/nodelist/node_select.h \ - src/feature/nodelist/parsecommon.h \ src/feature/nodelist/routerinfo.h \ src/feature/nodelist/routerinfo_st.h \ src/feature/nodelist/routerlist.h \ src/feature/nodelist/routerlist_st.h \ - src/feature/nodelist/routerparse.h \ src/feature/nodelist/routerset.h \ src/feature/nodelist/fmt_routerstatus.h \ src/feature/nodelist/routerstatus_st.h \ @@ -348,6 +368,7 @@ noinst_HEADERS += \ src/feature/rend/rendclient.h \ src/feature/rend/rendcommon.h \ src/feature/rend/rendmid.h \ + src/feature/rend/rendparse.h \ src/feature/rend/rendservice.h \ src/feature/stats/geoip_stats.h \ src/feature/stats/rephist.h \ diff --git a/src/core/mainloop/connection.c b/src/core/mainloop/connection.c index ef8c60a3da..3f3b13e069 100644 --- a/src/core/mainloop/connection.c +++ b/src/core/mainloop/connection.c @@ -96,15 +96,14 @@ #include "feature/hs/hs_ident.h" #include "feature/nodelist/nodelist.h" #include "feature/nodelist/routerlist.h" -#include "feature/nodelist/routerparse.h" #include "feature/relay/dns.h" #include "feature/relay/ext_orport.h" #include "feature/relay/routermode.h" #include "feature/rend/rendclient.h" #include "feature/rend/rendcommon.h" -#include "lib/geoip/geoip.h" #include "feature/stats/rephist.h" #include "lib/crypt_ops/crypto_util.h" +#include "lib/geoip/geoip.h" #include "lib/sandbox/sandbox.h" #include "lib/net/buffers_net.h" diff --git a/src/core/or/circuitbuild.c b/src/core/or/circuitbuild.c index 822129d80e..a69457571e 100644 --- a/src/core/or/circuitbuild.c +++ b/src/core/or/circuitbuild.c @@ -61,7 +61,6 @@ #include "feature/nodelist/node_select.h" #include "feature/nodelist/nodelist.h" #include "feature/nodelist/routerlist.h" -#include "feature/nodelist/routerparse.h" #include "feature/nodelist/routerset.h" #include "feature/relay/router.h" #include "feature/relay/routermode.h" diff --git a/src/core/or/policies.c b/src/core/or/policies.c index c3fded1fbd..0eda93c5f3 100644 --- a/src/core/or/policies.c +++ b/src/core/or/policies.c @@ -20,13 +20,13 @@ #include "core/or/or.h" #include "feature/client/bridges.h" #include "app/config/config.h" +#include "core/or/policies.h" +#include "feature/dirparse/policy_parse.h" #include "feature/nodelist/microdesc.h" #include "feature/nodelist/networkstatus.h" #include "feature/nodelist/nodelist.h" -#include "core/or/policies.h" #include "feature/relay/router.h" #include "feature/relay/routermode.h" -#include "feature/nodelist/routerparse.h" #include "lib/geoip/geoip.h" #include "ht.h" #include "lib/encoding/confline.h" diff --git a/src/core/or/protover.c b/src/core/or/protover.c index f0791366fe..e80fbfae81 100644 --- a/src/core/or/protover.c +++ b/src/core/or/protover.c @@ -25,7 +25,7 @@ #include "core/or/or.h" #include "core/or/protover.h" -#include "feature/nodelist/routerparse.h" +#include "core/or/versions.h" #include "lib/tls/tortls.h" #ifndef HAVE_RUST diff --git a/src/core/or/relay.c b/src/core/or/relay.c index 9e45a35246..510d96c648 100644 --- a/src/core/or/relay.c +++ b/src/core/or/relay.c @@ -79,7 +79,6 @@ #include "feature/rend/rendcommon.h" #include "feature/nodelist/describe.h" #include "feature/nodelist/routerlist.h" -#include "feature/nodelist/routerparse.h" #include "core/or/scheduler.h" #include "feature/stats/rephist.h" diff --git a/src/core/or/versions.c b/src/core/or/versions.c new file mode 100644 index 0000000000..06274996a7 --- /dev/null +++ b/src/core/or/versions.c @@ -0,0 +1,422 @@ +/* Copyright (c) 2001 Matej Pfajfar. + * Copyright (c) 2001-2004, Roger Dingledine. + * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson. + * Copyright (c) 2007-2018, The Tor Project, Inc. */ +/* See LICENSE for licensing information */ + +/** + * \file versions.c + * \brief Code to manipulate, parse, and compare Tor versions. + */ +#include "core/or/or.h" + +#include "core/or/protover.h" +#include "core/or/versions.h" +#include "lib/crypt_ops/crypto_util.h" + +#include "core/or/tor_version_st.h" + +/** Return VS_RECOMMENDED if <b>myversion</b> is contained in + * <b>versionlist</b>. Else, return VS_EMPTY if versionlist has no + * entries. Else, return VS_OLD if every member of + * <b>versionlist</b> is newer than <b>myversion</b>. Else, return + * VS_NEW_IN_SERIES if there is at least one member of <b>versionlist</b> in + * the same series (major.minor.micro) as <b>myversion</b>, but no such member + * is newer than <b>myversion.</b>. Else, return VS_NEW if every member of + * <b>versionlist</b> is older than <b>myversion</b>. Else, return + * VS_UNRECOMMENDED. + * + * (versionlist is a comma-separated list of version strings, + * optionally prefixed with "Tor". Versions that can't be parsed are + * ignored.) + */ +version_status_t +tor_version_is_obsolete(const char *myversion, const char *versionlist) +{ + tor_version_t mine, other; + int found_newer = 0, found_older = 0, found_newer_in_series = 0, + found_any_in_series = 0, r, same; + version_status_t ret = VS_UNRECOMMENDED; + smartlist_t *version_sl; + + log_debug(LD_CONFIG,"Checking whether version '%s' is in '%s'", + myversion, versionlist); + + if (tor_version_parse(myversion, &mine)) { + log_err(LD_BUG,"I couldn't parse my own version (%s)", myversion); + tor_assert(0); + } + version_sl = smartlist_new(); + smartlist_split_string(version_sl, versionlist, ",", SPLIT_SKIP_SPACE, 0); + + if (!strlen(versionlist)) { /* no authorities cared or agreed */ + ret = VS_EMPTY; + goto done; + } + + SMARTLIST_FOREACH_BEGIN(version_sl, const char *, cp) { + if (!strcmpstart(cp, "Tor ")) + cp += 4; + + if (tor_version_parse(cp, &other)) { + /* Couldn't parse other; it can't be a match. */ + } else { + same = tor_version_same_series(&mine, &other); + if (same) + found_any_in_series = 1; + r = tor_version_compare(&mine, &other); + if (r==0) { + ret = VS_RECOMMENDED; + goto done; + } else if (r<0) { + found_newer = 1; + if (same) + found_newer_in_series = 1; + } else if (r>0) { + found_older = 1; + } + } + } SMARTLIST_FOREACH_END(cp); + + /* We didn't find the listed version. Is it new or old? */ + if (found_any_in_series && !found_newer_in_series && found_newer) { + ret = VS_NEW_IN_SERIES; + } else if (found_newer && !found_older) { + ret = VS_OLD; + } else if (found_older && !found_newer) { + ret = VS_NEW; + } else { + ret = VS_UNRECOMMENDED; + } + + done: + SMARTLIST_FOREACH(version_sl, char *, version, tor_free(version)); + smartlist_free(version_sl); + return ret; +} + +/** Extract a Tor version from a <b>platform</b> line from a router + * descriptor, and place the result in <b>router_version</b>. + * + * Return 1 on success, -1 on parsing failure, and 0 if the + * platform line does not indicate some version of Tor. + * + * If <b>strict</b> is non-zero, finding any weird version components + * (like negative numbers) counts as a parsing failure. + */ +int +tor_version_parse_platform(const char *platform, + tor_version_t *router_version, + int strict) +{ + char tmp[128]; + char *s, *s2, *start; + + if (strcmpstart(platform,"Tor ")) /* nonstandard Tor; say 0. */ + return 0; + + start = (char *)eat_whitespace(platform+3); + if (!*start) return -1; + s = (char *)find_whitespace(start); /* also finds '\0', which is fine */ + s2 = (char*)eat_whitespace(s); + if (!strcmpstart(s2, "(r") || !strcmpstart(s2, "(git-")) + s = (char*)find_whitespace(s2); + + if ((size_t)(s-start+1) >= sizeof(tmp)) /* too big, no */ + return -1; + strlcpy(tmp, start, s-start+1); + + if (tor_version_parse(tmp, router_version)<0) { + log_info(LD_DIR,"Router version '%s' unparseable.",tmp); + return -1; + } + + if (strict) { + if (router_version->major < 0 || + router_version->minor < 0 || + router_version->micro < 0 || + router_version->patchlevel < 0 || + router_version->svn_revision < 0) { + return -1; + } + } + + return 1; +} + +/** Parse the Tor version of the platform string <b>platform</b>, + * and compare it to the version in <b>cutoff</b>. Return 1 if + * the router is at least as new as the cutoff, else return 0. + */ +int +tor_version_as_new_as(const char *platform, const char *cutoff) +{ + tor_version_t cutoff_version, router_version; + int r; + tor_assert(platform); + + if (tor_version_parse(cutoff, &cutoff_version)<0) { + log_warn(LD_BUG,"cutoff version '%s' unparseable.",cutoff); + return 0; + } + + r = tor_version_parse_platform(platform, &router_version, 0); + if (r == 0) { + /* nonstandard Tor; be safe and say yes */ + return 1; + } else if (r < 0) { + /* unparseable version; be safe and say yes. */ + return 1; + } + + /* Here's why we don't need to do any special handling for svn revisions: + * - If neither has an svn revision, we're fine. + * - If the router doesn't have an svn revision, we can't assume that it + * is "at least" any svn revision, so we need to return 0. + * - If the target version doesn't have an svn revision, any svn revision + * (or none at all) is good enough, so return 1. + * - If both target and router have an svn revision, we compare them. + */ + + return tor_version_compare(&router_version, &cutoff_version) >= 0; +} + +/** Parse a tor version from <b>s</b>, and store the result in <b>out</b>. + * Return 0 on success, -1 on failure. */ +int +tor_version_parse(const char *s, tor_version_t *out) +{ + char *eos=NULL; + const char *cp=NULL; + int ok = 1; + /* Format is: + * "Tor " ? NUM dot NUM [ dot NUM [ ( pre | rc | dot ) NUM ] ] [ - tag ] + */ + tor_assert(s); + tor_assert(out); + + memset(out, 0, sizeof(tor_version_t)); + out->status = VER_RELEASE; + if (!strcasecmpstart(s, "Tor ")) + s += 4; + + cp = s; + +#define NUMBER(m) \ + do { \ + if (!cp || *cp < '0' || *cp > '9') \ + return -1; \ + out->m = (int)tor_parse_uint64(cp, 10, 0, INT32_MAX, &ok, &eos); \ + if (!ok) \ + return -1; \ + if (!eos || eos == cp) \ + return -1; \ + cp = eos; \ + } while (0) + +#define DOT() \ + do { \ + if (*cp != '.') \ + return -1; \ + ++cp; \ + } while (0) + + NUMBER(major); + DOT(); + NUMBER(minor); + if (*cp == 0) + return 0; + else if (*cp == '-') + goto status_tag; + DOT(); + NUMBER(micro); + + /* Get status */ + if (*cp == 0) { + return 0; + } else if (*cp == '.') { + ++cp; + } else if (*cp == '-') { + goto status_tag; + } else if (0==strncmp(cp, "pre", 3)) { + out->status = VER_PRE; + cp += 3; + } else if (0==strncmp(cp, "rc", 2)) { + out->status = VER_RC; + cp += 2; + } else { + return -1; + } + + NUMBER(patchlevel); + + status_tag: + /* Get status tag. */ + if (*cp == '-' || *cp == '.') + ++cp; + eos = (char*) find_whitespace(cp); + if (eos-cp >= (int)sizeof(out->status_tag)) + strlcpy(out->status_tag, cp, sizeof(out->status_tag)); + else { + memcpy(out->status_tag, cp, eos-cp); + out->status_tag[eos-cp] = 0; + } + cp = eat_whitespace(eos); + + if (!strcmpstart(cp, "(r")) { + cp += 2; + out->svn_revision = (int) strtol(cp,&eos,10); + } else if (!strcmpstart(cp, "(git-")) { + char *close_paren = strchr(cp, ')'); + int hexlen; + char digest[DIGEST_LEN]; + if (! close_paren) + return -1; + cp += 5; + if (close_paren-cp > HEX_DIGEST_LEN) + return -1; + hexlen = (int)(close_paren-cp); + memwipe(digest, 0, sizeof(digest)); + if ( hexlen == 0 || (hexlen % 2) == 1) + return -1; + if (base16_decode(digest, hexlen/2, cp, hexlen) != hexlen/2) + return -1; + memcpy(out->git_tag, digest, hexlen/2); + out->git_tag_len = hexlen/2; + } + + return 0; +#undef NUMBER +#undef DOT +} + +/** Compare two tor versions; Return <0 if a < b; 0 if a ==b, >0 if a > + * b. */ +int +tor_version_compare(tor_version_t *a, tor_version_t *b) +{ + int i; + tor_assert(a); + tor_assert(b); + + /* We take this approach to comparison to ensure the same (bogus!) behavior + * on all inputs as we would have seen before bug #21278 was fixed. The + * only important difference here is that this method doesn't cause + * a signed integer underflow. + */ +#define CMP(field) do { \ + unsigned aval = (unsigned) a->field; \ + unsigned bval = (unsigned) b->field; \ + int result = (int) (aval - bval); \ + if (result < 0) \ + return -1; \ + else if (result > 0) \ + return 1; \ + } while (0) + + CMP(major); + CMP(minor); + CMP(micro); + CMP(status); + CMP(patchlevel); + if ((i = strcmp(a->status_tag, b->status_tag))) + return i; + CMP(svn_revision); + CMP(git_tag_len); + if (a->git_tag_len) + return fast_memcmp(a->git_tag, b->git_tag, a->git_tag_len); + else + return 0; + +#undef CMP +} + +/** Return true iff versions <b>a</b> and <b>b</b> belong to the same series. + */ +int +tor_version_same_series(tor_version_t *a, tor_version_t *b) +{ + tor_assert(a); + tor_assert(b); + return ((a->major == b->major) && + (a->minor == b->minor) && + (a->micro == b->micro)); +} + +/** Helper: Given pointers to two strings describing tor versions, return -1 + * if _a precedes _b, 1 if _b precedes _a, and 0 if they are equivalent. + * Used to sort a list of versions. */ +static int +compare_tor_version_str_ptr_(const void **_a, const void **_b) +{ + const char *a = *_a, *b = *_b; + int ca, cb; + tor_version_t va, vb; + ca = tor_version_parse(a, &va); + cb = tor_version_parse(b, &vb); + /* If they both parse, compare them. */ + if (!ca && !cb) + return tor_version_compare(&va,&vb); + /* If one parses, it comes first. */ + if (!ca && cb) + return -1; + if (ca && !cb) + return 1; + /* If neither parses, compare strings. Also, the directory server admin + ** needs to be smacked upside the head. But Tor is tolerant and gentle. */ + return strcmp(a,b); +} + +/** Sort a list of string-representations of versions in ascending order. */ +void +sort_version_list(smartlist_t *versions, int remove_duplicates) +{ + smartlist_sort(versions, compare_tor_version_str_ptr_); + + if (remove_duplicates) + smartlist_uniq(versions, compare_tor_version_str_ptr_, tor_free_); +} + +/** Summarize the protocols listed in <b>protocols</b> into <b>out</b>, + * falling back or correcting them based on <b>version</b> as appropriate. + */ +void +summarize_protover_flags(protover_summary_flags_t *out, + const char *protocols, + const char *version) +{ + tor_assert(out); + memset(out, 0, sizeof(*out)); + if (protocols) { + out->protocols_known = 1; + out->supports_extend2_cells = + protocol_list_supports_protocol(protocols, PRT_RELAY, 2); + out->supports_ed25519_link_handshake_compat = + protocol_list_supports_protocol(protocols, PRT_LINKAUTH, 3); + out->supports_ed25519_link_handshake_any = + protocol_list_supports_protocol_or_later(protocols, PRT_LINKAUTH, 3); + out->supports_ed25519_hs_intro = + protocol_list_supports_protocol(protocols, PRT_HSINTRO, 4); + out->supports_v3_hsdir = + protocol_list_supports_protocol(protocols, PRT_HSDIR, + PROTOVER_HSDIR_V3); + out->supports_v3_rendezvous_point = + protocol_list_supports_protocol(protocols, PRT_HSREND, + PROTOVER_HS_RENDEZVOUS_POINT_V3); + } + if (version && !strcmpstart(version, "Tor ")) { + if (!out->protocols_known) { + /* The version is a "Tor" version, and where there is no + * list of protocol versions that we should be looking at instead. */ + + out->supports_extend2_cells = + tor_version_as_new_as(version, "0.2.4.8-alpha"); + out->protocols_known = 1; + } else { + /* Bug #22447 forces us to filter on this version. */ + if (!tor_version_as_new_as(version, "0.3.0.8")) { + out->supports_v3_hsdir = 0; + } + } + } +} diff --git a/src/core/or/versions.h b/src/core/or/versions.h new file mode 100644 index 0000000000..0c773f3f4c --- /dev/null +++ b/src/core/or/versions.h @@ -0,0 +1,44 @@ +/* Copyright (c) 2001 Matej Pfajfar. + * Copyright (c) 2001-2004, Roger Dingledine. + * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson. + * Copyright (c) 2007-2018, The Tor Project, Inc. */ +/* See LICENSE for licensing information */ + +/** + * \file versions.h + * \brief Header file for versions.c. + **/ + +#ifndef TOR_VERSIONS_H +#define TOR_VERSIONS_H + +/** Possible statuses of a version of Tor, given opinions from the directory + * servers. */ +typedef enum version_status_t { + VS_RECOMMENDED=0, /**< This version is listed as recommended. */ + VS_OLD=1, /**< This version is older than any recommended version. */ + VS_NEW=2, /**< This version is newer than any recommended version. */ + VS_NEW_IN_SERIES=3, /**< This version is newer than any recommended version + * in its series, but later recommended versions exist. + */ + VS_UNRECOMMENDED=4, /**< This version is not recommended (general case). */ + VS_EMPTY=5, /**< The version list was empty; no agreed-on versions. */ + VS_UNKNOWN, /**< We have no idea. */ +} version_status_t; + +version_status_t tor_version_is_obsolete(const char *myversion, + const char *versionlist); +int tor_version_parse_platform(const char *platform, + tor_version_t *version_out, + int strict); +int tor_version_as_new_as(const char *platform, const char *cutoff); +int tor_version_parse(const char *s, tor_version_t *out); +int tor_version_compare(tor_version_t *a, tor_version_t *b); +int tor_version_same_series(tor_version_t *a, tor_version_t *b); +void sort_version_list(smartlist_t *lst, int remove_duplicates); + +void summarize_protover_flags(protover_summary_flags_t *out, + const char *protocols, + const char *version); + +#endif /* !defined(TOR_VERSIONS_H) */ diff --git a/src/feature/client/entrynodes.c b/src/feature/client/entrynodes.c index 8ad16af6d6..20208ef613 100644 --- a/src/feature/client/entrynodes.c +++ b/src/feature/client/entrynodes.c @@ -134,9 +134,8 @@ #include "feature/nodelist/microdesc.h" #include "feature/nodelist/networkstatus.h" #include "feature/nodelist/nickname.h" -#include "feature/nodelist/node_select.h" #include "feature/nodelist/nodelist.h" -#include "feature/nodelist/routerparse.h" +#include "feature/nodelist/node_select.h" #include "feature/nodelist/routerset.h" #include "feature/relay/router.h" #include "lib/crypt_ops/crypto_rand.h" diff --git a/src/feature/control/control.c b/src/feature/control/control.c index d02ecbac80..f0db97dc89 100644 --- a/src/feature/control/control.c +++ b/src/feature/control/control.c @@ -52,6 +52,7 @@ #include "core/or/connection_or.h" #include "core/or/policies.h" #include "core/or/reasons.h" +#include "core/or/versions.h" #include "core/proto/proto_control0.h" #include "core/proto/proto_http.h" #include "feature/client/addressmap.h" @@ -77,12 +78,12 @@ #include "feature/nodelist/nodelist.h" #include "feature/nodelist/routerinfo.h" #include "feature/nodelist/routerlist.h" -#include "feature/nodelist/routerparse.h" #include "feature/relay/router.h" #include "feature/relay/routermode.h" #include "feature/relay/selftest.h" #include "feature/rend/rendclient.h" #include "feature/rend/rendcommon.h" +#include "feature/rend/rendparse.h" #include "feature/rend/rendservice.h" #include "feature/stats/geoip_stats.h" #include "feature/stats/predict_ports.h" diff --git a/src/feature/dirauth/bwauth.c b/src/feature/dirauth/bwauth.c index 90497a3b7c..29e0c90962 100644 --- a/src/feature/dirauth/bwauth.c +++ b/src/feature/dirauth/bwauth.c @@ -15,7 +15,7 @@ #include "app/config/config.h" #include "feature/nodelist/networkstatus.h" #include "feature/nodelist/routerlist.h" -#include "feature/nodelist/routerparse.h" +#include "feature/dirparse/ns_parse.h" #include "feature/nodelist/routerinfo_st.h" #include "feature/nodelist/vote_routerstatus_st.h" diff --git a/src/feature/dirauth/dirvote.c b/src/feature/dirauth/dirvote.c index edb0ad2aea..80a5b54737 100644 --- a/src/feature/dirauth/dirvote.c +++ b/src/feature/dirauth/dirvote.c @@ -6,29 +6,33 @@ #define DIRVOTE_PRIVATE #include "core/or/or.h" #include "app/config/config.h" +#include "core/or/policies.h" +#include "core/or/protover.h" +#include "core/or/tor_version_st.h" +#include "core/or/versions.h" +#include "feature/dirauth/bwauth.h" #include "feature/dirauth/dircollate.h" +#include "feature/dirauth/dsigs_parse.h" +#include "feature/dirauth/guardfraction.h" #include "feature/dirauth/recommend_pkg.h" #include "feature/dirauth/voteflags.h" -#include "feature/dircommon/directory.h" -#include "feature/dirclient/dirclient.h" -#include "feature/dirauth/bwauth.h" #include "feature/dircache/dirserv.h" -#include "feature/dirauth/guardfraction.h" +#include "feature/dirclient/dirclient.h" +#include "feature/dircommon/directory.h" +#include "feature/dirparse/microdesc_parse.h" +#include "feature/dirparse/ns_parse.h" +#include "feature/dirparse/parsecommon.h" +#include "feature/dirparse/signing.h" +#include "feature/nodelist/authcert.h" +#include "feature/nodelist/dirlist.h" +#include "feature/nodelist/fmt_routerstatus.h" #include "feature/nodelist/microdesc.h" #include "feature/nodelist/networkstatus.h" #include "feature/nodelist/nodelist.h" -#include "feature/nodelist/parsecommon.h" -#include "core/or/policies.h" -#include "core/or/protover.h" -#include "core/or/tor_version_st.h" -#include "feature/stats/rephist.h" +#include "feature/nodelist/routerlist.h" #include "feature/relay/router.h" #include "feature/relay/routerkeys.h" -#include "feature/nodelist/authcert.h" -#include "feature/nodelist/dirlist.h" -#include "feature/nodelist/routerlist.h" -#include "feature/nodelist/routerparse.h" -#include "feature/nodelist/fmt_routerstatus.h" +#include "feature/stats/rephist.h" #include "feature/client/entrynodes.h" /* needed for guardfraction methods */ #include "feature/nodelist/torcert.h" #include "feature/dircommon/voting_schedule.h" diff --git a/src/feature/dirauth/dsigs_parse.c b/src/feature/dirauth/dsigs_parse.c new file mode 100644 index 0000000000..b0c407567b --- /dev/null +++ b/src/feature/dirauth/dsigs_parse.c @@ -0,0 +1,282 @@ +/* Copyright (c) 2001 Matej Pfajfar. + * Copyright (c) 2001-2004, Roger Dingledine. + * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson. + * Copyright (c) 2007-2018, The Tor Project, Inc. */ +/* See LICENSE for licensing information */ + +/** + * \file dsigs_parse.h + * \brief Code to parse and validate detached-signature objects + **/ + +#include "core/or/or.h" +#include "feature/dirparse/parsecommon.h" +#include "feature/dirparse/unparseable.h" +#include "feature/nodelist/networkstatus.h" +#include "lib/memarea/memarea.h" + +#include "feature/dirauth/dsigs_parse.h" +#include "feature/dirauth/ns_detached_signatures_st.h" +#include "feature/nodelist/document_signature_st.h" + +/** List of tokens recognized in detached networkstatus signature documents. */ +static token_rule_t networkstatus_detached_signature_token_table[] = { + T1_START("consensus-digest", K_CONSENSUS_DIGEST, GE(1), NO_OBJ ), + T("additional-digest", K_ADDITIONAL_DIGEST,GE(3), NO_OBJ ), + T1("valid-after", K_VALID_AFTER, CONCAT_ARGS, NO_OBJ ), + T1("fresh-until", K_FRESH_UNTIL, CONCAT_ARGS, NO_OBJ ), + T1("valid-until", K_VALID_UNTIL, CONCAT_ARGS, NO_OBJ ), + T("additional-signature", K_ADDITIONAL_SIGNATURE, GE(4), NEED_OBJ ), + T1N("directory-signature", K_DIRECTORY_SIGNATURE, GE(2), NEED_OBJ ), + END_OF_TABLE +}; + +/** Return the common_digests_t that holds the digests of the + * <b>flavor_name</b>-flavored networkstatus according to the detached + * signatures document <b>sigs</b>, allocating a new common_digests_t as + * needed. */ +static common_digests_t * +detached_get_digests(ns_detached_signatures_t *sigs, const char *flavor_name) +{ + common_digests_t *d = strmap_get(sigs->digests, flavor_name); + if (!d) { + d = tor_malloc_zero(sizeof(common_digests_t)); + strmap_set(sigs->digests, flavor_name, d); + } + return d; +} + +/** Return the list of signatures of the <b>flavor_name</b>-flavored + * networkstatus according to the detached signatures document <b>sigs</b>, + * allocating a new common_digests_t as needed. */ +static smartlist_t * +detached_get_signatures(ns_detached_signatures_t *sigs, + const char *flavor_name) +{ + smartlist_t *sl = strmap_get(sigs->signatures, flavor_name); + if (!sl) { + sl = smartlist_new(); + strmap_set(sigs->signatures, flavor_name, sl); + } + return sl; +} + +/** Parse a detached v3 networkstatus signature document between <b>s</b> and + * <b>eos</b> and return the result. Return -1 on failure. */ +ns_detached_signatures_t * +networkstatus_parse_detached_signatures(const char *s, const char *eos) +{ + /* XXXX there is too much duplicate shared between this function and + * networkstatus_parse_vote_from_string(). */ + directory_token_t *tok; + memarea_t *area = NULL; + common_digests_t *digests; + + smartlist_t *tokens = smartlist_new(); + ns_detached_signatures_t *sigs = + tor_malloc_zero(sizeof(ns_detached_signatures_t)); + sigs->digests = strmap_new(); + sigs->signatures = strmap_new(); + + if (!eos) + eos = s + strlen(s); + + area = memarea_new(); + if (tokenize_string(area,s, eos, tokens, + networkstatus_detached_signature_token_table, 0)) { + log_warn(LD_DIR, "Error tokenizing detached networkstatus signatures"); + goto err; + } + + /* Grab all the digest-like tokens. */ + SMARTLIST_FOREACH_BEGIN(tokens, directory_token_t *, _tok) { + const char *algname; + digest_algorithm_t alg; + const char *flavor; + const char *hexdigest; + size_t expected_length, digest_length; + + tok = _tok; + + if (tok->tp == K_CONSENSUS_DIGEST) { + algname = "sha1"; + alg = DIGEST_SHA1; + flavor = "ns"; + hexdigest = tok->args[0]; + } else if (tok->tp == K_ADDITIONAL_DIGEST) { + int a = crypto_digest_algorithm_parse_name(tok->args[1]); + if (a<0) { + log_warn(LD_DIR, "Unrecognized algorithm name %s", tok->args[0]); + continue; + } + alg = (digest_algorithm_t) a; + flavor = tok->args[0]; + algname = tok->args[1]; + hexdigest = tok->args[2]; + } else { + continue; + } + + digest_length = crypto_digest_algorithm_get_length(alg); + expected_length = digest_length * 2; /* hex encoding */ + + if (strlen(hexdigest) != expected_length) { + log_warn(LD_DIR, "Wrong length on consensus-digest in detached " + "networkstatus signatures"); + goto err; + } + digests = detached_get_digests(sigs, flavor); + tor_assert(digests); + if (!tor_mem_is_zero(digests->d[alg], digest_length)) { + log_warn(LD_DIR, "Multiple digests for %s with %s on detached " + "signatures document", flavor, algname); + continue; + } + if (base16_decode(digests->d[alg], digest_length, + hexdigest, strlen(hexdigest)) != (int) digest_length) { + log_warn(LD_DIR, "Bad encoding on consensus-digest in detached " + "networkstatus signatures"); + goto err; + } + } SMARTLIST_FOREACH_END(_tok); + + tok = find_by_keyword(tokens, K_VALID_AFTER); + if (parse_iso_time(tok->args[0], &sigs->valid_after)) { + log_warn(LD_DIR, "Bad valid-after in detached networkstatus signatures"); + goto err; + } + + tok = find_by_keyword(tokens, K_FRESH_UNTIL); + if (parse_iso_time(tok->args[0], &sigs->fresh_until)) { + log_warn(LD_DIR, "Bad fresh-until in detached networkstatus signatures"); + goto err; + } + + tok = find_by_keyword(tokens, K_VALID_UNTIL); + if (parse_iso_time(tok->args[0], &sigs->valid_until)) { + log_warn(LD_DIR, "Bad valid-until in detached networkstatus signatures"); + goto err; + } + + SMARTLIST_FOREACH_BEGIN(tokens, directory_token_t *, _tok) { + const char *id_hexdigest; + const char *sk_hexdigest; + const char *algname; + const char *flavor; + digest_algorithm_t alg; + + char id_digest[DIGEST_LEN]; + char sk_digest[DIGEST_LEN]; + smartlist_t *siglist; + document_signature_t *sig; + int is_duplicate; + + tok = _tok; + if (tok->tp == K_DIRECTORY_SIGNATURE) { + tor_assert(tok->n_args >= 2); + flavor = "ns"; + algname = "sha1"; + id_hexdigest = tok->args[0]; + sk_hexdigest = tok->args[1]; + } else if (tok->tp == K_ADDITIONAL_SIGNATURE) { + tor_assert(tok->n_args >= 4); + flavor = tok->args[0]; + algname = tok->args[1]; + id_hexdigest = tok->args[2]; + sk_hexdigest = tok->args[3]; + } else { + continue; + } + + { + int a = crypto_digest_algorithm_parse_name(algname); + if (a<0) { + log_warn(LD_DIR, "Unrecognized algorithm name %s", algname); + continue; + } + alg = (digest_algorithm_t) a; + } + + if (!tok->object_type || + strcmp(tok->object_type, "SIGNATURE") || + tok->object_size < 128 || tok->object_size > 512) { + log_warn(LD_DIR, "Bad object type or length on directory-signature"); + goto err; + } + + if (strlen(id_hexdigest) != HEX_DIGEST_LEN || + base16_decode(id_digest, sizeof(id_digest), + id_hexdigest, HEX_DIGEST_LEN) != sizeof(id_digest)) { + log_warn(LD_DIR, "Error decoding declared identity %s in " + "network-status vote.", escaped(id_hexdigest)); + goto err; + } + if (strlen(sk_hexdigest) != HEX_DIGEST_LEN || + base16_decode(sk_digest, sizeof(sk_digest), + sk_hexdigest, HEX_DIGEST_LEN) != sizeof(sk_digest)) { + log_warn(LD_DIR, "Error decoding declared signing key digest %s in " + "network-status vote.", escaped(sk_hexdigest)); + goto err; + } + + siglist = detached_get_signatures(sigs, flavor); + is_duplicate = 0; + SMARTLIST_FOREACH(siglist, document_signature_t *, dsig, { + if (dsig->alg == alg && + tor_memeq(id_digest, dsig->identity_digest, DIGEST_LEN) && + tor_memeq(sk_digest, dsig->signing_key_digest, DIGEST_LEN)) { + is_duplicate = 1; + } + }); + if (is_duplicate) { + log_warn(LD_DIR, "Two signatures with identical keys and algorithm " + "found."); + continue; + } + + sig = tor_malloc_zero(sizeof(document_signature_t)); + sig->alg = alg; + memcpy(sig->identity_digest, id_digest, DIGEST_LEN); + memcpy(sig->signing_key_digest, sk_digest, DIGEST_LEN); + if (tok->object_size >= INT_MAX || tok->object_size >= SIZE_T_CEILING) { + tor_free(sig); + goto err; + } + sig->signature = tor_memdup(tok->object_body, tok->object_size); + sig->signature_len = (int) tok->object_size; + + smartlist_add(siglist, sig); + } SMARTLIST_FOREACH_END(_tok); + + goto done; + err: + ns_detached_signatures_free(sigs); + sigs = NULL; + done: + SMARTLIST_FOREACH(tokens, directory_token_t *, t, token_clear(t)); + smartlist_free(tokens); + if (area) { + DUMP_AREA(area, "detached signatures"); + memarea_drop_all(area); + } + return sigs; +} + +/** Release all storage held in <b>s</b>. */ +void +ns_detached_signatures_free_(ns_detached_signatures_t *s) +{ + if (!s) + return; + if (s->signatures) { + STRMAP_FOREACH(s->signatures, flavor, smartlist_t *, sigs) { + SMARTLIST_FOREACH(sigs, document_signature_t *, sig, + document_signature_free(sig)); + smartlist_free(sigs); + } STRMAP_FOREACH_END; + strmap_free(s->signatures, NULL); + strmap_free(s->digests, tor_free_); + } + + tor_free(s); +} diff --git a/src/feature/dirauth/dsigs_parse.h b/src/feature/dirauth/dsigs_parse.h new file mode 100644 index 0000000000..ffb2ac0361 --- /dev/null +++ b/src/feature/dirauth/dsigs_parse.h @@ -0,0 +1,22 @@ +/* Copyright (c) 2001 Matej Pfajfar. + * Copyright (c) 2001-2004, Roger Dingledine. + * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson. + * Copyright (c) 2007-2018, The Tor Project, Inc. */ +/* See LICENSE for licensing information */ + +/** + * \file dsigs_parse.h + * \brief Header file for dsigs_parse.c. + **/ + +#ifndef TOR_DSIGS_PARSE_H +#define TOR_DSIGS_PARSE_H + +ns_detached_signatures_t *networkstatus_parse_detached_signatures( + const char *s, const char *eos); + +void ns_detached_signatures_free_(ns_detached_signatures_t *s); +#define ns_detached_signatures_free(s) \ + FREE_AND_NULL(ns_detached_signatures_t, ns_detached_signatures_free_, (s)) + +#endif diff --git a/src/feature/dirauth/guardfraction.c b/src/feature/dirauth/guardfraction.c index 60ba316cfe..1734d0a13c 100644 --- a/src/feature/dirauth/guardfraction.c +++ b/src/feature/dirauth/guardfraction.c @@ -12,7 +12,7 @@ #include "core/or/or.h" #include "feature/dirauth/guardfraction.h" #include "feature/nodelist/networkstatus.h" -#include "feature/nodelist/routerparse.h" +#include "feature/dirparse/ns_parse.h" #include "feature/nodelist/vote_routerstatus_st.h" diff --git a/src/feature/dirauth/process_descs.c b/src/feature/dirauth/process_descs.c index 823a1b8791..c379f25bdd 100644 --- a/src/feature/dirauth/process_descs.c +++ b/src/feature/dirauth/process_descs.c @@ -17,6 +17,7 @@ #include "app/config/config.h" #include "core/or/policies.h" +#include "core/or/versions.h" #include "feature/dirauth/keypin.h" #include "feature/dirauth/reachability.h" #include "feature/dirclient/dlstatus.h" @@ -26,7 +27,7 @@ #include "feature/nodelist/nodelist.h" #include "feature/nodelist/routerinfo.h" #include "feature/nodelist/routerlist.h" -#include "feature/nodelist/routerparse.h" +#include "feature/dirparse/routerparse.h" #include "feature/nodelist/torcert.h" #include "feature/relay/router.h" diff --git a/src/feature/dircache/consdiffmgr.c b/src/feature/dircache/consdiffmgr.c index 304b64f3b6..e79aad6efb 100644 --- a/src/feature/dircache/consdiffmgr.c +++ b/src/feature/dircache/consdiffmgr.c @@ -20,7 +20,7 @@ #include "feature/dircache/consdiffmgr.h" #include "core/mainloop/cpuworker.h" #include "feature/nodelist/networkstatus.h" -#include "feature/nodelist/routerparse.h" +#include "feature/dirparse/ns_parse.h" #include "lib/evloop/compat_libevent.h" #include "lib/evloop/workqueue.h" #include "lib/compress/compress.h" diff --git a/src/feature/dircommon/consdiff.c b/src/feature/dircommon/consdiff.c index 1823dc07fb..f8ced8503f 100644 --- a/src/feature/dircommon/consdiff.c +++ b/src/feature/dircommon/consdiff.c @@ -41,7 +41,7 @@ #include "core/or/or.h" #include "feature/dircommon/consdiff.h" #include "lib/memarea/memarea.h" -#include "feature/nodelist/routerparse.h" +#include "feature/dirparse/ns_parse.h" static const char* ns_diff_version = "network-status-diff-version 1"; static const char* hash_token = "hash"; diff --git a/src/feature/dirparse/authcert_members.i b/src/feature/dirparse/authcert_members.i new file mode 100644 index 0000000000..08cffca97a --- /dev/null +++ b/src/feature/dirparse/authcert_members.i @@ -0,0 +1,13 @@ +/* + * List of tokens common to V3 authority certificates and V3 consensuses. + */ + T1("dir-key-certificate-version", K_DIR_KEY_CERTIFICATE_VERSION, + GE(1), NO_OBJ ), + T1("dir-identity-key", K_DIR_IDENTITY_KEY, NO_ARGS, NEED_KEY ), + T1("dir-key-published",K_DIR_KEY_PUBLISHED, CONCAT_ARGS, NO_OBJ), + T1("dir-key-expires", K_DIR_KEY_EXPIRES, CONCAT_ARGS, NO_OBJ), + T1("dir-signing-key", K_DIR_SIGNING_KEY, NO_ARGS, NEED_KEY ), + T1("dir-key-crosscert", K_DIR_KEY_CROSSCERT, NO_ARGS, NEED_OBJ ), + T1("dir-key-certification", K_DIR_KEY_CERTIFICATION, + NO_ARGS, NEED_OBJ), + T01("dir-address", K_DIR_ADDRESS, GE(1), NO_OBJ), diff --git a/src/feature/dirparse/authcert_parse.c b/src/feature/dirparse/authcert_parse.c new file mode 100644 index 0000000000..2ba46bb8fa --- /dev/null +++ b/src/feature/dirparse/authcert_parse.c @@ -0,0 +1,207 @@ +/* Copyright (c) 2001 Matej Pfajfar. + * Copyright (c) 2001-2004, Roger Dingledine. + * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson. + * Copyright (c) 2007-2018, The Tor Project, Inc. */ +/* See LICENSE for licensing information */ + +#include "core/or/or.h" +#include "feature/dirparse/authcert_parse.h" +#include "feature/dirparse/parsecommon.h" +#include "feature/dirparse/sigcommon.h" +#include "feature/dirparse/unparseable.h" +#include "feature/nodelist/authcert.h" +#include "lib/memarea/memarea.h" + +#include "feature/nodelist/authority_cert_st.h" + +/** List of tokens recognized in V3 authority certificates. */ +static token_rule_t dir_key_certificate_table[] = { +#include "feature/dirparse/authcert_members.i" + T1("fingerprint", K_FINGERPRINT, CONCAT_ARGS, NO_OBJ ), + END_OF_TABLE +}; + +/** Parse a key certificate from <b>s</b>; point <b>end-of-string</b> to + * the first character after the certificate. */ +authority_cert_t * +authority_cert_parse_from_string(const char *s, const char **end_of_string) +{ + /** Reject any certificate at least this big; it is probably an overflow, an + * attack, a bug, or some other nonsense. */ +#define MAX_CERT_SIZE (128*1024) + + authority_cert_t *cert = NULL, *old_cert; + smartlist_t *tokens = NULL; + char digest[DIGEST_LEN]; + directory_token_t *tok; + char fp_declared[DIGEST_LEN]; + char *eos; + size_t len; + int found; + memarea_t *area = NULL; + const char *s_dup = s; + + s = eat_whitespace(s); + eos = strstr(s, "\ndir-key-certification"); + if (! eos) { + log_warn(LD_DIR, "No signature found on key certificate"); + return NULL; + } + eos = strstr(eos, "\n-----END SIGNATURE-----\n"); + if (! eos) { + log_warn(LD_DIR, "No end-of-signature found on key certificate"); + return NULL; + } + eos = strchr(eos+2, '\n'); + tor_assert(eos); + ++eos; + len = eos - s; + + if (len > MAX_CERT_SIZE) { + log_warn(LD_DIR, "Certificate is far too big (at %lu bytes long); " + "rejecting", (unsigned long)len); + return NULL; + } + + tokens = smartlist_new(); + area = memarea_new(); + if (tokenize_string(area,s, eos, tokens, dir_key_certificate_table, 0) < 0) { + log_warn(LD_DIR, "Error tokenizing key certificate"); + goto err; + } + if (router_get_hash_impl(s, strlen(s), digest, "dir-key-certificate-version", + "\ndir-key-certification", '\n', DIGEST_SHA1) < 0) + goto err; + tok = smartlist_get(tokens, 0); + if (tok->tp != K_DIR_KEY_CERTIFICATE_VERSION || strcmp(tok->args[0], "3")) { + log_warn(LD_DIR, + "Key certificate does not begin with a recognized version (3)."); + goto err; + } + + cert = tor_malloc_zero(sizeof(authority_cert_t)); + memcpy(cert->cache_info.signed_descriptor_digest, digest, DIGEST_LEN); + + tok = find_by_keyword(tokens, K_DIR_SIGNING_KEY); + tor_assert(tok->key); + cert->signing_key = tok->key; + tok->key = NULL; + if (crypto_pk_get_digest(cert->signing_key, cert->signing_key_digest)) + goto err; + + tok = find_by_keyword(tokens, K_DIR_IDENTITY_KEY); + tor_assert(tok->key); + cert->identity_key = tok->key; + tok->key = NULL; + + tok = find_by_keyword(tokens, K_FINGERPRINT); + tor_assert(tok->n_args); + if (base16_decode(fp_declared, DIGEST_LEN, tok->args[0], + strlen(tok->args[0])) != DIGEST_LEN) { + log_warn(LD_DIR, "Couldn't decode key certificate fingerprint %s", + escaped(tok->args[0])); + goto err; + } + + if (crypto_pk_get_digest(cert->identity_key, + cert->cache_info.identity_digest)) + goto err; + + if (tor_memneq(cert->cache_info.identity_digest, fp_declared, DIGEST_LEN)) { + log_warn(LD_DIR, "Digest of certificate key didn't match declared " + "fingerprint"); + goto err; + } + + tok = find_opt_by_keyword(tokens, K_DIR_ADDRESS); + if (tok) { + struct in_addr in; + char *address = NULL; + tor_assert(tok->n_args); + /* XXX++ use some tor_addr parse function below instead. -RD */ + if (tor_addr_port_split(LOG_WARN, tok->args[0], &address, + &cert->dir_port) < 0 || + tor_inet_aton(address, &in) == 0) { + log_warn(LD_DIR, "Couldn't parse dir-address in certificate"); + tor_free(address); + goto err; + } + cert->addr = ntohl(in.s_addr); + tor_free(address); + } + + tok = find_by_keyword(tokens, K_DIR_KEY_PUBLISHED); + if (parse_iso_time(tok->args[0], &cert->cache_info.published_on) < 0) { + goto err; + } + tok = find_by_keyword(tokens, K_DIR_KEY_EXPIRES); + if (parse_iso_time(tok->args[0], &cert->expires) < 0) { + goto err; + } + + tok = smartlist_get(tokens, smartlist_len(tokens)-1); + if (tok->tp != K_DIR_KEY_CERTIFICATION) { + log_warn(LD_DIR, "Certificate didn't end with dir-key-certification."); + goto err; + } + + /* If we already have this cert, don't bother checking the signature. */ + old_cert = authority_cert_get_by_digests( + cert->cache_info.identity_digest, + cert->signing_key_digest); + found = 0; + if (old_cert) { + /* XXXX We could just compare signed_descriptor_digest, but that wouldn't + * buy us much. */ + if (old_cert->cache_info.signed_descriptor_len == len && + old_cert->cache_info.signed_descriptor_body && + tor_memeq(s, old_cert->cache_info.signed_descriptor_body, len)) { + log_debug(LD_DIR, "We already checked the signature on this " + "certificate; no need to do so again."); + found = 1; + } + } + if (!found) { + if (check_signature_token(digest, DIGEST_LEN, tok, cert->identity_key, 0, + "key certificate")) { + goto err; + } + + tok = find_by_keyword(tokens, K_DIR_KEY_CROSSCERT); + if (check_signature_token(cert->cache_info.identity_digest, + DIGEST_LEN, + tok, + cert->signing_key, + CST_NO_CHECK_OBJTYPE, + "key cross-certification")) { + goto err; + } + } + + cert->cache_info.signed_descriptor_len = len; + cert->cache_info.signed_descriptor_body = tor_malloc(len+1); + memcpy(cert->cache_info.signed_descriptor_body, s, len); + cert->cache_info.signed_descriptor_body[len] = 0; + cert->cache_info.saved_location = SAVED_NOWHERE; + + if (end_of_string) { + *end_of_string = eat_whitespace(eos); + } + SMARTLIST_FOREACH(tokens, directory_token_t *, t, token_clear(t)); + smartlist_free(tokens); + if (area) { + DUMP_AREA(area, "authority cert"); + memarea_drop_all(area); + } + return cert; + err: + dump_desc(s_dup, "authority cert"); + authority_cert_free(cert); + SMARTLIST_FOREACH(tokens, directory_token_t *, t, token_clear(t)); + smartlist_free(tokens); + if (area) { + DUMP_AREA(area, "authority cert"); + memarea_drop_all(area); + } + return NULL; +} diff --git a/src/feature/dirparse/authcert_parse.h b/src/feature/dirparse/authcert_parse.h new file mode 100644 index 0000000000..f63525e04d --- /dev/null +++ b/src/feature/dirparse/authcert_parse.h @@ -0,0 +1,18 @@ +/* Copyright (c) 2001 Matej Pfajfar. + * Copyright (c) 2001-2004, Roger Dingledine. + * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson. + * Copyright (c) 2007-2018, The Tor Project, Inc. */ +/* See LICENSE for licensing information */ + +/** + * \file authcert_parse.h + * \brief Header file for authcert_parse.c. + **/ + +#ifndef TOR_AUTHCERT_PARSE_H +#define TOR_AUTHCERT_PARSE_H + +authority_cert_t *authority_cert_parse_from_string(const char *s, + const char **end_of_string); + +#endif /* !defined(TOR_AUTHCERT_PARSE_H) */ diff --git a/src/feature/dirparse/microdesc_parse.c b/src/feature/dirparse/microdesc_parse.c new file mode 100644 index 0000000000..005d2c53d0 --- /dev/null +++ b/src/feature/dirparse/microdesc_parse.c @@ -0,0 +1,267 @@ +/* Copyright (c) 2001 Matej Pfajfar. + * Copyright (c) 2001-2004, Roger Dingledine. + * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson. + * Copyright (c) 2007-2018, The Tor Project, Inc. */ +/* See LICENSE for licensing information */ + +/** + * \file microdesc_parse.c + * \brief Code to parse and validate microdescriptors. + **/ + +#include "core/or/or.h" + +#include "app/config/config.h" +#include "core/or/policies.h" +#include "feature/dirparse/microdesc_parse.h" +#include "feature/dirparse/parsecommon.h" +#include "feature/dirparse/routerparse.h" +#include "feature/nodelist/microdesc.h" +#include "feature/nodelist/nickname.h" +#include "feature/relay/router.h" +#include "lib/crypt_ops/crypto_curve25519.h" +#include "lib/crypt_ops/crypto_ed25519.h" +#include "lib/crypt_ops/crypto_format.h" +#include "lib/memarea/memarea.h" + +#include "feature/nodelist/microdesc_st.h" + +/** List of tokens recognized in microdescriptors */ +static token_rule_t microdesc_token_table[] = { + T1_START("onion-key", K_ONION_KEY, NO_ARGS, NEED_KEY_1024), + T01("ntor-onion-key", K_ONION_KEY_NTOR, GE(1), NO_OBJ ), + T0N("id", K_ID, GE(2), NO_OBJ ), + T0N("a", K_A, GE(1), NO_OBJ ), + T01("family", K_FAMILY, ARGS, NO_OBJ ), + T01("p", K_P, CONCAT_ARGS, NO_OBJ ), + T01("p6", K_P6, CONCAT_ARGS, NO_OBJ ), + A01("@last-listed", A_LAST_LISTED, CONCAT_ARGS, NO_OBJ ), + END_OF_TABLE +}; + +/** Assuming that s starts with a microdesc, return the start of the + * *NEXT* one. Return NULL on "not found." */ +static const char * +find_start_of_next_microdesc(const char *s, const char *eos) +{ + int started_with_annotations; + s = eat_whitespace_eos(s, eos); + if (!s) + return NULL; + +#define CHECK_LENGTH() STMT_BEGIN \ + if (s+32 > eos) \ + return NULL; \ + STMT_END + +#define NEXT_LINE() STMT_BEGIN \ + s = memchr(s, '\n', eos-s); \ + if (!s || s+1 >= eos) \ + return NULL; \ + s++; \ + STMT_END + + CHECK_LENGTH(); + + started_with_annotations = (*s == '@'); + + if (started_with_annotations) { + /* Start by advancing to the first non-annotation line. */ + while (*s == '@') + NEXT_LINE(); + } + CHECK_LENGTH(); + + /* Now we should be pointed at an onion-key line. If we are, then skip + * it. */ + if (!strcmpstart(s, "onion-key")) + NEXT_LINE(); + + /* Okay, now we're pointed at the first line of the microdescriptor which is + not an annotation or onion-key. The next line that _is_ an annotation or + onion-key is the start of the next microdescriptor. */ + while (s+32 < eos) { + if (*s == '@' || !strcmpstart(s, "onion-key")) + return s; + NEXT_LINE(); + } + return NULL; + +#undef CHECK_LENGTH +#undef NEXT_LINE +} + +/** Parse as many microdescriptors as are found from the string starting at + * <b>s</b> and ending at <b>eos</b>. If allow_annotations is set, read any + * annotations we recognize and ignore ones we don't. + * + * If <b>saved_location</b> isn't SAVED_IN_CACHE, make a local copy of each + * descriptor in the body field of each microdesc_t. + * + * Return all newly parsed microdescriptors in a newly allocated + * smartlist_t. If <b>invalid_disgests_out</b> is provided, add a SHA256 + * microdesc digest to it for every microdesc that we found to be badly + * formed. (This may cause duplicates) */ +smartlist_t * +microdescs_parse_from_string(const char *s, const char *eos, + int allow_annotations, + saved_location_t where, + smartlist_t *invalid_digests_out) +{ + smartlist_t *tokens; + smartlist_t *result; + microdesc_t *md = NULL; + memarea_t *area; + const char *start = s; + const char *start_of_next_microdesc; + int flags = allow_annotations ? TS_ANNOTATIONS_OK : 0; + const int copy_body = (where != SAVED_IN_CACHE); + + directory_token_t *tok; + + if (!eos) + eos = s + strlen(s); + + s = eat_whitespace_eos(s, eos); + area = memarea_new(); + result = smartlist_new(); + tokens = smartlist_new(); + + while (s < eos) { + int okay = 0; + + start_of_next_microdesc = find_start_of_next_microdesc(s, eos); + if (!start_of_next_microdesc) + start_of_next_microdesc = eos; + + md = tor_malloc_zero(sizeof(microdesc_t)); + { + const char *cp = tor_memstr(s, start_of_next_microdesc-s, + "onion-key"); + const int no_onion_key = (cp == NULL); + if (no_onion_key) { + cp = s; /* So that we have *some* junk to put in the body */ + } + + md->bodylen = start_of_next_microdesc - cp; + md->saved_location = where; + if (copy_body) + md->body = tor_memdup_nulterm(cp, md->bodylen); + else + md->body = (char*)cp; + md->off = cp - start; + crypto_digest256(md->digest, md->body, md->bodylen, DIGEST_SHA256); + if (no_onion_key) { + log_fn(LOG_PROTOCOL_WARN, LD_DIR, "Malformed or truncated descriptor"); + goto next; + } + } + + if (tokenize_string(area, s, start_of_next_microdesc, tokens, + microdesc_token_table, flags)) { + log_warn(LD_DIR, "Unparseable microdescriptor"); + goto next; + } + + if ((tok = find_opt_by_keyword(tokens, A_LAST_LISTED))) { + if (parse_iso_time(tok->args[0], &md->last_listed)) { + log_warn(LD_DIR, "Bad last-listed time in microdescriptor"); + goto next; + } + } + + tok = find_by_keyword(tokens, K_ONION_KEY); + if (!crypto_pk_public_exponent_ok(tok->key)) { + log_warn(LD_DIR, + "Relay's onion key had invalid exponent."); + goto next; + } + router_set_rsa_onion_pkey(tok->key, &md->onion_pkey, + &md->onion_pkey_len); + crypto_pk_free(tok->key); + + if ((tok = find_opt_by_keyword(tokens, K_ONION_KEY_NTOR))) { + curve25519_public_key_t k; + tor_assert(tok->n_args >= 1); + if (curve25519_public_from_base64(&k, tok->args[0]) < 0) { + log_warn(LD_DIR, "Bogus ntor-onion-key in microdesc"); + goto next; + } + md->onion_curve25519_pkey = + tor_memdup(&k, sizeof(curve25519_public_key_t)); + } + + smartlist_t *id_lines = find_all_by_keyword(tokens, K_ID); + if (id_lines) { + SMARTLIST_FOREACH_BEGIN(id_lines, directory_token_t *, t) { + tor_assert(t->n_args >= 2); + if (!strcmp(t->args[0], "ed25519")) { + if (md->ed25519_identity_pkey) { + log_warn(LD_DIR, "Extra ed25519 key in microdesc"); + smartlist_free(id_lines); + goto next; + } + ed25519_public_key_t k; + if (ed25519_public_from_base64(&k, t->args[1])<0) { + log_warn(LD_DIR, "Bogus ed25519 key in microdesc"); + smartlist_free(id_lines); + goto next; + } + md->ed25519_identity_pkey = tor_memdup(&k, sizeof(k)); + } + } SMARTLIST_FOREACH_END(t); + smartlist_free(id_lines); + } + + { + smartlist_t *a_lines = find_all_by_keyword(tokens, K_A); + if (a_lines) { + find_single_ipv6_orport(a_lines, &md->ipv6_addr, &md->ipv6_orport); + smartlist_free(a_lines); + } + } + + if ((tok = find_opt_by_keyword(tokens, K_FAMILY))) { + int i; + md->family = smartlist_new(); + for (i=0;i<tok->n_args;++i) { + if (!is_legal_nickname_or_hexdigest(tok->args[i])) { + log_warn(LD_DIR, "Illegal nickname %s in family line", + escaped(tok->args[i])); + goto next; + } + smartlist_add_strdup(md->family, tok->args[i]); + } + } + + if ((tok = find_opt_by_keyword(tokens, K_P))) { + md->exit_policy = parse_short_policy(tok->args[0]); + } + if ((tok = find_opt_by_keyword(tokens, K_P6))) { + md->ipv6_exit_policy = parse_short_policy(tok->args[0]); + } + + smartlist_add(result, md); + okay = 1; + + md = NULL; + next: + if (! okay && invalid_digests_out) { + smartlist_add(invalid_digests_out, + tor_memdup(md->digest, DIGEST256_LEN)); + } + microdesc_free(md); + md = NULL; + + SMARTLIST_FOREACH(tokens, directory_token_t *, t, token_clear(t)); + memarea_clear(area); + smartlist_clear(tokens); + s = start_of_next_microdesc; + } + + SMARTLIST_FOREACH(tokens, directory_token_t *, t, token_clear(t)); + memarea_drop_all(area); + smartlist_free(tokens); + + return result; +} diff --git a/src/feature/dirparse/microdesc_parse.h b/src/feature/dirparse/microdesc_parse.h new file mode 100644 index 0000000000..e8f8b2e17e --- /dev/null +++ b/src/feature/dirparse/microdesc_parse.h @@ -0,0 +1,20 @@ +/* Copyright (c) 2001 Matej Pfajfar. + * Copyright (c) 2001-2004, Roger Dingledine. + * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson. + * Copyright (c) 2007-2018, The Tor Project, Inc. */ +/* See LICENSE for licensing information */ + +/** + * \file microdesc_parse.h + * \brief Header file for microdesc_parse.c. + **/ + +#ifndef TOR_MICRODESC_PARSE_H +#define TOR_MICRODESC_PARSE_H + +smartlist_t *microdescs_parse_from_string(const char *s, const char *eos, + int allow_annotations, + saved_location_t where, + smartlist_t *invalid_digests_out); + +#endif diff --git a/src/feature/dirparse/ns_parse.c b/src/feature/dirparse/ns_parse.c new file mode 100644 index 0000000000..72299e8071 --- /dev/null +++ b/src/feature/dirparse/ns_parse.c @@ -0,0 +1,1685 @@ +/* Copyright (c) 2001 Matej Pfajfar. + * Copyright (c) 2001-2004, Roger Dingledine. + * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson. + * Copyright (c) 2007-2018, The Tor Project, Inc. */ +/* See LICENSE for licensing information */ + +/** + * \file routerparse.c + * \brief Code to parse and validate consensus documents and votes. + */ + +#define NS_PARSE_PRIVATE + +#include "core/or/or.h" +#include "app/config/config.h" +#include "core/or/versions.h" +#include "feature/client/entrynodes.h" +#include "feature/dirauth/dirvote.h" +#include "feature/dirparse/authcert_parse.h" +#include "feature/dirparse/ns_parse.h" +#include "feature/dirparse/parsecommon.h" +#include "feature/dirparse/routerparse.h" +#include "feature/dirparse/sigcommon.h" +#include "feature/dirparse/unparseable.h" +#include "feature/hs_common/shared_random_client.h" +#include "feature/nodelist/authcert.h" +#include "feature/nodelist/describe.h" +#include "feature/nodelist/networkstatus.h" +#include "feature/nodelist/nickname.h" +#include "lib/crypt_ops/crypto_format.h" +#include "lib/memarea/memarea.h" + +#include "feature/dirauth/vote_microdesc_hash_st.h" +#include "feature/nodelist/authority_cert_st.h" +#include "feature/nodelist/document_signature_st.h" +#include "feature/nodelist/networkstatus_st.h" +#include "feature/nodelist/networkstatus_voter_info_st.h" +#include "feature/nodelist/vote_routerstatus_st.h" + +#undef log +#include <math.h> + +/** List of tokens recognized in the body part of v3 networkstatus + * documents. */ +static token_rule_t rtrstatus_token_table[] = { + T01("p", K_P, CONCAT_ARGS, NO_OBJ ), + T1( "r", K_R, GE(7), NO_OBJ ), + T0N("a", K_A, GE(1), NO_OBJ ), + T1( "s", K_S, ARGS, NO_OBJ ), + T01("v", K_V, CONCAT_ARGS, NO_OBJ ), + T01("w", K_W, ARGS, NO_OBJ ), + T0N("m", K_M, CONCAT_ARGS, NO_OBJ ), + T0N("id", K_ID, GE(2), NO_OBJ ), + T01("pr", K_PROTO, CONCAT_ARGS, NO_OBJ ), + T0N("opt", K_OPT, CONCAT_ARGS, OBJ_OK ), + END_OF_TABLE +}; + +/** List of tokens recognized in V3 networkstatus votes. */ +static token_rule_t networkstatus_token_table[] = { + T1_START("network-status-version", K_NETWORK_STATUS_VERSION, + GE(1), NO_OBJ ), + T1("vote-status", K_VOTE_STATUS, GE(1), NO_OBJ ), + T1("published", K_PUBLISHED, CONCAT_ARGS, NO_OBJ ), + T1("valid-after", K_VALID_AFTER, CONCAT_ARGS, NO_OBJ ), + T1("fresh-until", K_FRESH_UNTIL, CONCAT_ARGS, NO_OBJ ), + T1("valid-until", K_VALID_UNTIL, CONCAT_ARGS, NO_OBJ ), + T1("voting-delay", K_VOTING_DELAY, GE(2), NO_OBJ ), + T1("known-flags", K_KNOWN_FLAGS, ARGS, NO_OBJ ), + T01("params", K_PARAMS, ARGS, NO_OBJ ), + T( "fingerprint", K_FINGERPRINT, CONCAT_ARGS, NO_OBJ ), + T01("signing-ed25519", K_SIGNING_CERT_ED, NO_ARGS , NEED_OBJ ), + T01("shared-rand-participate",K_SR_FLAG, NO_ARGS, NO_OBJ ), + T0N("shared-rand-commit", K_COMMIT, GE(3), NO_OBJ ), + T01("shared-rand-previous-value", K_PREVIOUS_SRV,EQ(2), NO_OBJ ), + T01("shared-rand-current-value", K_CURRENT_SRV, EQ(2), NO_OBJ ), + T0N("package", K_PACKAGE, CONCAT_ARGS, NO_OBJ ), + T01("recommended-client-protocols", K_RECOMMENDED_CLIENT_PROTOCOLS, + CONCAT_ARGS, NO_OBJ ), + T01("recommended-relay-protocols", K_RECOMMENDED_RELAY_PROTOCOLS, + CONCAT_ARGS, NO_OBJ ), + T01("required-client-protocols", K_REQUIRED_CLIENT_PROTOCOLS, + CONCAT_ARGS, NO_OBJ ), + T01("required-relay-protocols", K_REQUIRED_RELAY_PROTOCOLS, + CONCAT_ARGS, NO_OBJ ), + +#include "feature/dirparse/authcert_members.i" + + T0N("opt", K_OPT, CONCAT_ARGS, OBJ_OK ), + T1( "contact", K_CONTACT, CONCAT_ARGS, NO_OBJ ), + T1( "dir-source", K_DIR_SOURCE, GE(6), NO_OBJ ), + T01("legacy-dir-key", K_LEGACY_DIR_KEY, GE(1), NO_OBJ ), + T1( "known-flags", K_KNOWN_FLAGS, CONCAT_ARGS, NO_OBJ ), + T01("client-versions", K_CLIENT_VERSIONS, CONCAT_ARGS, NO_OBJ ), + T01("server-versions", K_SERVER_VERSIONS, CONCAT_ARGS, NO_OBJ ), + T1( "consensus-methods", K_CONSENSUS_METHODS, GE(1), NO_OBJ ), + + END_OF_TABLE +}; + +/** List of tokens recognized in V3 networkstatus consensuses. */ +static token_rule_t networkstatus_consensus_token_table[] = { + T1_START("network-status-version", K_NETWORK_STATUS_VERSION, + GE(1), NO_OBJ ), + T1("vote-status", K_VOTE_STATUS, GE(1), NO_OBJ ), + T1("valid-after", K_VALID_AFTER, CONCAT_ARGS, NO_OBJ ), + T1("fresh-until", K_FRESH_UNTIL, CONCAT_ARGS, NO_OBJ ), + T1("valid-until", K_VALID_UNTIL, CONCAT_ARGS, NO_OBJ ), + T1("voting-delay", K_VOTING_DELAY, GE(2), NO_OBJ ), + + T0N("opt", K_OPT, CONCAT_ARGS, OBJ_OK ), + + T1N("dir-source", K_DIR_SOURCE, GE(6), NO_OBJ ), + T1N("contact", K_CONTACT, CONCAT_ARGS, NO_OBJ ), + T1N("vote-digest", K_VOTE_DIGEST, GE(1), NO_OBJ ), + + T1( "known-flags", K_KNOWN_FLAGS, CONCAT_ARGS, NO_OBJ ), + + T01("client-versions", K_CLIENT_VERSIONS, CONCAT_ARGS, NO_OBJ ), + T01("server-versions", K_SERVER_VERSIONS, CONCAT_ARGS, NO_OBJ ), + T01("consensus-method", K_CONSENSUS_METHOD, EQ(1), NO_OBJ), + T01("params", K_PARAMS, ARGS, NO_OBJ ), + + T01("shared-rand-previous-value", K_PREVIOUS_SRV, EQ(2), NO_OBJ ), + T01("shared-rand-current-value", K_CURRENT_SRV, EQ(2), NO_OBJ ), + + T01("recommended-client-protocols", K_RECOMMENDED_CLIENT_PROTOCOLS, + CONCAT_ARGS, NO_OBJ ), + T01("recommended-relay-protocols", K_RECOMMENDED_RELAY_PROTOCOLS, + CONCAT_ARGS, NO_OBJ ), + T01("required-client-protocols", K_REQUIRED_CLIENT_PROTOCOLS, + CONCAT_ARGS, NO_OBJ ), + T01("required-relay-protocols", K_REQUIRED_RELAY_PROTOCOLS, + CONCAT_ARGS, NO_OBJ ), + + END_OF_TABLE +}; + +/** List of tokens recognized in the footer of v1 directory footers. */ +static token_rule_t networkstatus_vote_footer_token_table[] = { + T01("directory-footer", K_DIRECTORY_FOOTER, NO_ARGS, NO_OBJ ), + T01("bandwidth-weights", K_BW_WEIGHTS, ARGS, NO_OBJ ), + T( "directory-signature", K_DIRECTORY_SIGNATURE, GE(2), NEED_OBJ ), + END_OF_TABLE +}; + +/** Try to find the start and end of the signed portion of a networkstatus + * document in <b>s</b>. On success, set <b>start_out</b> to the first + * character of the document, and <b>end_out</b> to a position one after the + * final character of the signed document, and return 0. On failure, return + * -1. */ +int +router_get_networkstatus_v3_signed_boundaries(const char *s, + const char **start_out, + const char **end_out) +{ + return router_get_hash_impl_helper(s, strlen(s), + "network-status-version", + "\ndirectory-signature", + ' ', LOG_INFO, + start_out, end_out); +} + +/** Set <b>digest_out</b> to the SHA3-256 digest of the signed portion of the + * networkstatus vote in <b>s</b> -- or of the entirety of <b>s</b> if no + * signed portion can be identified. Return 0 on success, -1 on failure. */ +int +router_get_networkstatus_v3_sha3_as_signed(uint8_t *digest_out, + const char *s) +{ + const char *start, *end; + if (router_get_networkstatus_v3_signed_boundaries(s, &start, &end) < 0) { + start = s; + end = s + strlen(s); + } + tor_assert(start); + tor_assert(end); + return crypto_digest256((char*)digest_out, start, end-start, + DIGEST_SHA3_256); +} + +/** Set <b>digests</b> to all the digests of the consensus document in + * <b>s</b> */ +int +router_get_networkstatus_v3_hashes(const char *s, common_digests_t *digests) +{ + return router_get_hashes_impl(s,strlen(s),digests, + "network-status-version", + "\ndirectory-signature", + ' '); +} + +/** Helper: given a string <b>s</b>, return the start of the next router-status + * object (starting with "r " at the start of a line). If none is found, + * return the start of the directory footer, or the next directory signature. + * If none is found, return the end of the string. */ +static inline const char * +find_start_of_next_routerstatus(const char *s) +{ + const char *eos, *footer, *sig; + if ((eos = strstr(s, "\nr "))) + ++eos; + else + eos = s + strlen(s); + + footer = tor_memstr(s, eos-s, "\ndirectory-footer"); + sig = tor_memstr(s, eos-s, "\ndirectory-signature"); + + if (footer && sig) + return MIN(footer, sig) + 1; + else if (footer) + return footer+1; + else if (sig) + return sig+1; + else + return eos; +} + +/** Parse the GuardFraction string from a consensus or vote. + * + * If <b>vote</b> or <b>vote_rs</b> are set the document getting + * parsed is a vote routerstatus. Otherwise it's a consensus. This is + * the same semantic as in routerstatus_parse_entry_from_string(). */ +STATIC int +routerstatus_parse_guardfraction(const char *guardfraction_str, + networkstatus_t *vote, + vote_routerstatus_t *vote_rs, + routerstatus_t *rs) +{ + int ok; + const char *end_of_header = NULL; + int is_consensus = !vote_rs; + uint32_t guardfraction; + + tor_assert(bool_eq(vote, vote_rs)); + + /* If this info comes from a consensus, but we should't apply + guardfraction, just exit. */ + if (is_consensus && !should_apply_guardfraction(NULL)) { + return 0; + } + + end_of_header = strchr(guardfraction_str, '='); + if (!end_of_header) { + return -1; + } + + guardfraction = (uint32_t)tor_parse_ulong(end_of_header+1, + 10, 0, 100, &ok, NULL); + if (!ok) { + log_warn(LD_DIR, "Invalid GuardFraction %s", escaped(guardfraction_str)); + return -1; + } + + log_debug(LD_GENERAL, "[*] Parsed %s guardfraction '%s' for '%s'.", + is_consensus ? "consensus" : "vote", + guardfraction_str, rs->nickname); + + if (!is_consensus) { /* We are parsing a vote */ + vote_rs->status.guardfraction_percentage = guardfraction; + vote_rs->status.has_guardfraction = 1; + } else { + /* We are parsing a consensus. Only apply guardfraction to guards. */ + if (rs->is_possible_guard) { + rs->guardfraction_percentage = guardfraction; + rs->has_guardfraction = 1; + } else { + log_warn(LD_BUG, "Got GuardFraction for non-guard %s. " + "This is not supposed to happen. Not applying. ", rs->nickname); + } + } + + return 0; +} + +/** Given a string at *<b>s</b>, containing a routerstatus object, and an + * empty smartlist at <b>tokens</b>, parse and return the first router status + * object in the string, and advance *<b>s</b> to just after the end of the + * router status. Return NULL and advance *<b>s</b> on error. + * + * If <b>vote</b> and <b>vote_rs</b> are provided, don't allocate a fresh + * routerstatus but use <b>vote_rs</b> instead. + * + * If <b>consensus_method</b> is nonzero, this routerstatus is part of a + * consensus, and we should parse it according to the method used to + * make that consensus. + * + * Parse according to the syntax used by the consensus flavor <b>flav</b>. + **/ +STATIC routerstatus_t * +routerstatus_parse_entry_from_string(memarea_t *area, + const char **s, smartlist_t *tokens, + networkstatus_t *vote, + vote_routerstatus_t *vote_rs, + int consensus_method, + consensus_flavor_t flav) +{ + const char *eos, *s_dup = *s; + routerstatus_t *rs = NULL; + directory_token_t *tok; + char timebuf[ISO_TIME_LEN+1]; + struct in_addr in; + int offset = 0; + tor_assert(tokens); + tor_assert(bool_eq(vote, vote_rs)); + + if (!consensus_method) + flav = FLAV_NS; + tor_assert(flav == FLAV_NS || flav == FLAV_MICRODESC); + + eos = find_start_of_next_routerstatus(*s); + + if (tokenize_string(area,*s, eos, tokens, rtrstatus_token_table,0)) { + log_warn(LD_DIR, "Error tokenizing router status"); + goto err; + } + if (smartlist_len(tokens) < 1) { + log_warn(LD_DIR, "Impossibly short router status"); + goto err; + } + tok = find_by_keyword(tokens, K_R); + tor_assert(tok->n_args >= 7); /* guaranteed by GE(7) in K_R setup */ + if (flav == FLAV_NS) { + if (tok->n_args < 8) { + log_warn(LD_DIR, "Too few arguments to r"); + goto err; + } + } else if (flav == FLAV_MICRODESC) { + offset = -1; /* There is no descriptor digest in an md consensus r line */ + } + + if (vote_rs) { + rs = &vote_rs->status; + } else { + rs = tor_malloc_zero(sizeof(routerstatus_t)); + } + + if (!is_legal_nickname(tok->args[0])) { + log_warn(LD_DIR, + "Invalid nickname %s in router status; skipping.", + escaped(tok->args[0])); + goto err; + } + strlcpy(rs->nickname, tok->args[0], sizeof(rs->nickname)); + + if (digest_from_base64(rs->identity_digest, tok->args[1])) { + log_warn(LD_DIR, "Error decoding identity digest %s", + escaped(tok->args[1])); + goto err; + } + + if (flav == FLAV_NS) { + if (digest_from_base64(rs->descriptor_digest, tok->args[2])) { + log_warn(LD_DIR, "Error decoding descriptor digest %s", + escaped(tok->args[2])); + goto err; + } + } + + if (tor_snprintf(timebuf, sizeof(timebuf), "%s %s", + tok->args[3+offset], tok->args[4+offset]) < 0 || + parse_iso_time(timebuf, &rs->published_on)<0) { + log_warn(LD_DIR, "Error parsing time '%s %s' [%d %d]", + tok->args[3+offset], tok->args[4+offset], + offset, (int)flav); + goto err; + } + + if (tor_inet_aton(tok->args[5+offset], &in) == 0) { + log_warn(LD_DIR, "Error parsing router address in network-status %s", + escaped(tok->args[5+offset])); + goto err; + } + rs->addr = ntohl(in.s_addr); + + rs->or_port = (uint16_t) tor_parse_long(tok->args[6+offset], + 10,0,65535,NULL,NULL); + rs->dir_port = (uint16_t) tor_parse_long(tok->args[7+offset], + 10,0,65535,NULL,NULL); + + { + smartlist_t *a_lines = find_all_by_keyword(tokens, K_A); + if (a_lines) { + find_single_ipv6_orport(a_lines, &rs->ipv6_addr, &rs->ipv6_orport); + smartlist_free(a_lines); + } + } + + tok = find_opt_by_keyword(tokens, K_S); + if (tok && vote) { + int i; + vote_rs->flags = 0; + for (i=0; i < tok->n_args; ++i) { + int p = smartlist_string_pos(vote->known_flags, tok->args[i]); + if (p >= 0) { + vote_rs->flags |= (UINT64_C(1)<<p); + } else { + log_warn(LD_DIR, "Flags line had a flag %s not listed in known_flags.", + escaped(tok->args[i])); + goto err; + } + } + } else if (tok) { + /* This is a consensus, not a vote. */ + int i; + for (i=0; i < tok->n_args; ++i) { + if (!strcmp(tok->args[i], "Exit")) + rs->is_exit = 1; + else if (!strcmp(tok->args[i], "Stable")) + rs->is_stable = 1; + else if (!strcmp(tok->args[i], "Fast")) + rs->is_fast = 1; + else if (!strcmp(tok->args[i], "Running")) + rs->is_flagged_running = 1; + else if (!strcmp(tok->args[i], "Named")) + rs->is_named = 1; + else if (!strcmp(tok->args[i], "Valid")) + rs->is_valid = 1; + else if (!strcmp(tok->args[i], "Guard")) + rs->is_possible_guard = 1; + else if (!strcmp(tok->args[i], "BadExit")) + rs->is_bad_exit = 1; + else if (!strcmp(tok->args[i], "Authority")) + rs->is_authority = 1; + else if (!strcmp(tok->args[i], "Unnamed") && + consensus_method >= 2) { + /* Unnamed is computed right by consensus method 2 and later. */ + rs->is_unnamed = 1; + } else if (!strcmp(tok->args[i], "HSDir")) { + rs->is_hs_dir = 1; + } else if (!strcmp(tok->args[i], "V2Dir")) { + rs->is_v2_dir = 1; + } + } + /* These are implied true by having been included in a consensus made + * with a given method */ + rs->is_flagged_running = 1; /* Starting with consensus method 4. */ + rs->is_valid = 1; /* Starting with consensus method 24. */ + } + { + const char *protocols = NULL, *version = NULL; + if ((tok = find_opt_by_keyword(tokens, K_PROTO))) { + tor_assert(tok->n_args == 1); + protocols = tok->args[0]; + } + if ((tok = find_opt_by_keyword(tokens, K_V))) { + tor_assert(tok->n_args == 1); + version = tok->args[0]; + if (vote_rs) { + vote_rs->version = tor_strdup(tok->args[0]); + } + } + + summarize_protover_flags(&rs->pv, protocols, version); + } + + /* handle weighting/bandwidth info */ + if ((tok = find_opt_by_keyword(tokens, K_W))) { + int i; + for (i=0; i < tok->n_args; ++i) { + if (!strcmpstart(tok->args[i], "Bandwidth=")) { + int ok; + rs->bandwidth_kb = + (uint32_t)tor_parse_ulong(strchr(tok->args[i], '=')+1, + 10, 0, UINT32_MAX, + &ok, NULL); + if (!ok) { + log_warn(LD_DIR, "Invalid Bandwidth %s", escaped(tok->args[i])); + goto err; + } + rs->has_bandwidth = 1; + } else if (!strcmpstart(tok->args[i], "Measured=") && vote_rs) { + int ok; + vote_rs->measured_bw_kb = + (uint32_t)tor_parse_ulong(strchr(tok->args[i], '=')+1, + 10, 0, UINT32_MAX, &ok, NULL); + if (!ok) { + log_warn(LD_DIR, "Invalid Measured Bandwidth %s", + escaped(tok->args[i])); + goto err; + } + vote_rs->has_measured_bw = 1; + vote->has_measured_bws = 1; + } else if (!strcmpstart(tok->args[i], "Unmeasured=1")) { + rs->bw_is_unmeasured = 1; + } else if (!strcmpstart(tok->args[i], "GuardFraction=")) { + if (routerstatus_parse_guardfraction(tok->args[i], + vote, vote_rs, rs) < 0) { + goto err; + } + } + } + } + + /* parse exit policy summaries */ + if ((tok = find_opt_by_keyword(tokens, K_P))) { + tor_assert(tok->n_args == 1); + if (strcmpstart(tok->args[0], "accept ") && + strcmpstart(tok->args[0], "reject ")) { + log_warn(LD_DIR, "Unknown exit policy summary type %s.", + escaped(tok->args[0])); + goto err; + } + /* XXX weasel: parse this into ports and represent them somehow smart, + * maybe not here but somewhere on if we need it for the client. + * we should still parse it here to check it's valid tho. + */ + rs->exitsummary = tor_strdup(tok->args[0]); + rs->has_exitsummary = 1; + } + + if (vote_rs) { + SMARTLIST_FOREACH_BEGIN(tokens, directory_token_t *, t) { + if (t->tp == K_M && t->n_args) { + vote_microdesc_hash_t *line = + tor_malloc(sizeof(vote_microdesc_hash_t)); + line->next = vote_rs->microdesc; + line->microdesc_hash_line = tor_strdup(t->args[0]); + vote_rs->microdesc = line; + } + if (t->tp == K_ID) { + tor_assert(t->n_args >= 2); + if (!strcmp(t->args[0], "ed25519")) { + vote_rs->has_ed25519_listing = 1; + if (strcmp(t->args[1], "none") && + digest256_from_base64((char*)vote_rs->ed25519_id, + t->args[1])<0) { + log_warn(LD_DIR, "Bogus ed25519 key in networkstatus vote"); + goto err; + } + } + } + if (t->tp == K_PROTO) { + tor_assert(t->n_args == 1); + vote_rs->protocols = tor_strdup(t->args[0]); + } + } SMARTLIST_FOREACH_END(t); + } else if (flav == FLAV_MICRODESC) { + tok = find_opt_by_keyword(tokens, K_M); + if (tok) { + tor_assert(tok->n_args); + if (digest256_from_base64(rs->descriptor_digest, tok->args[0])) { + log_warn(LD_DIR, "Error decoding microdescriptor digest %s", + escaped(tok->args[0])); + goto err; + } + } else { + log_info(LD_BUG, "Found an entry in networkstatus with no " + "microdescriptor digest. (Router %s ($%s) at %s:%d.)", + rs->nickname, hex_str(rs->identity_digest, DIGEST_LEN), + fmt_addr32(rs->addr), rs->or_port); + } + } + + if (!strcasecmp(rs->nickname, UNNAMED_ROUTER_NICKNAME)) + rs->is_named = 0; + + goto done; + err: + dump_desc(s_dup, "routerstatus entry"); + if (rs && !vote_rs) + routerstatus_free(rs); + rs = NULL; + done: + SMARTLIST_FOREACH(tokens, directory_token_t *, t, token_clear(t)); + smartlist_clear(tokens); + if (area) { + DUMP_AREA(area, "routerstatus entry"); + memarea_clear(area); + } + *s = eos; + + return rs; +} + +int +compare_vote_routerstatus_entries(const void **_a, const void **_b) +{ + const vote_routerstatus_t *a = *_a, *b = *_b; + return fast_memcmp(a->status.identity_digest, b->status.identity_digest, + DIGEST_LEN); +} + +/** Verify the bandwidth weights of a network status document */ +int +networkstatus_verify_bw_weights(networkstatus_t *ns, int consensus_method) +{ + int64_t G=0, M=0, E=0, D=0, T=0; + double Wgg, Wgm, Wgd, Wmg, Wmm, Wme, Wmd, Weg, Wem, Wee, Wed; + double Gtotal=0, Mtotal=0, Etotal=0; + const char *casename = NULL; + int valid = 1; + (void) consensus_method; + + const int64_t weight_scale = networkstatus_get_weight_scale_param(ns); + tor_assert(weight_scale >= 1); + Wgg = networkstatus_get_bw_weight(ns, "Wgg", -1); + Wgm = networkstatus_get_bw_weight(ns, "Wgm", -1); + Wgd = networkstatus_get_bw_weight(ns, "Wgd", -1); + Wmg = networkstatus_get_bw_weight(ns, "Wmg", -1); + Wmm = networkstatus_get_bw_weight(ns, "Wmm", -1); + Wme = networkstatus_get_bw_weight(ns, "Wme", -1); + Wmd = networkstatus_get_bw_weight(ns, "Wmd", -1); + Weg = networkstatus_get_bw_weight(ns, "Weg", -1); + Wem = networkstatus_get_bw_weight(ns, "Wem", -1); + Wee = networkstatus_get_bw_weight(ns, "Wee", -1); + Wed = networkstatus_get_bw_weight(ns, "Wed", -1); + + if (Wgg<0 || Wgm<0 || Wgd<0 || Wmg<0 || Wmm<0 || Wme<0 || Wmd<0 || Weg<0 + || Wem<0 || Wee<0 || Wed<0) { + log_warn(LD_BUG, "No bandwidth weights produced in consensus!"); + return 0; + } + + // First, sanity check basic summing properties that hold for all cases + // We use > 1 as the check for these because they are computed as integers. + // Sometimes there are rounding errors. + if (fabs(Wmm - weight_scale) > 1) { + log_warn(LD_BUG, "Wmm=%f != %"PRId64, + Wmm, (weight_scale)); + valid = 0; + } + + if (fabs(Wem - Wee) > 1) { + log_warn(LD_BUG, "Wem=%f != Wee=%f", Wem, Wee); + valid = 0; + } + + if (fabs(Wgm - Wgg) > 1) { + log_warn(LD_BUG, "Wgm=%f != Wgg=%f", Wgm, Wgg); + valid = 0; + } + + if (fabs(Weg - Wed) > 1) { + log_warn(LD_BUG, "Wed=%f != Weg=%f", Wed, Weg); + valid = 0; + } + + if (fabs(Wgg + Wmg - weight_scale) > 0.001*weight_scale) { + log_warn(LD_BUG, "Wgg=%f != %"PRId64" - Wmg=%f", Wgg, + (weight_scale), Wmg); + valid = 0; + } + + if (fabs(Wee + Wme - weight_scale) > 0.001*weight_scale) { + log_warn(LD_BUG, "Wee=%f != %"PRId64" - Wme=%f", Wee, + (weight_scale), Wme); + valid = 0; + } + + if (fabs(Wgd + Wmd + Wed - weight_scale) > 0.001*weight_scale) { + log_warn(LD_BUG, "Wgd=%f + Wmd=%f + Wed=%f != %"PRId64, + Wgd, Wmd, Wed, (weight_scale)); + valid = 0; + } + + Wgg /= weight_scale; + Wgm /= weight_scale; (void) Wgm; // unused from here on. + Wgd /= weight_scale; + + Wmg /= weight_scale; + Wmm /= weight_scale; + Wme /= weight_scale; + Wmd /= weight_scale; + + Weg /= weight_scale; (void) Weg; // unused from here on. + Wem /= weight_scale; (void) Wem; // unused from here on. + Wee /= weight_scale; + Wed /= weight_scale; + + // Then, gather G, M, E, D, T to determine case + SMARTLIST_FOREACH_BEGIN(ns->routerstatus_list, routerstatus_t *, rs) { + int is_exit = 0; + /* Bug #2203: Don't count bad exits as exits for balancing */ + is_exit = rs->is_exit && !rs->is_bad_exit; + if (rs->has_bandwidth) { + T += rs->bandwidth_kb; + if (is_exit && rs->is_possible_guard) { + D += rs->bandwidth_kb; + Gtotal += Wgd*rs->bandwidth_kb; + Mtotal += Wmd*rs->bandwidth_kb; + Etotal += Wed*rs->bandwidth_kb; + } else if (is_exit) { + E += rs->bandwidth_kb; + Mtotal += Wme*rs->bandwidth_kb; + Etotal += Wee*rs->bandwidth_kb; + } else if (rs->is_possible_guard) { + G += rs->bandwidth_kb; + Gtotal += Wgg*rs->bandwidth_kb; + Mtotal += Wmg*rs->bandwidth_kb; + } else { + M += rs->bandwidth_kb; + Mtotal += Wmm*rs->bandwidth_kb; + } + } else { + log_warn(LD_BUG, "Missing consensus bandwidth for router %s", + routerstatus_describe(rs)); + } + } SMARTLIST_FOREACH_END(rs); + + // Finally, check equality conditions depending upon case 1, 2 or 3 + // Full equality cases: 1, 3b + // Partial equality cases: 2b (E=G), 3a (M=E) + // Fully unknown: 2a + if (3*E >= T && 3*G >= T) { + // Case 1: Neither are scarce + casename = "Case 1"; + if (fabs(Etotal-Mtotal) > 0.01*MAX(Etotal,Mtotal)) { + log_warn(LD_DIR, + "Bw Weight Failure for %s: Etotal %f != Mtotal %f. " + "G=%"PRId64" M=%"PRId64" E=%"PRId64" D=%"PRId64 + " T=%"PRId64". " + "Wgg=%f Wgd=%f Wmg=%f Wme=%f Wmd=%f Wee=%f Wed=%f", + casename, Etotal, Mtotal, + (G), (M), (E), + (D), (T), + Wgg, Wgd, Wmg, Wme, Wmd, Wee, Wed); + valid = 0; + } + if (fabs(Etotal-Gtotal) > 0.01*MAX(Etotal,Gtotal)) { + log_warn(LD_DIR, + "Bw Weight Failure for %s: Etotal %f != Gtotal %f. " + "G=%"PRId64" M=%"PRId64" E=%"PRId64" D=%"PRId64 + " T=%"PRId64". " + "Wgg=%f Wgd=%f Wmg=%f Wme=%f Wmd=%f Wee=%f Wed=%f", + casename, Etotal, Gtotal, + (G), (M), (E), + (D), (T), + Wgg, Wgd, Wmg, Wme, Wmd, Wee, Wed); + valid = 0; + } + if (fabs(Gtotal-Mtotal) > 0.01*MAX(Gtotal,Mtotal)) { + log_warn(LD_DIR, + "Bw Weight Failure for %s: Mtotal %f != Gtotal %f. " + "G=%"PRId64" M=%"PRId64" E=%"PRId64" D=%"PRId64 + " T=%"PRId64". " + "Wgg=%f Wgd=%f Wmg=%f Wme=%f Wmd=%f Wee=%f Wed=%f", + casename, Mtotal, Gtotal, + (G), (M), (E), + (D), (T), + Wgg, Wgd, Wmg, Wme, Wmd, Wee, Wed); + valid = 0; + } + } else if (3*E < T && 3*G < T) { + int64_t R = MIN(E, G); + int64_t S = MAX(E, G); + /* + * Case 2: Both Guards and Exits are scarce + * Balance D between E and G, depending upon + * D capacity and scarcity. Devote no extra + * bandwidth to middle nodes. + */ + if (R+D < S) { // Subcase a + double Rtotal, Stotal; + if (E < G) { + Rtotal = Etotal; + Stotal = Gtotal; + } else { + Rtotal = Gtotal; + Stotal = Etotal; + } + casename = "Case 2a"; + // Rtotal < Stotal + if (Rtotal > Stotal) { + log_warn(LD_DIR, + "Bw Weight Failure for %s: Rtotal %f > Stotal %f. " + "G=%"PRId64" M=%"PRId64" E=%"PRId64" D=%"PRId64 + " T=%"PRId64". " + "Wgg=%f Wgd=%f Wmg=%f Wme=%f Wmd=%f Wee=%f Wed=%f", + casename, Rtotal, Stotal, + (G), (M), (E), + (D), (T), + Wgg, Wgd, Wmg, Wme, Wmd, Wee, Wed); + valid = 0; + } + // Rtotal < T/3 + if (3*Rtotal > T) { + log_warn(LD_DIR, + "Bw Weight Failure for %s: 3*Rtotal %f > T " + "%"PRId64". G=%"PRId64" M=%"PRId64" E=%"PRId64 + " D=%"PRId64" T=%"PRId64". " + "Wgg=%f Wgd=%f Wmg=%f Wme=%f Wmd=%f Wee=%f Wed=%f", + casename, Rtotal*3, (T), + (G), (M), (E), + (D), (T), + Wgg, Wgd, Wmg, Wme, Wmd, Wee, Wed); + valid = 0; + } + // Stotal < T/3 + if (3*Stotal > T) { + log_warn(LD_DIR, + "Bw Weight Failure for %s: 3*Stotal %f > T " + "%"PRId64". G=%"PRId64" M=%"PRId64" E=%"PRId64 + " D=%"PRId64" T=%"PRId64". " + "Wgg=%f Wgd=%f Wmg=%f Wme=%f Wmd=%f Wee=%f Wed=%f", + casename, Stotal*3, (T), + (G), (M), (E), + (D), (T), + Wgg, Wgd, Wmg, Wme, Wmd, Wee, Wed); + valid = 0; + } + // Mtotal > T/3 + if (3*Mtotal < T) { + log_warn(LD_DIR, + "Bw Weight Failure for %s: 3*Mtotal %f < T " + "%"PRId64". " + "G=%"PRId64" M=%"PRId64" E=%"PRId64" D=%"PRId64 + " T=%"PRId64". " + "Wgg=%f Wgd=%f Wmg=%f Wme=%f Wmd=%f Wee=%f Wed=%f", + casename, Mtotal*3, (T), + (G), (M), (E), + (D), (T), + Wgg, Wgd, Wmg, Wme, Wmd, Wee, Wed); + valid = 0; + } + } else { // Subcase b: R+D > S + casename = "Case 2b"; + + /* Check the rare-M redirect case. */ + if (D != 0 && 3*M < T) { + casename = "Case 2b (balanced)"; + if (fabs(Etotal-Mtotal) > 0.01*MAX(Etotal,Mtotal)) { + log_warn(LD_DIR, + "Bw Weight Failure for %s: Etotal %f != Mtotal %f. " + "G=%"PRId64" M=%"PRId64" E=%"PRId64" D=%"PRId64 + " T=%"PRId64". " + "Wgg=%f Wgd=%f Wmg=%f Wme=%f Wmd=%f Wee=%f Wed=%f", + casename, Etotal, Mtotal, + (G), (M), (E), + (D), (T), + Wgg, Wgd, Wmg, Wme, Wmd, Wee, Wed); + valid = 0; + } + if (fabs(Etotal-Gtotal) > 0.01*MAX(Etotal,Gtotal)) { + log_warn(LD_DIR, + "Bw Weight Failure for %s: Etotal %f != Gtotal %f. " + "G=%"PRId64" M=%"PRId64" E=%"PRId64" D=%"PRId64 + " T=%"PRId64". " + "Wgg=%f Wgd=%f Wmg=%f Wme=%f Wmd=%f Wee=%f Wed=%f", + casename, Etotal, Gtotal, + (G), (M), (E), + (D), (T), + Wgg, Wgd, Wmg, Wme, Wmd, Wee, Wed); + valid = 0; + } + if (fabs(Gtotal-Mtotal) > 0.01*MAX(Gtotal,Mtotal)) { + log_warn(LD_DIR, + "Bw Weight Failure for %s: Mtotal %f != Gtotal %f. " + "G=%"PRId64" M=%"PRId64" E=%"PRId64" D=%"PRId64 + " T=%"PRId64". " + "Wgg=%f Wgd=%f Wmg=%f Wme=%f Wmd=%f Wee=%f Wed=%f", + casename, Mtotal, Gtotal, + (G), (M), (E), + (D), (T), + Wgg, Wgd, Wmg, Wme, Wmd, Wee, Wed); + valid = 0; + } + } else { + if (fabs(Etotal-Gtotal) > 0.01*MAX(Etotal,Gtotal)) { + log_warn(LD_DIR, + "Bw Weight Failure for %s: Etotal %f != Gtotal %f. " + "G=%"PRId64" M=%"PRId64" E=%"PRId64" D=%"PRId64 + " T=%"PRId64". " + "Wgg=%f Wgd=%f Wmg=%f Wme=%f Wmd=%f Wee=%f Wed=%f", + casename, Etotal, Gtotal, + (G), (M), (E), + (D), (T), + Wgg, Wgd, Wmg, Wme, Wmd, Wee, Wed); + valid = 0; + } + } + } + } else { // if (E < T/3 || G < T/3) { + int64_t S = MIN(E, G); + int64_t NS = MAX(E, G); + if (3*(S+D) < T) { // Subcase a: + double Stotal; + double NStotal; + if (G < E) { + casename = "Case 3a (G scarce)"; + Stotal = Gtotal; + NStotal = Etotal; + } else { // if (G >= E) { + casename = "Case 3a (E scarce)"; + NStotal = Gtotal; + Stotal = Etotal; + } + // Stotal < T/3 + if (3*Stotal > T) { + log_warn(LD_DIR, + "Bw Weight Failure for %s: 3*Stotal %f > T " + "%"PRId64". G=%"PRId64" M=%"PRId64" E=%"PRId64 + " D=%"PRId64" T=%"PRId64". " + "Wgg=%f Wgd=%f Wmg=%f Wme=%f Wmd=%f Wee=%f Wed=%f", + casename, Stotal*3, (T), + (G), (M), (E), + (D), (T), + Wgg, Wgd, Wmg, Wme, Wmd, Wee, Wed); + valid = 0; + } + if (NS >= M) { + if (fabs(NStotal-Mtotal) > 0.01*MAX(NStotal,Mtotal)) { + log_warn(LD_DIR, + "Bw Weight Failure for %s: NStotal %f != Mtotal %f. " + "G=%"PRId64" M=%"PRId64" E=%"PRId64" D=%"PRId64 + " T=%"PRId64". " + "Wgg=%f Wgd=%f Wmg=%f Wme=%f Wmd=%f Wee=%f Wed=%f", + casename, NStotal, Mtotal, + (G), (M), (E), + (D), (T), + Wgg, Wgd, Wmg, Wme, Wmd, Wee, Wed); + valid = 0; + } + } else { + // if NS < M, NStotal > T/3 because only one of G or E is scarce + if (3*NStotal < T) { + log_warn(LD_DIR, + "Bw Weight Failure for %s: 3*NStotal %f < T " + "%"PRId64". G=%"PRId64" M=%"PRId64 + " E=%"PRId64" D=%"PRId64" T=%"PRId64". " + "Wgg=%f Wgd=%f Wmg=%f Wme=%f Wmd=%f Wee=%f Wed=%f", + casename, NStotal*3, (T), + (G), (M), (E), + (D), (T), + Wgg, Wgd, Wmg, Wme, Wmd, Wee, Wed); + valid = 0; + } + } + } else { // Subcase b: S+D >= T/3 + casename = "Case 3b"; + if (fabs(Etotal-Mtotal) > 0.01*MAX(Etotal,Mtotal)) { + log_warn(LD_DIR, + "Bw Weight Failure for %s: Etotal %f != Mtotal %f. " + "G=%"PRId64" M=%"PRId64" E=%"PRId64" D=%"PRId64 + " T=%"PRId64". " + "Wgg=%f Wgd=%f Wmg=%f Wme=%f Wmd=%f Wee=%f Wed=%f", + casename, Etotal, Mtotal, + (G), (M), (E), + (D), (T), + Wgg, Wgd, Wmg, Wme, Wmd, Wee, Wed); + valid = 0; + } + if (fabs(Etotal-Gtotal) > 0.01*MAX(Etotal,Gtotal)) { + log_warn(LD_DIR, + "Bw Weight Failure for %s: Etotal %f != Gtotal %f. " + "G=%"PRId64" M=%"PRId64" E=%"PRId64" D=%"PRId64 + " T=%"PRId64". " + "Wgg=%f Wgd=%f Wmg=%f Wme=%f Wmd=%f Wee=%f Wed=%f", + casename, Etotal, Gtotal, + (G), (M), (E), + (D), (T), + Wgg, Wgd, Wmg, Wme, Wmd, Wee, Wed); + valid = 0; + } + if (fabs(Gtotal-Mtotal) > 0.01*MAX(Gtotal,Mtotal)) { + log_warn(LD_DIR, + "Bw Weight Failure for %s: Mtotal %f != Gtotal %f. " + "G=%"PRId64" M=%"PRId64" E=%"PRId64" D=%"PRId64 + " T=%"PRId64". " + "Wgg=%f Wgd=%f Wmg=%f Wme=%f Wmd=%f Wee=%f Wed=%f", + casename, Mtotal, Gtotal, + (G), (M), (E), + (D), (T), + Wgg, Wgd, Wmg, Wme, Wmd, Wee, Wed); + valid = 0; + } + } + } + + if (valid) + log_notice(LD_DIR, "Bandwidth-weight %s is verified and valid.", + casename); + + return valid; +} + +/** Check if a shared random value of type <b>srv_type</b> is in + * <b>tokens</b>. If there is, parse it and set it to <b>srv_out</b>. Return + * -1 on failure, 0 on success. The resulting srv is allocated on the heap and + * it's the responsibility of the caller to free it. */ +static int +extract_one_srv(smartlist_t *tokens, directory_keyword srv_type, + sr_srv_t **srv_out) +{ + int ret = -1; + directory_token_t *tok; + sr_srv_t *srv = NULL; + smartlist_t *chunks; + + tor_assert(tokens); + + chunks = smartlist_new(); + tok = find_opt_by_keyword(tokens, srv_type); + if (!tok) { + /* That's fine, no SRV is allowed. */ + ret = 0; + goto end; + } + for (int i = 0; i < tok->n_args; i++) { + smartlist_add(chunks, tok->args[i]); + } + srv = sr_parse_srv(chunks); + if (srv == NULL) { + log_warn(LD_DIR, "SR: Unparseable SRV %s", escaped(tok->object_body)); + goto end; + } + /* All is good. */ + *srv_out = srv; + ret = 0; + end: + smartlist_free(chunks); + return ret; +} + +/** Extract any shared random values found in <b>tokens</b> and place them in + * the networkstatus <b>ns</b>. */ +static void +extract_shared_random_srvs(networkstatus_t *ns, smartlist_t *tokens) +{ + const char *voter_identity; + networkstatus_voter_info_t *voter; + + tor_assert(ns); + tor_assert(tokens); + /* Can be only one of them else code flow. */ + tor_assert(ns->type == NS_TYPE_VOTE || ns->type == NS_TYPE_CONSENSUS); + + if (ns->type == NS_TYPE_VOTE) { + voter = smartlist_get(ns->voters, 0); + tor_assert(voter); + voter_identity = hex_str(voter->identity_digest, + sizeof(voter->identity_digest)); + } else { + /* Consensus has multiple voters so no specific voter. */ + voter_identity = "consensus"; + } + + /* We extract both, and on error everything is stopped because it means + * the vote is malformed for the shared random value(s). */ + if (extract_one_srv(tokens, K_PREVIOUS_SRV, &ns->sr_info.previous_srv) < 0) { + log_warn(LD_DIR, "SR: Unable to parse previous SRV from %s", + voter_identity); + /* Maybe we have a chance with the current SRV so let's try it anyway. */ + } + if (extract_one_srv(tokens, K_CURRENT_SRV, &ns->sr_info.current_srv) < 0) { + log_warn(LD_DIR, "SR: Unable to parse current SRV from %s", + voter_identity); + } +} + +/** Parse a v3 networkstatus vote, opinion, or consensus (depending on + * ns_type), from <b>s</b>, and return the result. Return NULL on failure. */ +networkstatus_t * +networkstatus_parse_vote_from_string(const char *s, const char **eos_out, + networkstatus_type_t ns_type) +{ + smartlist_t *tokens = smartlist_new(); + smartlist_t *rs_tokens = NULL, *footer_tokens = NULL; + networkstatus_voter_info_t *voter = NULL; + networkstatus_t *ns = NULL; + common_digests_t ns_digests; + uint8_t sha3_as_signed[DIGEST256_LEN]; + const char *cert, *end_of_header, *end_of_footer, *s_dup = s; + directory_token_t *tok; + struct in_addr in; + int i, inorder, n_signatures = 0; + memarea_t *area = NULL, *rs_area = NULL; + consensus_flavor_t flav = FLAV_NS; + char *last_kwd=NULL; + + tor_assert(s); + + if (eos_out) + *eos_out = NULL; + + if (router_get_networkstatus_v3_hashes(s, &ns_digests) || + router_get_networkstatus_v3_sha3_as_signed(sha3_as_signed, s)<0) { + log_warn(LD_DIR, "Unable to compute digest of network-status"); + goto err; + } + + area = memarea_new(); + end_of_header = find_start_of_next_routerstatus(s); + if (tokenize_string(area, s, end_of_header, tokens, + (ns_type == NS_TYPE_CONSENSUS) ? + networkstatus_consensus_token_table : + networkstatus_token_table, 0)) { + log_warn(LD_DIR, "Error tokenizing network-status header"); + goto err; + } + + ns = tor_malloc_zero(sizeof(networkstatus_t)); + memcpy(&ns->digests, &ns_digests, sizeof(ns_digests)); + memcpy(&ns->digest_sha3_as_signed, sha3_as_signed, sizeof(sha3_as_signed)); + + tok = find_by_keyword(tokens, K_NETWORK_STATUS_VERSION); + tor_assert(tok); + if (tok->n_args > 1) { + int flavor = networkstatus_parse_flavor_name(tok->args[1]); + if (flavor < 0) { + log_warn(LD_DIR, "Can't parse document with unknown flavor %s", + escaped(tok->args[1])); + goto err; + } + ns->flavor = flav = flavor; + } + if (flav != FLAV_NS && ns_type != NS_TYPE_CONSENSUS) { + log_warn(LD_DIR, "Flavor found on non-consensus networkstatus."); + goto err; + } + + if (ns_type != NS_TYPE_CONSENSUS) { + const char *end_of_cert = NULL; + if (!(cert = strstr(s, "\ndir-key-certificate-version"))) + goto err; + ++cert; + ns->cert = authority_cert_parse_from_string(cert, &end_of_cert); + if (!ns->cert || !end_of_cert || end_of_cert > end_of_header) + goto err; + } + + tok = find_by_keyword(tokens, K_VOTE_STATUS); + tor_assert(tok->n_args); + if (!strcmp(tok->args[0], "vote")) { + ns->type = NS_TYPE_VOTE; + } else if (!strcmp(tok->args[0], "consensus")) { + ns->type = NS_TYPE_CONSENSUS; + } else if (!strcmp(tok->args[0], "opinion")) { + ns->type = NS_TYPE_OPINION; + } else { + log_warn(LD_DIR, "Unrecognized vote status %s in network-status", + escaped(tok->args[0])); + goto err; + } + if (ns_type != ns->type) { + log_warn(LD_DIR, "Got the wrong kind of v3 networkstatus."); + goto err; + } + + if (ns->type == NS_TYPE_VOTE || ns->type == NS_TYPE_OPINION) { + tok = find_by_keyword(tokens, K_PUBLISHED); + if (parse_iso_time(tok->args[0], &ns->published)) + goto err; + + ns->supported_methods = smartlist_new(); + tok = find_opt_by_keyword(tokens, K_CONSENSUS_METHODS); + if (tok) { + for (i=0; i < tok->n_args; ++i) + smartlist_add_strdup(ns->supported_methods, tok->args[i]); + } else { + smartlist_add_strdup(ns->supported_methods, "1"); + } + } else { + tok = find_opt_by_keyword(tokens, K_CONSENSUS_METHOD); + if (tok) { + int num_ok; + ns->consensus_method = (int)tor_parse_long(tok->args[0], 10, 1, INT_MAX, + &num_ok, NULL); + if (!num_ok) + goto err; + } else { + ns->consensus_method = 1; + } + } + + if ((tok = find_opt_by_keyword(tokens, K_RECOMMENDED_CLIENT_PROTOCOLS))) + ns->recommended_client_protocols = tor_strdup(tok->args[0]); + if ((tok = find_opt_by_keyword(tokens, K_RECOMMENDED_RELAY_PROTOCOLS))) + ns->recommended_relay_protocols = tor_strdup(tok->args[0]); + if ((tok = find_opt_by_keyword(tokens, K_REQUIRED_CLIENT_PROTOCOLS))) + ns->required_client_protocols = tor_strdup(tok->args[0]); + if ((tok = find_opt_by_keyword(tokens, K_REQUIRED_RELAY_PROTOCOLS))) + ns->required_relay_protocols = tor_strdup(tok->args[0]); + + tok = find_by_keyword(tokens, K_VALID_AFTER); + if (parse_iso_time(tok->args[0], &ns->valid_after)) + goto err; + + tok = find_by_keyword(tokens, K_FRESH_UNTIL); + if (parse_iso_time(tok->args[0], &ns->fresh_until)) + goto err; + + tok = find_by_keyword(tokens, K_VALID_UNTIL); + if (parse_iso_time(tok->args[0], &ns->valid_until)) + goto err; + + tok = find_by_keyword(tokens, K_VOTING_DELAY); + tor_assert(tok->n_args >= 2); + { + int ok; + ns->vote_seconds = + (int) tor_parse_long(tok->args[0], 10, 0, INT_MAX, &ok, NULL); + if (!ok) + goto err; + ns->dist_seconds = + (int) tor_parse_long(tok->args[1], 10, 0, INT_MAX, &ok, NULL); + if (!ok) + goto err; + } + if (ns->valid_after + + (get_options()->TestingTorNetwork ? + MIN_VOTE_INTERVAL_TESTING : MIN_VOTE_INTERVAL) > ns->fresh_until) { + log_warn(LD_DIR, "Vote/consensus freshness interval is too short"); + goto err; + } + if (ns->valid_after + + (get_options()->TestingTorNetwork ? + MIN_VOTE_INTERVAL_TESTING : MIN_VOTE_INTERVAL)*2 > ns->valid_until) { + log_warn(LD_DIR, "Vote/consensus liveness interval is too short"); + goto err; + } + if (ns->vote_seconds < MIN_VOTE_SECONDS) { + log_warn(LD_DIR, "Vote seconds is too short"); + goto err; + } + if (ns->dist_seconds < MIN_DIST_SECONDS) { + log_warn(LD_DIR, "Dist seconds is too short"); + goto err; + } + + if ((tok = find_opt_by_keyword(tokens, K_CLIENT_VERSIONS))) { + ns->client_versions = tor_strdup(tok->args[0]); + } + if ((tok = find_opt_by_keyword(tokens, K_SERVER_VERSIONS))) { + ns->server_versions = tor_strdup(tok->args[0]); + } + + { + smartlist_t *package_lst = find_all_by_keyword(tokens, K_PACKAGE); + ns->package_lines = smartlist_new(); + if (package_lst) { + SMARTLIST_FOREACH(package_lst, directory_token_t *, t, + smartlist_add_strdup(ns->package_lines, t->args[0])); + } + smartlist_free(package_lst); + } + + tok = find_by_keyword(tokens, K_KNOWN_FLAGS); + ns->known_flags = smartlist_new(); + inorder = 1; + for (i = 0; i < tok->n_args; ++i) { + smartlist_add_strdup(ns->known_flags, tok->args[i]); + if (i>0 && strcmp(tok->args[i-1], tok->args[i])>= 0) { + log_warn(LD_DIR, "%s >= %s", tok->args[i-1], tok->args[i]); + inorder = 0; + } + } + if (!inorder) { + log_warn(LD_DIR, "known-flags not in order"); + goto err; + } + if (ns->type != NS_TYPE_CONSENSUS && + smartlist_len(ns->known_flags) > MAX_KNOWN_FLAGS_IN_VOTE) { + /* If we allowed more than 64 flags in votes, then parsing them would make + * us invoke undefined behavior whenever we used 1<<flagnum to do a + * bit-shift. This is only for votes and opinions: consensus users don't + * care about flags they don't recognize, and so don't build a bitfield + * for them. */ + log_warn(LD_DIR, "Too many known-flags in consensus vote or opinion"); + goto err; + } + + tok = find_opt_by_keyword(tokens, K_PARAMS); + if (tok) { + int any_dups = 0; + inorder = 1; + ns->net_params = smartlist_new(); + for (i = 0; i < tok->n_args; ++i) { + int ok=0; + char *eq = strchr(tok->args[i], '='); + size_t eq_pos; + if (!eq) { + log_warn(LD_DIR, "Bad element '%s' in params", escaped(tok->args[i])); + goto err; + } + eq_pos = eq-tok->args[i]; + tor_parse_long(eq+1, 10, INT32_MIN, INT32_MAX, &ok, NULL); + if (!ok) { + log_warn(LD_DIR, "Bad element '%s' in params", escaped(tok->args[i])); + goto err; + } + if (i > 0 && strcmp(tok->args[i-1], tok->args[i]) >= 0) { + log_warn(LD_DIR, "%s >= %s", tok->args[i-1], tok->args[i]); + inorder = 0; + } + if (last_kwd && eq_pos == strlen(last_kwd) && + fast_memeq(last_kwd, tok->args[i], eq_pos)) { + log_warn(LD_DIR, "Duplicate value for %s parameter", + escaped(tok->args[i])); + any_dups = 1; + } + tor_free(last_kwd); + last_kwd = tor_strndup(tok->args[i], eq_pos); + smartlist_add_strdup(ns->net_params, tok->args[i]); + } + if (!inorder) { + log_warn(LD_DIR, "params not in order"); + goto err; + } + if (any_dups) { + log_warn(LD_DIR, "Duplicate in parameters"); + goto err; + } + } + + ns->voters = smartlist_new(); + + SMARTLIST_FOREACH_BEGIN(tokens, directory_token_t *, _tok) { + tok = _tok; + if (tok->tp == K_DIR_SOURCE) { + tor_assert(tok->n_args >= 6); + + if (voter) + smartlist_add(ns->voters, voter); + voter = tor_malloc_zero(sizeof(networkstatus_voter_info_t)); + voter->sigs = smartlist_new(); + if (ns->type != NS_TYPE_CONSENSUS) + memcpy(voter->vote_digest, ns_digests.d[DIGEST_SHA1], DIGEST_LEN); + + voter->nickname = tor_strdup(tok->args[0]); + if (strlen(tok->args[1]) != HEX_DIGEST_LEN || + base16_decode(voter->identity_digest, sizeof(voter->identity_digest), + tok->args[1], HEX_DIGEST_LEN) + != sizeof(voter->identity_digest)) { + log_warn(LD_DIR, "Error decoding identity digest %s in " + "network-status document.", escaped(tok->args[1])); + goto err; + } + if (ns->type != NS_TYPE_CONSENSUS && + tor_memneq(ns->cert->cache_info.identity_digest, + voter->identity_digest, DIGEST_LEN)) { + log_warn(LD_DIR,"Mismatch between identities in certificate and vote"); + goto err; + } + if (ns->type != NS_TYPE_CONSENSUS) { + if (authority_cert_is_blacklisted(ns->cert)) { + log_warn(LD_DIR, "Rejecting vote signature made with blacklisted " + "signing key %s", + hex_str(ns->cert->signing_key_digest, DIGEST_LEN)); + goto err; + } + } + voter->address = tor_strdup(tok->args[2]); + if (!tor_inet_aton(tok->args[3], &in)) { + log_warn(LD_DIR, "Error decoding IP address %s in network-status.", + escaped(tok->args[3])); + goto err; + } + voter->addr = ntohl(in.s_addr); + int ok; + voter->dir_port = (uint16_t) + tor_parse_long(tok->args[4], 10, 0, 65535, &ok, NULL); + if (!ok) + goto err; + voter->or_port = (uint16_t) + tor_parse_long(tok->args[5], 10, 0, 65535, &ok, NULL); + if (!ok) + goto err; + } else if (tok->tp == K_CONTACT) { + if (!voter || voter->contact) { + log_warn(LD_DIR, "contact element is out of place."); + goto err; + } + voter->contact = tor_strdup(tok->args[0]); + } else if (tok->tp == K_VOTE_DIGEST) { + tor_assert(ns->type == NS_TYPE_CONSENSUS); + tor_assert(tok->n_args >= 1); + if (!voter || ! tor_digest_is_zero(voter->vote_digest)) { + log_warn(LD_DIR, "vote-digest element is out of place."); + goto err; + } + if (strlen(tok->args[0]) != HEX_DIGEST_LEN || + base16_decode(voter->vote_digest, sizeof(voter->vote_digest), + tok->args[0], HEX_DIGEST_LEN) + != sizeof(voter->vote_digest)) { + log_warn(LD_DIR, "Error decoding vote digest %s in " + "network-status consensus.", escaped(tok->args[0])); + goto err; + } + } + } SMARTLIST_FOREACH_END(_tok); + if (voter) { + smartlist_add(ns->voters, voter); + voter = NULL; + } + if (smartlist_len(ns->voters) == 0) { + log_warn(LD_DIR, "Missing dir-source elements in a networkstatus."); + goto err; + } else if (ns->type != NS_TYPE_CONSENSUS && smartlist_len(ns->voters) != 1) { + log_warn(LD_DIR, "Too many dir-source elements in a vote networkstatus."); + goto err; + } + + if (ns->type != NS_TYPE_CONSENSUS && + (tok = find_opt_by_keyword(tokens, K_LEGACY_DIR_KEY))) { + int bad = 1; + if (strlen(tok->args[0]) == HEX_DIGEST_LEN) { + networkstatus_voter_info_t *voter_0 = smartlist_get(ns->voters, 0); + if (base16_decode(voter_0->legacy_id_digest, DIGEST_LEN, + tok->args[0], HEX_DIGEST_LEN) != DIGEST_LEN) + bad = 1; + else + bad = 0; + } + if (bad) { + log_warn(LD_DIR, "Invalid legacy key digest %s on vote.", + escaped(tok->args[0])); + } + } + + /* If this is a vote document, check if information about the shared + randomness protocol is included, and extract it. */ + if (ns->type == NS_TYPE_VOTE) { + dirvote_parse_sr_commits(ns, tokens); + } + /* For both a vote and consensus, extract the shared random values. */ + if (ns->type == NS_TYPE_VOTE || ns->type == NS_TYPE_CONSENSUS) { + extract_shared_random_srvs(ns, tokens); + } + + /* Parse routerstatus lines. */ + rs_tokens = smartlist_new(); + rs_area = memarea_new(); + s = end_of_header; + ns->routerstatus_list = smartlist_new(); + + while (!strcmpstart(s, "r ")) { + if (ns->type != NS_TYPE_CONSENSUS) { + vote_routerstatus_t *rs = tor_malloc_zero(sizeof(vote_routerstatus_t)); + if (routerstatus_parse_entry_from_string(rs_area, &s, rs_tokens, ns, + rs, 0, 0)) { + smartlist_add(ns->routerstatus_list, rs); + } else { + vote_routerstatus_free(rs); + } + } else { + routerstatus_t *rs; + if ((rs = routerstatus_parse_entry_from_string(rs_area, &s, rs_tokens, + NULL, NULL, + ns->consensus_method, + flav))) { + /* Use exponential-backoff scheduling when downloading microdescs */ + smartlist_add(ns->routerstatus_list, rs); + } + } + } + for (i = 1; i < smartlist_len(ns->routerstatus_list); ++i) { + routerstatus_t *rs1, *rs2; + if (ns->type != NS_TYPE_CONSENSUS) { + vote_routerstatus_t *a = smartlist_get(ns->routerstatus_list, i-1); + vote_routerstatus_t *b = smartlist_get(ns->routerstatus_list, i); + rs1 = &a->status; rs2 = &b->status; + } else { + rs1 = smartlist_get(ns->routerstatus_list, i-1); + rs2 = smartlist_get(ns->routerstatus_list, i); + } + if (fast_memcmp(rs1->identity_digest, rs2->identity_digest, DIGEST_LEN) + >= 0) { + log_warn(LD_DIR, "Networkstatus entries not sorted by identity digest"); + goto err; + } + } + if (ns_type != NS_TYPE_CONSENSUS) { + digest256map_t *ed_id_map = digest256map_new(); + SMARTLIST_FOREACH_BEGIN(ns->routerstatus_list, vote_routerstatus_t *, + vrs) { + if (! vrs->has_ed25519_listing || + tor_mem_is_zero((const char *)vrs->ed25519_id, DIGEST256_LEN)) + continue; + if (digest256map_get(ed_id_map, vrs->ed25519_id) != NULL) { + log_warn(LD_DIR, "Vote networkstatus ed25519 identities were not " + "unique"); + digest256map_free(ed_id_map, NULL); + goto err; + } + digest256map_set(ed_id_map, vrs->ed25519_id, (void*)1); + } SMARTLIST_FOREACH_END(vrs); + digest256map_free(ed_id_map, NULL); + } + + /* Parse footer; check signature. */ + footer_tokens = smartlist_new(); + if ((end_of_footer = strstr(s, "\nnetwork-status-version "))) + ++end_of_footer; + else + end_of_footer = s + strlen(s); + if (tokenize_string(area,s, end_of_footer, footer_tokens, + networkstatus_vote_footer_token_table, 0)) { + log_warn(LD_DIR, "Error tokenizing network-status vote footer."); + goto err; + } + + { + int found_sig = 0; + SMARTLIST_FOREACH_BEGIN(footer_tokens, directory_token_t *, _tok) { + tok = _tok; + if (tok->tp == K_DIRECTORY_SIGNATURE) + found_sig = 1; + else if (found_sig) { + log_warn(LD_DIR, "Extraneous token after first directory-signature"); + goto err; + } + } SMARTLIST_FOREACH_END(_tok); + } + + if ((tok = find_opt_by_keyword(footer_tokens, K_DIRECTORY_FOOTER))) { + if (tok != smartlist_get(footer_tokens, 0)) { + log_warn(LD_DIR, "Misplaced directory-footer token"); + goto err; + } + } + + tok = find_opt_by_keyword(footer_tokens, K_BW_WEIGHTS); + if (tok) { + ns->weight_params = smartlist_new(); + for (i = 0; i < tok->n_args; ++i) { + int ok=0; + char *eq = strchr(tok->args[i], '='); + if (!eq) { + log_warn(LD_DIR, "Bad element '%s' in weight params", + escaped(tok->args[i])); + goto err; + } + tor_parse_long(eq+1, 10, INT32_MIN, INT32_MAX, &ok, NULL); + if (!ok) { + log_warn(LD_DIR, "Bad element '%s' in params", escaped(tok->args[i])); + goto err; + } + smartlist_add_strdup(ns->weight_params, tok->args[i]); + } + } + + SMARTLIST_FOREACH_BEGIN(footer_tokens, directory_token_t *, _tok) { + char declared_identity[DIGEST_LEN]; + networkstatus_voter_info_t *v; + document_signature_t *sig; + const char *id_hexdigest = NULL; + const char *sk_hexdigest = NULL; + digest_algorithm_t alg = DIGEST_SHA1; + tok = _tok; + if (tok->tp != K_DIRECTORY_SIGNATURE) + continue; + tor_assert(tok->n_args >= 2); + if (tok->n_args == 2) { + id_hexdigest = tok->args[0]; + sk_hexdigest = tok->args[1]; + } else { + const char *algname = tok->args[0]; + int a; + id_hexdigest = tok->args[1]; + sk_hexdigest = tok->args[2]; + a = crypto_digest_algorithm_parse_name(algname); + if (a<0) { + log_warn(LD_DIR, "Unknown digest algorithm %s; skipping", + escaped(algname)); + continue; + } + alg = a; + } + + if (!tok->object_type || + strcmp(tok->object_type, "SIGNATURE") || + tok->object_size < 128 || tok->object_size > 512) { + log_warn(LD_DIR, "Bad object type or length on directory-signature"); + goto err; + } + + if (strlen(id_hexdigest) != HEX_DIGEST_LEN || + base16_decode(declared_identity, sizeof(declared_identity), + id_hexdigest, HEX_DIGEST_LEN) + != sizeof(declared_identity)) { + log_warn(LD_DIR, "Error decoding declared identity %s in " + "network-status document.", escaped(id_hexdigest)); + goto err; + } + if (!(v = networkstatus_get_voter_by_id(ns, declared_identity))) { + log_warn(LD_DIR, "ID on signature on network-status document does " + "not match any declared directory source."); + goto err; + } + sig = tor_malloc_zero(sizeof(document_signature_t)); + memcpy(sig->identity_digest, v->identity_digest, DIGEST_LEN); + sig->alg = alg; + if (strlen(sk_hexdigest) != HEX_DIGEST_LEN || + base16_decode(sig->signing_key_digest, sizeof(sig->signing_key_digest), + sk_hexdigest, HEX_DIGEST_LEN) + != sizeof(sig->signing_key_digest)) { + log_warn(LD_DIR, "Error decoding declared signing key digest %s in " + "network-status document.", escaped(sk_hexdigest)); + tor_free(sig); + goto err; + } + + if (ns->type != NS_TYPE_CONSENSUS) { + if (tor_memneq(declared_identity, ns->cert->cache_info.identity_digest, + DIGEST_LEN)) { + log_warn(LD_DIR, "Digest mismatch between declared and actual on " + "network-status vote."); + tor_free(sig); + goto err; + } + } + + if (networkstatus_get_voter_sig_by_alg(v, sig->alg)) { + /* We already parsed a vote with this algorithm from this voter. Use the + first one. */ + log_fn(LOG_PROTOCOL_WARN, LD_DIR, "We received a networkstatus " + "that contains two signatures from the same voter with the same " + "algorithm. Ignoring the second signature."); + tor_free(sig); + continue; + } + + if (ns->type != NS_TYPE_CONSENSUS) { + if (check_signature_token(ns_digests.d[DIGEST_SHA1], DIGEST_LEN, + tok, ns->cert->signing_key, 0, + "network-status document")) { + tor_free(sig); + goto err; + } + sig->good_signature = 1; + } else { + if (tok->object_size >= INT_MAX || tok->object_size >= SIZE_T_CEILING) { + tor_free(sig); + goto err; + } + sig->signature = tor_memdup(tok->object_body, tok->object_size); + sig->signature_len = (int) tok->object_size; + } + smartlist_add(v->sigs, sig); + + ++n_signatures; + } SMARTLIST_FOREACH_END(_tok); + + if (! n_signatures) { + log_warn(LD_DIR, "No signatures on networkstatus document."); + goto err; + } else if (ns->type == NS_TYPE_VOTE && n_signatures != 1) { + log_warn(LD_DIR, "Received more than one signature on a " + "network-status vote."); + goto err; + } + + if (eos_out) + *eos_out = end_of_footer; + + goto done; + err: + dump_desc(s_dup, "v3 networkstatus"); + networkstatus_vote_free(ns); + ns = NULL; + done: + if (tokens) { + SMARTLIST_FOREACH(tokens, directory_token_t *, t, token_clear(t)); + smartlist_free(tokens); + } + if (voter) { + if (voter->sigs) { + SMARTLIST_FOREACH(voter->sigs, document_signature_t *, sig, + document_signature_free(sig)); + smartlist_free(voter->sigs); + } + tor_free(voter->nickname); + tor_free(voter->address); + tor_free(voter->contact); + tor_free(voter); + } + if (rs_tokens) { + SMARTLIST_FOREACH(rs_tokens, directory_token_t *, t, token_clear(t)); + smartlist_free(rs_tokens); + } + if (footer_tokens) { + SMARTLIST_FOREACH(footer_tokens, directory_token_t *, t, token_clear(t)); + smartlist_free(footer_tokens); + } + if (area) { + DUMP_AREA(area, "v3 networkstatus"); + memarea_drop_all(area); + } + if (rs_area) + memarea_drop_all(rs_area); + tor_free(last_kwd); + + return ns; +} diff --git a/src/feature/dirparse/ns_parse.h b/src/feature/dirparse/ns_parse.h new file mode 100644 index 0000000000..22438d73a7 --- /dev/null +++ b/src/feature/dirparse/ns_parse.h @@ -0,0 +1,45 @@ +/* Copyright (c) 2001 Matej Pfajfar. + * Copyright (c) 2001-2004, Roger Dingledine. + * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson. + * Copyright (c) 2007-2018, The Tor Project, Inc. */ +/* See LICENSE for licensing information */ + +/** + * \file ns_parse.h + * \brief Header file for ns_parse.c. + **/ + +#ifndef TOR_NS_PARSE_H +#define TOR_NS_PARSE_H + +int router_get_networkstatus_v3_hashes(const char *s, + common_digests_t *digests); +int router_get_networkstatus_v3_signed_boundaries(const char *s, + const char **start_out, + const char **end_out); +int router_get_networkstatus_v3_sha3_as_signed(uint8_t *digest_out, + const char *s); +int compare_vote_routerstatus_entries(const void **_a, const void **_b); + +int networkstatus_verify_bw_weights(networkstatus_t *ns, int); +enum networkstatus_type_t; +networkstatus_t *networkstatus_parse_vote_from_string(const char *s, + const char **eos_out, + enum networkstatus_type_t ns_type); + +#ifdef NS_PARSE_PRIVATE +STATIC int routerstatus_parse_guardfraction(const char *guardfraction_str, + networkstatus_t *vote, + vote_routerstatus_t *vote_rs, + routerstatus_t *rs); +struct memarea_t; +STATIC routerstatus_t *routerstatus_parse_entry_from_string( + struct memarea_t *area, + const char **s, smartlist_t *tokens, + networkstatus_t *vote, + vote_routerstatus_t *vote_rs, + int consensus_method, + consensus_flavor_t flav); +#endif + +#endif diff --git a/src/feature/nodelist/parsecommon.c b/src/feature/dirparse/parsecommon.c index e05657aca0..c12f199e4e 100644 --- a/src/feature/nodelist/parsecommon.c +++ b/src/feature/dirparse/parsecommon.c @@ -6,7 +6,7 @@ * \brief Common code to parse and validate various type of descriptors. **/ -#include "feature/nodelist/parsecommon.h" +#include "feature/dirparse/parsecommon.h" #include "lib/log/log.h" #include "lib/log/util_bug.h" #include "lib/encoding/binascii.h" @@ -51,7 +51,7 @@ token_clear(directory_token_t *tok) int tokenize_string(memarea_t *area, const char *start, const char *end, smartlist_t *out, - token_rule_t *table, int flags) + const token_rule_t *table, int flags) { const char **s; directory_token_t *tok = NULL; @@ -257,7 +257,7 @@ token_check_object(memarea_t *area, const char *kwd, */ directory_token_t * get_next_token(memarea_t *area, - const char **s, const char *eos, token_rule_t *table) + const char **s, const char *eos, const token_rule_t *table) { /** Reject any object at least this big; it is probably an overflow, an * attack, a bug, or some other nonsense. */ diff --git a/src/feature/nodelist/parsecommon.h b/src/feature/dirparse/parsecommon.h index d0f3810c0b..f14862f04a 100644 --- a/src/feature/nodelist/parsecommon.h +++ b/src/feature/dirparse/parsecommon.h @@ -302,12 +302,12 @@ void token_clear(directory_token_t *tok); int tokenize_string(struct memarea_t *area, const char *start, const char *end, struct smartlist_t *out, - token_rule_t *table, + const token_rule_t *table, int flags); directory_token_t *get_next_token(struct memarea_t *area, const char **s, const char *eos, - token_rule_t *table); + const token_rule_t *table); directory_token_t *find_by_keyword_(struct smartlist_t *s, directory_keyword keyword, diff --git a/src/feature/dirparse/policy_parse.c b/src/feature/dirparse/policy_parse.c new file mode 100644 index 0000000000..e102a62282 --- /dev/null +++ b/src/feature/dirparse/policy_parse.c @@ -0,0 +1,218 @@ +/* Copyright (c) 2001 Matej Pfajfar. + * Copyright (c) 2001-2004, Roger Dingledine. + * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson. + * Copyright (c) 2007-2018, The Tor Project, Inc. */ +/* See LICENSE for licensing information */ + +/** + * \file policy_parse.c + * \brief Code to parse address policies. + **/ + +#define EXPOSE_ROUTERDESC_TOKEN_TABLE + +#include "core/or/or.h" + +#include "core/or/policies.h" +#include "feature/dirparse/parsecommon.h" +#include "feature/dirparse/policy_parse.h" +#include "feature/dirparse/routerparse.h" +#include "feature/dirparse/unparseable.h" +#include "lib/memarea/memarea.h" + +#include "core/or/addr_policy_st.h" + +static addr_policy_t *router_parse_addr_policy_private(directory_token_t *tok); + +/** Parse the addr policy in the string <b>s</b> and return it. If + * assume_action is nonnegative, then insert its action (ADDR_POLICY_ACCEPT or + * ADDR_POLICY_REJECT) for items that specify no action. + * + * Returns NULL on policy errors. + * + * Set *<b>malformed_list</b> to true if the entire policy list should be + * discarded. Otherwise, set it to false, and only this item should be ignored + * on error - the rest of the policy list can continue to be processed and + * used. + * + * The addr_policy_t returned by this function can have its address set to + * AF_UNSPEC for '*'. Use policy_expand_unspec() to turn this into a pair + * of AF_INET and AF_INET6 items. + */ +MOCK_IMPL(addr_policy_t *, +router_parse_addr_policy_item_from_string,(const char *s, int assume_action, + int *malformed_list)) +{ + directory_token_t *tok = NULL; + const char *cp, *eos; + /* Longest possible policy is + * "accept6 [ffff:ffff:..255]/128:10000-65535", + * which contains a max-length IPv6 address, plus 26 characters. + * But note that there can be an arbitrary amount of space between the + * accept and the address:mask/port element. + * We don't need to multiply TOR_ADDR_BUF_LEN by 2, as there is only one + * IPv6 address. But making the buffer shorter might cause valid long lines, + * which parsed in previous versions, to fail to parse in new versions. + * (These lines would have to have excessive amounts of whitespace.) */ + char line[TOR_ADDR_BUF_LEN*2 + 32]; + addr_policy_t *r; + memarea_t *area = NULL; + + tor_assert(malformed_list); + *malformed_list = 0; + + s = eat_whitespace(s); + /* We can only do assume_action on []-quoted IPv6, as "a" (accept) + * and ":" (port separator) are ambiguous */ + if ((*s == '*' || *s == '[' || TOR_ISDIGIT(*s)) && assume_action >= 0) { + if (tor_snprintf(line, sizeof(line), "%s %s", + assume_action == ADDR_POLICY_ACCEPT?"accept":"reject", s)<0) { + log_warn(LD_DIR, "Policy %s is too long.", escaped(s)); + return NULL; + } + cp = line; + tor_strlower(line); + } else { /* assume an already well-formed address policy line */ + cp = s; + } + + eos = cp + strlen(cp); + area = memarea_new(); + tok = get_next_token(area, &cp, eos, routerdesc_token_table); + if (tok->tp == ERR_) { + log_warn(LD_DIR, "Error reading address policy: %s", tok->error); + goto err; + } + if (tok->tp != K_ACCEPT && tok->tp != K_ACCEPT6 && + tok->tp != K_REJECT && tok->tp != K_REJECT6) { + log_warn(LD_DIR, "Expected 'accept' or 'reject'."); + goto err; + } + + /* Use the extended interpretation of accept/reject *, + * expanding it into an IPv4 wildcard and an IPv6 wildcard. + * Also permit *4 and *6 for IPv4 and IPv6 only wildcards. */ + r = router_parse_addr_policy(tok, TAPMP_EXTENDED_STAR); + if (!r) { + goto err; + } + + /* Ensure that accept6/reject6 fields are followed by IPv6 addresses. + * AF_UNSPEC addresses are only permitted on the accept/reject field type. + * Unlike descriptors, torrcs exit policy accept/reject can be followed by + * either an IPv4 or IPv6 address. */ + if ((tok->tp == K_ACCEPT6 || tok->tp == K_REJECT6) && + tor_addr_family(&r->addr) != AF_INET6) { + /* This is a non-fatal error, just ignore this one entry. */ + *malformed_list = 0; + log_warn(LD_DIR, "IPv4 address '%s' with accept6/reject6 field type in " + "exit policy. Ignoring, but continuing to parse rules. (Use " + "accept/reject with IPv4 addresses.)", + tok->n_args == 1 ? tok->args[0] : ""); + addr_policy_free(r); + r = NULL; + goto done; + } + + goto done; + err: + *malformed_list = 1; + r = NULL; + done: + token_clear(tok); + if (area) { + DUMP_AREA(area, "policy item"); + memarea_drop_all(area); + } + return r; +} + +/** Given a K_ACCEPT[6] or K_REJECT[6] token and a router, create and return + * a new exit_policy_t corresponding to the token. If TAPMP_EXTENDED_STAR + * is set in fmt_flags, K_ACCEPT6 and K_REJECT6 tokens followed by * + * expand to IPv6-only policies, otherwise they expand to IPv4 and IPv6 + * policies */ +addr_policy_t * +router_parse_addr_policy(directory_token_t *tok, unsigned fmt_flags) +{ + addr_policy_t newe; + char *arg; + + tor_assert(tok->tp == K_REJECT || tok->tp == K_REJECT6 || + tok->tp == K_ACCEPT || tok->tp == K_ACCEPT6); + + if (tok->n_args != 1) + return NULL; + arg = tok->args[0]; + + if (!strcmpstart(arg,"private")) + return router_parse_addr_policy_private(tok); + + memset(&newe, 0, sizeof(newe)); + + if (tok->tp == K_REJECT || tok->tp == K_REJECT6) + newe.policy_type = ADDR_POLICY_REJECT; + else + newe.policy_type = ADDR_POLICY_ACCEPT; + + /* accept6/reject6 * produces an IPv6 wildcard address only. + * (accept/reject * produces rules for IPv4 and IPv6 wildcard addresses.) */ + if ((fmt_flags & TAPMP_EXTENDED_STAR) + && (tok->tp == K_ACCEPT6 || tok->tp == K_REJECT6)) { + fmt_flags |= TAPMP_STAR_IPV6_ONLY; + } + + if (tor_addr_parse_mask_ports(arg, fmt_flags, &newe.addr, &newe.maskbits, + &newe.prt_min, &newe.prt_max) < 0) { + log_warn(LD_DIR,"Couldn't parse line %s. Dropping", escaped(arg)); + return NULL; + } + + return addr_policy_get_canonical_entry(&newe); +} + +/** Parse an exit policy line of the format "accept[6]/reject[6] private:...". + * This didn't exist until Tor 0.1.1.15, so nobody should generate it in + * router descriptors until earlier versions are obsolete. + * + * accept/reject and accept6/reject6 private all produce rules for both + * IPv4 and IPv6 addresses. + */ +static addr_policy_t * +router_parse_addr_policy_private(directory_token_t *tok) +{ + const char *arg; + uint16_t port_min, port_max; + addr_policy_t result; + + arg = tok->args[0]; + if (strcmpstart(arg, "private")) + return NULL; + + arg += strlen("private"); + arg = (char*) eat_whitespace(arg); + if (!arg || *arg != ':') + return NULL; + + if (parse_port_range(arg+1, &port_min, &port_max)<0) + return NULL; + + memset(&result, 0, sizeof(result)); + if (tok->tp == K_REJECT || tok->tp == K_REJECT6) + result.policy_type = ADDR_POLICY_REJECT; + else + result.policy_type = ADDR_POLICY_ACCEPT; + result.is_private = 1; + result.prt_min = port_min; + result.prt_max = port_max; + + if (tok->tp == K_ACCEPT6 || tok->tp == K_REJECT6) { + log_warn(LD_GENERAL, + "'%s' expands into rules which apply to all private IPv4 and " + "IPv6 addresses. (Use accept/reject private:* for IPv4 and " + "IPv6.)", tok->n_args == 1 ? tok->args[0] : ""); + } + + return addr_policy_get_canonical_entry(&result); +} + diff --git a/src/feature/dirparse/policy_parse.h b/src/feature/dirparse/policy_parse.h new file mode 100644 index 0000000000..887aa9261b --- /dev/null +++ b/src/feature/dirparse/policy_parse.h @@ -0,0 +1,25 @@ +/* Copyright (c) 2001 Matej Pfajfar. + * Copyright (c) 2001-2004, Roger Dingledine. + * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson. + * Copyright (c) 2007-2018, The Tor Project, Inc. */ +/* See LICENSE for licensing information */ + +/** + * \file policy_parse.h + * \brief Header file for policy_parse.c. + **/ + +#ifndef TOR_POLICY_PARSE_H +#define TOR_POLICY_PARSE_H + +#include "lib/testsupport/testsupport.h" + +struct directory_token_t; + +MOCK_DECL(addr_policy_t *, router_parse_addr_policy_item_from_string, + (const char *s, int assume_action, int *malformed_list)); + +addr_policy_t *router_parse_addr_policy(struct directory_token_t *tok, + unsigned fmt_flags); + +#endif /* !defined(TOR_POLICY_PARSE_H) */ diff --git a/src/feature/dirparse/routerparse.c b/src/feature/dirparse/routerparse.c new file mode 100644 index 0000000000..2249ab7cbc --- /dev/null +++ b/src/feature/dirparse/routerparse.c @@ -0,0 +1,1242 @@ +/* Copyright (c) 2001 Matej Pfajfar. + * Copyright (c) 2001-2004, Roger Dingledine. + * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson. + * Copyright (c) 2007-2018, The Tor Project, Inc. */ +/* See LICENSE for licensing information */ + +/** + * \file routerparse.c + * \brief Code to parse and validate router descriptors, consenus directories, + * and similar objects. + * + * The objects parsed by this module use a common text-based metaformat, + * documented in dir-spec.txt in torspec.git. This module is itself divided + * into two major kinds of function: code to handle the metaformat, and code + * to convert from particular instances of the metaformat into the + * objects that Tor uses. + * + * The generic parsing code works by calling a table-based tokenizer on the + * input string. Each token corresponds to a single line with a token, plus + * optional arguments on that line, plus an optional base-64 encoded object + * after that line. Each token has a definition in a table of token_rule_t + * entries that describes how many arguments it can take, whether it takes an + * object, how many times it may appear, whether it must appear first, and so + * on. + * + * The tokenizer function tokenize_string() converts its string input into a + * smartlist full of instances of directory_token_t, according to a provided + * table of token_rule_t. + * + * The generic parts of this module additionally include functions for + * finding the start and end of signed information inside a signed object, and + * computing the digest that will be signed. + * + * There are also functions for saving objects to disk that have caused + * parsing to fail. + * + * The specific parts of this module describe conversions between + * particular lists of directory_token_t and particular objects. The + * kinds of objects that can be parsed here are: + * <ul> + * <li>router descriptors (managed from routerlist.c) + * <li>extra-info documents (managed from routerlist.c) + * <li>microdescriptors (managed from microdesc.c) + * <li>vote and consensus networkstatus documents, and the routerstatus_t + * objects that they comprise (managed from networkstatus.c) + * <li>detached-signature objects used by authorities for gathering + * signatures on the networkstatus consensus (managed from dirvote.c) + * <li>authority key certificates (managed from routerlist.c) + * <li>hidden service descriptors (managed from rendcommon.c and rendcache.c) + * </ul> + **/ + +#define EXPOSE_ROUTERDESC_TOKEN_TABLE + +#include "core/or/or.h" +#include "app/config/config.h" +#include "core/or/policies.h" +#include "core/or/versions.h" +#include "feature/dirparse/parsecommon.h" +#include "feature/dirparse/policy_parse.h" +#include "feature/dirparse/routerparse.h" +#include "feature/dirparse/sigcommon.h" +#include "feature/dirparse/unparseable.h" +#include "feature/nodelist/describe.h" +#include "feature/nodelist/nickname.h" +#include "feature/nodelist/routerinfo.h" +#include "feature/nodelist/routerlist.h" +#include "feature/nodelist/torcert.h" +#include "feature/relay/router.h" +#include "lib/crypt_ops/crypto_curve25519.h" +#include "lib/crypt_ops/crypto_ed25519.h" +#include "lib/crypt_ops/crypto_format.h" +#include "lib/memarea/memarea.h" +#include "lib/sandbox/sandbox.h" + +#include "core/or/addr_policy_st.h" +#include "feature/nodelist/extrainfo_st.h" +#include "feature/nodelist/routerinfo_st.h" +#include "feature/nodelist/routerlist_st.h" + +/****************************************************************************/ + +/** List of tokens recognized in router descriptors */ +const token_rule_t routerdesc_token_table[] = { + T0N("reject", K_REJECT, ARGS, NO_OBJ ), + T0N("accept", K_ACCEPT, ARGS, NO_OBJ ), + T0N("reject6", K_REJECT6, ARGS, NO_OBJ ), + T0N("accept6", K_ACCEPT6, ARGS, NO_OBJ ), + T1_START( "router", K_ROUTER, GE(5), NO_OBJ ), + T01("ipv6-policy", K_IPV6_POLICY, CONCAT_ARGS, NO_OBJ), + T1( "signing-key", K_SIGNING_KEY, NO_ARGS, NEED_KEY_1024 ), + T1( "onion-key", K_ONION_KEY, NO_ARGS, NEED_KEY_1024 ), + T01("ntor-onion-key", K_ONION_KEY_NTOR, GE(1), NO_OBJ ), + T1_END( "router-signature", K_ROUTER_SIGNATURE, NO_ARGS, NEED_OBJ ), + T1( "published", K_PUBLISHED, CONCAT_ARGS, NO_OBJ ), + T01("uptime", K_UPTIME, GE(1), NO_OBJ ), + T01("fingerprint", K_FINGERPRINT, CONCAT_ARGS, NO_OBJ ), + T01("hibernating", K_HIBERNATING, GE(1), NO_OBJ ), + T01("platform", K_PLATFORM, CONCAT_ARGS, NO_OBJ ), + T01("proto", K_PROTO, CONCAT_ARGS, NO_OBJ ), + T01("contact", K_CONTACT, CONCAT_ARGS, NO_OBJ ), + T01("read-history", K_READ_HISTORY, ARGS, NO_OBJ ), + T01("write-history", K_WRITE_HISTORY, ARGS, NO_OBJ ), + T01("extra-info-digest", K_EXTRA_INFO_DIGEST, GE(1), NO_OBJ ), + T01("hidden-service-dir", K_HIDDEN_SERVICE_DIR, NO_ARGS, NO_OBJ ), + T01("identity-ed25519", K_IDENTITY_ED25519, NO_ARGS, NEED_OBJ ), + T01("master-key-ed25519", K_MASTER_KEY_ED25519, GE(1), NO_OBJ ), + T01("router-sig-ed25519", K_ROUTER_SIG_ED25519, GE(1), NO_OBJ ), + T01("onion-key-crosscert", K_ONION_KEY_CROSSCERT, NO_ARGS, NEED_OBJ ), + T01("ntor-onion-key-crosscert", K_NTOR_ONION_KEY_CROSSCERT, + EQ(1), NEED_OBJ ), + + T01("allow-single-hop-exits",K_ALLOW_SINGLE_HOP_EXITS, NO_ARGS, NO_OBJ ), + + T01("family", K_FAMILY, ARGS, NO_OBJ ), + T01("caches-extra-info", K_CACHES_EXTRA_INFO, NO_ARGS, NO_OBJ ), + T0N("or-address", K_OR_ADDRESS, GE(1), NO_OBJ ), + + T0N("opt", K_OPT, CONCAT_ARGS, OBJ_OK ), + T1( "bandwidth", K_BANDWIDTH, GE(3), NO_OBJ ), + A01("@purpose", A_PURPOSE, GE(1), NO_OBJ ), + T01("tunnelled-dir-server",K_DIR_TUNNELLED, NO_ARGS, NO_OBJ ), + + END_OF_TABLE +}; + +/** List of tokens recognized in extra-info documents. */ +static token_rule_t extrainfo_token_table[] = { + T1_END( "router-signature", K_ROUTER_SIGNATURE, NO_ARGS, NEED_OBJ ), + T1( "published", K_PUBLISHED, CONCAT_ARGS, NO_OBJ ), + T01("identity-ed25519", K_IDENTITY_ED25519, NO_ARGS, NEED_OBJ ), + T01("router-sig-ed25519", K_ROUTER_SIG_ED25519, GE(1), NO_OBJ ), + T0N("opt", K_OPT, CONCAT_ARGS, OBJ_OK ), + T01("read-history", K_READ_HISTORY, ARGS, NO_OBJ ), + T01("write-history", K_WRITE_HISTORY, ARGS, NO_OBJ ), + T01("dirreq-stats-end", K_DIRREQ_END, ARGS, NO_OBJ ), + T01("dirreq-v2-ips", K_DIRREQ_V2_IPS, ARGS, NO_OBJ ), + T01("dirreq-v3-ips", K_DIRREQ_V3_IPS, ARGS, NO_OBJ ), + T01("dirreq-v2-reqs", K_DIRREQ_V2_REQS, ARGS, NO_OBJ ), + T01("dirreq-v3-reqs", K_DIRREQ_V3_REQS, ARGS, NO_OBJ ), + T01("dirreq-v2-share", K_DIRREQ_V2_SHARE, ARGS, NO_OBJ ), + T01("dirreq-v3-share", K_DIRREQ_V3_SHARE, ARGS, NO_OBJ ), + T01("dirreq-v2-resp", K_DIRREQ_V2_RESP, ARGS, NO_OBJ ), + T01("dirreq-v3-resp", K_DIRREQ_V3_RESP, ARGS, NO_OBJ ), + T01("dirreq-v2-direct-dl", K_DIRREQ_V2_DIR, ARGS, NO_OBJ ), + T01("dirreq-v3-direct-dl", K_DIRREQ_V3_DIR, ARGS, NO_OBJ ), + T01("dirreq-v2-tunneled-dl", K_DIRREQ_V2_TUN, ARGS, NO_OBJ ), + T01("dirreq-v3-tunneled-dl", K_DIRREQ_V3_TUN, ARGS, NO_OBJ ), + T01("entry-stats-end", K_ENTRY_END, ARGS, NO_OBJ ), + T01("entry-ips", K_ENTRY_IPS, ARGS, NO_OBJ ), + T01("cell-stats-end", K_CELL_END, ARGS, NO_OBJ ), + T01("cell-processed-cells", K_CELL_PROCESSED, ARGS, NO_OBJ ), + T01("cell-queued-cells", K_CELL_QUEUED, ARGS, NO_OBJ ), + T01("cell-time-in-queue", K_CELL_TIME, ARGS, NO_OBJ ), + T01("cell-circuits-per-decile", K_CELL_CIRCS, ARGS, NO_OBJ ), + T01("exit-stats-end", K_EXIT_END, ARGS, NO_OBJ ), + T01("exit-kibibytes-written", K_EXIT_WRITTEN, ARGS, NO_OBJ ), + T01("exit-kibibytes-read", K_EXIT_READ, ARGS, NO_OBJ ), + T01("exit-streams-opened", K_EXIT_OPENED, ARGS, NO_OBJ ), + + T1_START( "extra-info", K_EXTRA_INFO, GE(2), NO_OBJ ), + + END_OF_TABLE +}; + +#undef T + +/* static function prototypes */ +static int router_add_exit_policy(routerinfo_t *router,directory_token_t *tok); +static smartlist_t *find_all_exitpolicy(smartlist_t *s); + +/** Set <b>digest</b> to the SHA-1 digest of the hash of the first router in + * <b>s</b>. Return 0 on success, -1 on failure. + */ +int +router_get_router_hash(const char *s, size_t s_len, char *digest) +{ + return router_get_hash_impl(s, s_len, digest, + "router ","\nrouter-signature", '\n', + DIGEST_SHA1); +} + +/** Set <b>digest</b> to the SHA-1 digest of the hash of the <b>s_len</b>-byte + * extrainfo string at <b>s</b>. Return 0 on success, -1 on failure. */ +int +router_get_extrainfo_hash(const char *s, size_t s_len, char *digest) +{ + return router_get_hash_impl(s, s_len, digest, "extra-info", + "\nrouter-signature",'\n', DIGEST_SHA1); +} + +/** Helper: move *<b>s_ptr</b> ahead to the next router, the next extra-info, + * or to the first of the annotations proceeding the next router or + * extra-info---whichever comes first. Set <b>is_extrainfo_out</b> to true if + * we found an extrainfo, or false if found a router. Do not scan beyond + * <b>eos</b>. Return -1 if we found nothing; 0 if we found something. */ +static int +find_start_of_next_router_or_extrainfo(const char **s_ptr, + const char *eos, + int *is_extrainfo_out) +{ + const char *annotations = NULL; + const char *s = *s_ptr; + + s = eat_whitespace_eos(s, eos); + + while (s < eos-32) { /* 32 gives enough room for a the first keyword. */ + /* We're at the start of a line. */ + tor_assert(*s != '\n'); + + if (*s == '@' && !annotations) { + annotations = s; + } else if (*s == 'r' && !strcmpstart(s, "router ")) { + *s_ptr = annotations ? annotations : s; + *is_extrainfo_out = 0; + return 0; + } else if (*s == 'e' && !strcmpstart(s, "extra-info ")) { + *s_ptr = annotations ? annotations : s; + *is_extrainfo_out = 1; + return 0; + } + + if (!(s = memchr(s+1, '\n', eos-(s+1)))) + break; + s = eat_whitespace_eos(s, eos); + } + return -1; +} + +/** Given a string *<b>s</b> containing a concatenated sequence of router + * descriptors (or extra-info documents if <b>want_extrainfo</b> is set), + * parses them and stores the result in <b>dest</b>. All routers are marked + * running and valid. Advances *s to a point immediately following the last + * router entry. Ignore any trailing router entries that are not complete. + * + * If <b>saved_location</b> isn't SAVED_IN_CACHE, make a local copy of each + * descriptor in the signed_descriptor_body field of each routerinfo_t. If it + * isn't SAVED_NOWHERE, remember the offset of each descriptor. + * + * Returns 0 on success and -1 on failure. Adds a digest to + * <b>invalid_digests_out</b> for every entry that was unparseable or + * invalid. (This may cause duplicate entries.) + */ +int +router_parse_list_from_string(const char **s, const char *eos, + smartlist_t *dest, + saved_location_t saved_location, + int want_extrainfo, + int allow_annotations, + const char *prepend_annotations, + smartlist_t *invalid_digests_out) +{ + routerinfo_t *router; + extrainfo_t *extrainfo; + signed_descriptor_t *signed_desc = NULL; + void *elt; + const char *end, *start; + int have_extrainfo; + + tor_assert(s); + tor_assert(*s); + tor_assert(dest); + + start = *s; + if (!eos) + eos = *s + strlen(*s); + + tor_assert(eos >= *s); + + while (1) { + char raw_digest[DIGEST_LEN]; + int have_raw_digest = 0; + int dl_again = 0; + if (find_start_of_next_router_or_extrainfo(s, eos, &have_extrainfo) < 0) + break; + + end = tor_memstr(*s, eos-*s, "\nrouter-signature"); + if (end) + end = tor_memstr(end, eos-end, "\n-----END SIGNATURE-----\n"); + if (end) + end += strlen("\n-----END SIGNATURE-----\n"); + + if (!end) + break; + + elt = NULL; + + if (have_extrainfo && want_extrainfo) { + routerlist_t *rl = router_get_routerlist(); + have_raw_digest = router_get_extrainfo_hash(*s, end-*s, raw_digest) == 0; + extrainfo = extrainfo_parse_entry_from_string(*s, end, + saved_location != SAVED_IN_CACHE, + rl->identity_map, &dl_again); + if (extrainfo) { + signed_desc = &extrainfo->cache_info; + elt = extrainfo; + } + } else if (!have_extrainfo && !want_extrainfo) { + have_raw_digest = router_get_router_hash(*s, end-*s, raw_digest) == 0; + router = router_parse_entry_from_string(*s, end, + saved_location != SAVED_IN_CACHE, + allow_annotations, + prepend_annotations, &dl_again); + if (router) { + log_debug(LD_DIR, "Read router '%s', purpose '%s'", + router_describe(router), + router_purpose_to_string(router->purpose)); + signed_desc = &router->cache_info; + elt = router; + } + } + if (! elt && ! dl_again && have_raw_digest && invalid_digests_out) { + smartlist_add(invalid_digests_out, tor_memdup(raw_digest, DIGEST_LEN)); + } + if (!elt) { + *s = end; + continue; + } + if (saved_location != SAVED_NOWHERE) { + tor_assert(signed_desc); + signed_desc->saved_location = saved_location; + signed_desc->saved_offset = *s - start; + } + *s = end; + smartlist_add(dest, elt); + } + + return 0; +} + +/** Try to find an IPv6 OR port in <b>list</b> of directory_token_t's + * with at least one argument (use GE(1) in setup). If found, store + * address and port number to <b>addr_out</b> and + * <b>port_out</b>. Return number of OR ports found. */ +int +find_single_ipv6_orport(const smartlist_t *list, + tor_addr_t *addr_out, + uint16_t *port_out) +{ + int ret = 0; + tor_assert(list != NULL); + tor_assert(addr_out != NULL); + tor_assert(port_out != NULL); + + SMARTLIST_FOREACH_BEGIN(list, directory_token_t *, t) { + tor_addr_t a; + maskbits_t bits; + uint16_t port_min, port_max; + tor_assert(t->n_args >= 1); + /* XXXX Prop186 the full spec allows much more than this. */ + if (tor_addr_parse_mask_ports(t->args[0], 0, + &a, &bits, &port_min, + &port_max) == AF_INET6 && + bits == 128 && + port_min == port_max) { + /* Okay, this is one we can understand. Use it and ignore + any potential more addresses in list. */ + tor_addr_copy(addr_out, &a); + *port_out = port_min; + ret = 1; + break; + } + } SMARTLIST_FOREACH_END(t); + + return ret; +} + +/** Helper function: reads a single router entry from *<b>s</b> ... + * *<b>end</b>. Mallocs a new router and returns it if all goes well, else + * returns NULL. If <b>cache_copy</b> is true, duplicate the contents of + * s through end into the signed_descriptor_body of the resulting + * routerinfo_t. + * + * If <b>end</b> is NULL, <b>s</b> must be properly NUL-terminated. + * + * If <b>allow_annotations</b>, it's okay to encounter annotations in <b>s</b> + * before the router; if it's false, reject the router if it's annotated. If + * <b>prepend_annotations</b> is set, it should contain some annotations: + * append them to the front of the router before parsing it, and keep them + * around when caching the router. + * + * Only one of allow_annotations and prepend_annotations may be set. + * + * If <b>can_dl_again_out</b> is provided, set *<b>can_dl_again_out</b> to 1 + * if it's okay to try to download a descriptor with this same digest again, + * and 0 if it isn't. (It might not be okay to download it again if part of + * the part covered by the digest is invalid.) + */ +routerinfo_t * +router_parse_entry_from_string(const char *s, const char *end, + int cache_copy, int allow_annotations, + const char *prepend_annotations, + int *can_dl_again_out) +{ + routerinfo_t *router = NULL; + char digest[128]; + smartlist_t *tokens = NULL, *exit_policy_tokens = NULL; + directory_token_t *tok; + struct in_addr in; + const char *start_of_annotations, *cp, *s_dup = s; + size_t prepend_len = prepend_annotations ? strlen(prepend_annotations) : 0; + int ok = 1; + memarea_t *area = NULL; + tor_cert_t *ntor_cc_cert = NULL; + /* Do not set this to '1' until we have parsed everything that we intend to + * parse that's covered by the hash. */ + int can_dl_again = 0; + crypto_pk_t *rsa_pubkey = NULL; + + tor_assert(!allow_annotations || !prepend_annotations); + + if (!end) { + end = s + strlen(s); + } + + /* point 'end' to a point immediately after the final newline. */ + while (end > s+2 && *(end-1) == '\n' && *(end-2) == '\n') + --end; + + area = memarea_new(); + tokens = smartlist_new(); + if (prepend_annotations) { + if (tokenize_string(area,prepend_annotations,NULL,tokens, + routerdesc_token_table,TS_NOCHECK)) { + log_warn(LD_DIR, "Error tokenizing router descriptor (annotations)."); + goto err; + } + } + + start_of_annotations = s; + cp = tor_memstr(s, end-s, "\nrouter "); + if (!cp) { + if (end-s < 7 || strcmpstart(s, "router ")) { + log_warn(LD_DIR, "No router keyword found."); + goto err; + } + } else { + s = cp+1; + } + + if (start_of_annotations != s) { /* We have annotations */ + if (allow_annotations) { + if (tokenize_string(area,start_of_annotations,s,tokens, + routerdesc_token_table,TS_NOCHECK)) { + log_warn(LD_DIR, "Error tokenizing router descriptor (annotations)."); + goto err; + } + } else { + log_warn(LD_DIR, "Found unexpected annotations on router descriptor not " + "loaded from disk. Dropping it."); + goto err; + } + } + + if (router_get_router_hash(s, end - s, digest) < 0) { + log_warn(LD_DIR, "Couldn't compute router hash."); + goto err; + } + { + int flags = 0; + if (allow_annotations) + flags |= TS_ANNOTATIONS_OK; + if (prepend_annotations) + flags |= TS_ANNOTATIONS_OK|TS_NO_NEW_ANNOTATIONS; + + if (tokenize_string(area,s,end,tokens,routerdesc_token_table, flags)) { + log_warn(LD_DIR, "Error tokenizing router descriptor."); + goto err; + } + } + + if (smartlist_len(tokens) < 2) { + log_warn(LD_DIR, "Impossibly short router descriptor."); + goto err; + } + + tok = find_by_keyword(tokens, K_ROUTER); + const int router_token_pos = smartlist_pos(tokens, tok); + tor_assert(tok->n_args >= 5); + + router = tor_malloc_zero(sizeof(routerinfo_t)); + router->cert_expiration_time = TIME_MAX; + router->cache_info.routerlist_index = -1; + router->cache_info.annotations_len = s-start_of_annotations + prepend_len; + router->cache_info.signed_descriptor_len = end-s; + if (cache_copy) { + size_t len = router->cache_info.signed_descriptor_len + + router->cache_info.annotations_len; + char *signed_body = + router->cache_info.signed_descriptor_body = tor_malloc(len+1); + if (prepend_annotations) { + memcpy(signed_body, prepend_annotations, prepend_len); + signed_body += prepend_len; + } + /* This assertion will always succeed. + * len == signed_desc_len + annotations_len + * == end-s + s-start_of_annotations + prepend_len + * == end-start_of_annotations + prepend_len + * We already wrote prepend_len bytes into the buffer; now we're + * writing end-start_of_annotations -NM. */ + tor_assert(signed_body+(end-start_of_annotations) == + router->cache_info.signed_descriptor_body+len); + memcpy(signed_body, start_of_annotations, end-start_of_annotations); + router->cache_info.signed_descriptor_body[len] = '\0'; + tor_assert(strlen(router->cache_info.signed_descriptor_body) == len); + } + memcpy(router->cache_info.signed_descriptor_digest, digest, DIGEST_LEN); + + router->nickname = tor_strdup(tok->args[0]); + if (!is_legal_nickname(router->nickname)) { + log_warn(LD_DIR,"Router nickname is invalid"); + goto err; + } + if (!tor_inet_aton(tok->args[1], &in)) { + log_warn(LD_DIR,"Router address is not an IP address."); + goto err; + } + router->addr = ntohl(in.s_addr); + + router->or_port = + (uint16_t) tor_parse_long(tok->args[2],10,0,65535,&ok,NULL); + if (!ok) { + log_warn(LD_DIR,"Invalid OR port %s", escaped(tok->args[2])); + goto err; + } + router->dir_port = + (uint16_t) tor_parse_long(tok->args[4],10,0,65535,&ok,NULL); + if (!ok) { + log_warn(LD_DIR,"Invalid dir port %s", escaped(tok->args[4])); + goto err; + } + + tok = find_by_keyword(tokens, K_BANDWIDTH); + tor_assert(tok->n_args >= 3); + router->bandwidthrate = (int) + tor_parse_long(tok->args[0],10,1,INT_MAX,&ok,NULL); + + if (!ok) { + log_warn(LD_DIR, "bandwidthrate %s unreadable or 0. Failing.", + escaped(tok->args[0])); + goto err; + } + router->bandwidthburst = + (int) tor_parse_long(tok->args[1],10,0,INT_MAX,&ok,NULL); + if (!ok) { + log_warn(LD_DIR, "Invalid bandwidthburst %s", escaped(tok->args[1])); + goto err; + } + router->bandwidthcapacity = (int) + tor_parse_long(tok->args[2],10,0,INT_MAX,&ok,NULL); + if (!ok) { + log_warn(LD_DIR, "Invalid bandwidthcapacity %s", escaped(tok->args[1])); + goto err; + } + + if ((tok = find_opt_by_keyword(tokens, A_PURPOSE))) { + tor_assert(tok->n_args); + router->purpose = router_purpose_from_string(tok->args[0]); + } else { + router->purpose = ROUTER_PURPOSE_GENERAL; + } + router->cache_info.send_unencrypted = + (router->purpose == ROUTER_PURPOSE_GENERAL) ? 1 : 0; + + if ((tok = find_opt_by_keyword(tokens, K_UPTIME))) { + tor_assert(tok->n_args >= 1); + router->uptime = tor_parse_long(tok->args[0],10,0,LONG_MAX,&ok,NULL); + if (!ok) { + log_warn(LD_DIR, "Invalid uptime %s", escaped(tok->args[0])); + goto err; + } + } + + if ((tok = find_opt_by_keyword(tokens, K_HIBERNATING))) { + tor_assert(tok->n_args >= 1); + router->is_hibernating + = (tor_parse_long(tok->args[0],10,0,LONG_MAX,NULL,NULL) != 0); + } + + tok = find_by_keyword(tokens, K_PUBLISHED); + tor_assert(tok->n_args == 1); + if (parse_iso_time(tok->args[0], &router->cache_info.published_on) < 0) + goto err; + + tok = find_by_keyword(tokens, K_ONION_KEY); + if (!crypto_pk_public_exponent_ok(tok->key)) { + log_warn(LD_DIR, + "Relay's onion key had invalid exponent."); + goto err; + } + router_set_rsa_onion_pkey(tok->key, &router->onion_pkey, + &router->onion_pkey_len); + crypto_pk_free(tok->key); + + if ((tok = find_opt_by_keyword(tokens, K_ONION_KEY_NTOR))) { + curve25519_public_key_t k; + tor_assert(tok->n_args >= 1); + if (curve25519_public_from_base64(&k, tok->args[0]) < 0) { + log_warn(LD_DIR, "Bogus ntor-onion-key in routerinfo"); + goto err; + } + router->onion_curve25519_pkey = + tor_memdup(&k, sizeof(curve25519_public_key_t)); + } + + tok = find_by_keyword(tokens, K_SIGNING_KEY); + router->identity_pkey = tok->key; + tok->key = NULL; /* Prevent free */ + if (crypto_pk_get_digest(router->identity_pkey, + router->cache_info.identity_digest)) { + log_warn(LD_DIR, "Couldn't calculate key digest"); goto err; + } + + { + directory_token_t *ed_sig_tok, *ed_cert_tok, *cc_tap_tok, *cc_ntor_tok, + *master_key_tok; + ed_sig_tok = find_opt_by_keyword(tokens, K_ROUTER_SIG_ED25519); + ed_cert_tok = find_opt_by_keyword(tokens, K_IDENTITY_ED25519); + master_key_tok = find_opt_by_keyword(tokens, K_MASTER_KEY_ED25519); + cc_tap_tok = find_opt_by_keyword(tokens, K_ONION_KEY_CROSSCERT); + cc_ntor_tok = find_opt_by_keyword(tokens, K_NTOR_ONION_KEY_CROSSCERT); + int n_ed_toks = !!ed_sig_tok + !!ed_cert_tok + + !!cc_tap_tok + !!cc_ntor_tok; + if ((n_ed_toks != 0 && n_ed_toks != 4) || + (n_ed_toks == 4 && !router->onion_curve25519_pkey)) { + log_warn(LD_DIR, "Router descriptor with only partial ed25519/" + "cross-certification support"); + goto err; + } + if (master_key_tok && !ed_sig_tok) { + log_warn(LD_DIR, "Router descriptor has ed25519 master key but no " + "certificate"); + goto err; + } + if (ed_sig_tok) { + tor_assert(ed_cert_tok && cc_tap_tok && cc_ntor_tok); + const int ed_cert_token_pos = smartlist_pos(tokens, ed_cert_tok); + if (ed_cert_token_pos == -1 || router_token_pos == -1 || + (ed_cert_token_pos != router_token_pos + 1 && + ed_cert_token_pos != router_token_pos - 1)) { + log_warn(LD_DIR, "Ed25519 certificate in wrong position"); + goto err; + } + if (ed_sig_tok != smartlist_get(tokens, smartlist_len(tokens)-2)) { + log_warn(LD_DIR, "Ed25519 signature in wrong position"); + goto err; + } + if (strcmp(ed_cert_tok->object_type, "ED25519 CERT")) { + log_warn(LD_DIR, "Wrong object type on identity-ed25519 in decriptor"); + goto err; + } + if (strcmp(cc_ntor_tok->object_type, "ED25519 CERT")) { + log_warn(LD_DIR, "Wrong object type on ntor-onion-key-crosscert " + "in decriptor"); + goto err; + } + if (strcmp(cc_tap_tok->object_type, "CROSSCERT")) { + log_warn(LD_DIR, "Wrong object type on onion-key-crosscert " + "in decriptor"); + goto err; + } + if (strcmp(cc_ntor_tok->args[0], "0") && + strcmp(cc_ntor_tok->args[0], "1")) { + log_warn(LD_DIR, "Bad sign bit on ntor-onion-key-crosscert"); + goto err; + } + int ntor_cc_sign_bit = !strcmp(cc_ntor_tok->args[0], "1"); + + uint8_t d256[DIGEST256_LEN]; + const char *signed_start, *signed_end; + tor_cert_t *cert = tor_cert_parse( + (const uint8_t*)ed_cert_tok->object_body, + ed_cert_tok->object_size); + if (! cert) { + log_warn(LD_DIR, "Couldn't parse ed25519 cert"); + goto err; + } + /* makes sure it gets freed. */ + router->cache_info.signing_key_cert = cert; + + if (cert->cert_type != CERT_TYPE_ID_SIGNING || + ! cert->signing_key_included) { + log_warn(LD_DIR, "Invalid form for ed25519 cert"); + goto err; + } + + if (master_key_tok) { + /* This token is optional, but if it's present, it must match + * the signature in the signing cert, or supplant it. */ + tor_assert(master_key_tok->n_args >= 1); + ed25519_public_key_t pkey; + if (ed25519_public_from_base64(&pkey, master_key_tok->args[0])<0) { + log_warn(LD_DIR, "Can't parse ed25519 master key"); + goto err; + } + + if (fast_memneq(&cert->signing_key.pubkey, + pkey.pubkey, ED25519_PUBKEY_LEN)) { + log_warn(LD_DIR, "Ed25519 master key does not match " + "key in certificate"); + goto err; + } + } + ntor_cc_cert = tor_cert_parse((const uint8_t*)cc_ntor_tok->object_body, + cc_ntor_tok->object_size); + if (!ntor_cc_cert) { + log_warn(LD_DIR, "Couldn't parse ntor-onion-key-crosscert cert"); + goto err; + } + if (ntor_cc_cert->cert_type != CERT_TYPE_ONION_ID || + ! ed25519_pubkey_eq(&ntor_cc_cert->signed_key, &cert->signing_key)) { + log_warn(LD_DIR, "Invalid contents for ntor-onion-key-crosscert cert"); + goto err; + } + + ed25519_public_key_t ntor_cc_pk; + if (ed25519_public_key_from_curve25519_public_key(&ntor_cc_pk, + router->onion_curve25519_pkey, + ntor_cc_sign_bit)<0) { + log_warn(LD_DIR, "Error converting onion key to ed25519"); + goto err; + } + + if (router_get_hash_impl_helper(s, end-s, "router ", + "\nrouter-sig-ed25519", + ' ', LOG_WARN, + &signed_start, &signed_end) < 0) { + log_warn(LD_DIR, "Can't find ed25519-signed portion of descriptor"); + goto err; + } + crypto_digest_t *d = crypto_digest256_new(DIGEST_SHA256); + crypto_digest_add_bytes(d, ED_DESC_SIGNATURE_PREFIX, + strlen(ED_DESC_SIGNATURE_PREFIX)); + crypto_digest_add_bytes(d, signed_start, signed_end-signed_start); + crypto_digest_get_digest(d, (char*)d256, sizeof(d256)); + crypto_digest_free(d); + + ed25519_checkable_t check[3]; + int check_ok[3]; + time_t expires = TIME_MAX; + if (tor_cert_get_checkable_sig(&check[0], cert, NULL, &expires) < 0) { + log_err(LD_BUG, "Couldn't create 'checkable' for cert."); + goto err; + } + if (tor_cert_get_checkable_sig(&check[1], + ntor_cc_cert, &ntor_cc_pk, &expires) < 0) { + log_err(LD_BUG, "Couldn't create 'checkable' for ntor_cc_cert."); + goto err; + } + + if (ed25519_signature_from_base64(&check[2].signature, + ed_sig_tok->args[0])<0) { + log_warn(LD_DIR, "Couldn't decode ed25519 signature"); + goto err; + } + check[2].pubkey = &cert->signed_key; + check[2].msg = d256; + check[2].len = DIGEST256_LEN; + + if (ed25519_checksig_batch(check_ok, check, 3) < 0) { + log_warn(LD_DIR, "Incorrect ed25519 signature(s)"); + goto err; + } + + rsa_pubkey = router_get_rsa_onion_pkey(router->onion_pkey, + router->onion_pkey_len); + if (check_tap_onion_key_crosscert( + (const uint8_t*)cc_tap_tok->object_body, + (int)cc_tap_tok->object_size, + rsa_pubkey, + &cert->signing_key, + (const uint8_t*)router->cache_info.identity_digest)<0) { + log_warn(LD_DIR, "Incorrect TAP cross-verification"); + goto err; + } + + /* We check this before adding it to the routerlist. */ + router->cert_expiration_time = expires; + } + } + + if ((tok = find_opt_by_keyword(tokens, K_FINGERPRINT))) { + /* If there's a fingerprint line, it must match the identity digest. */ + char d[DIGEST_LEN]; + tor_assert(tok->n_args == 1); + tor_strstrip(tok->args[0], " "); + if (base16_decode(d, DIGEST_LEN, + tok->args[0], strlen(tok->args[0])) != DIGEST_LEN) { + log_warn(LD_DIR, "Couldn't decode router fingerprint %s", + escaped(tok->args[0])); + goto err; + } + if (tor_memneq(d,router->cache_info.identity_digest, DIGEST_LEN)) { + log_warn(LD_DIR, "Fingerprint '%s' does not match identity digest.", + tok->args[0]); + goto err; + } + } + + { + const char *version = NULL, *protocols = NULL; + if ((tok = find_opt_by_keyword(tokens, K_PLATFORM))) { + router->platform = tor_strdup(tok->args[0]); + version = tok->args[0]; + } + + if ((tok = find_opt_by_keyword(tokens, K_PROTO))) { + router->protocol_list = tor_strdup(tok->args[0]); + protocols = tok->args[0]; + } + + summarize_protover_flags(&router->pv, protocols, version); + } + + if ((tok = find_opt_by_keyword(tokens, K_CONTACT))) { + router->contact_info = tor_strdup(tok->args[0]); + } + + if (find_opt_by_keyword(tokens, K_REJECT6) || + find_opt_by_keyword(tokens, K_ACCEPT6)) { + log_warn(LD_DIR, "Rejecting router with reject6/accept6 line: they crash " + "older Tors."); + goto err; + } + { + smartlist_t *or_addresses = find_all_by_keyword(tokens, K_OR_ADDRESS); + if (or_addresses) { + find_single_ipv6_orport(or_addresses, &router->ipv6_addr, + &router->ipv6_orport); + smartlist_free(or_addresses); + } + } + exit_policy_tokens = find_all_exitpolicy(tokens); + if (!smartlist_len(exit_policy_tokens)) { + log_warn(LD_DIR, "No exit policy tokens in descriptor."); + goto err; + } + SMARTLIST_FOREACH(exit_policy_tokens, directory_token_t *, t, + if (router_add_exit_policy(router,t)<0) { + log_warn(LD_DIR,"Error in exit policy"); + goto err; + }); + policy_expand_private(&router->exit_policy); + + if ((tok = find_opt_by_keyword(tokens, K_IPV6_POLICY)) && tok->n_args) { + router->ipv6_exit_policy = parse_short_policy(tok->args[0]); + if (! router->ipv6_exit_policy) { + log_warn(LD_DIR , "Error in ipv6-policy %s", escaped(tok->args[0])); + goto err; + } + } + + if (policy_is_reject_star(router->exit_policy, AF_INET, 1) && + (!router->ipv6_exit_policy || + short_policy_is_reject_star(router->ipv6_exit_policy))) + router->policy_is_reject_star = 1; + + if ((tok = find_opt_by_keyword(tokens, K_FAMILY)) && tok->n_args) { + int i; + router->declared_family = smartlist_new(); + for (i=0;i<tok->n_args;++i) { + if (!is_legal_nickname_or_hexdigest(tok->args[i])) { + log_warn(LD_DIR, "Illegal nickname %s in family line", + escaped(tok->args[i])); + goto err; + } + smartlist_add_strdup(router->declared_family, tok->args[i]); + } + } + + if (find_opt_by_keyword(tokens, K_CACHES_EXTRA_INFO)) + router->caches_extra_info = 1; + + if (find_opt_by_keyword(tokens, K_ALLOW_SINGLE_HOP_EXITS)) + router->allow_single_hop_exits = 1; + + if ((tok = find_opt_by_keyword(tokens, K_EXTRA_INFO_DIGEST))) { + tor_assert(tok->n_args >= 1); + if (strlen(tok->args[0]) == HEX_DIGEST_LEN) { + if (base16_decode(router->cache_info.extra_info_digest, DIGEST_LEN, + tok->args[0], HEX_DIGEST_LEN) != DIGEST_LEN) { + log_warn(LD_DIR,"Invalid extra info digest"); + } + } else { + log_warn(LD_DIR, "Invalid extra info digest %s", escaped(tok->args[0])); + } + + if (tok->n_args >= 2) { + if (digest256_from_base64(router->cache_info.extra_info_digest256, + tok->args[1]) < 0) { + log_warn(LD_DIR, "Invalid extra info digest256 %s", + escaped(tok->args[1])); + } + } + } + + if (find_opt_by_keyword(tokens, K_HIDDEN_SERVICE_DIR)) { + router->wants_to_be_hs_dir = 1; + } + + /* This router accepts tunnelled directory requests via begindir if it has + * an open dirport or it included "tunnelled-dir-server". */ + if (find_opt_by_keyword(tokens, K_DIR_TUNNELLED) || router->dir_port > 0) { + router->supports_tunnelled_dir_requests = 1; + } + + tok = find_by_keyword(tokens, K_ROUTER_SIGNATURE); + + if (!router->or_port) { + log_warn(LD_DIR,"or_port unreadable or 0. Failing."); + goto err; + } + + /* We've checked everything that's covered by the hash. */ + can_dl_again = 1; + if (check_signature_token(digest, DIGEST_LEN, tok, router->identity_pkey, 0, + "router descriptor") < 0) + goto err; + + if (!router->platform) { + router->platform = tor_strdup("<unknown>"); + } + goto done; + + err: + dump_desc(s_dup, "router descriptor"); + routerinfo_free(router); + router = NULL; + done: + crypto_pk_free(rsa_pubkey); + tor_cert_free(ntor_cc_cert); + if (tokens) { + SMARTLIST_FOREACH(tokens, directory_token_t *, t, token_clear(t)); + smartlist_free(tokens); + } + smartlist_free(exit_policy_tokens); + if (area) { + DUMP_AREA(area, "routerinfo"); + memarea_drop_all(area); + } + if (can_dl_again_out) + *can_dl_again_out = can_dl_again; + return router; +} + +/** Parse a single extrainfo entry from the string <b>s</b>, ending at + * <b>end</b>. (If <b>end</b> is NULL, parse up to the end of <b>s</b>.) If + * <b>cache_copy</b> is true, make a copy of the extra-info document in the + * cache_info fields of the result. If <b>routermap</b> is provided, use it + * as a map from router identity to routerinfo_t when looking up signing keys. + * + * If <b>can_dl_again_out</b> is provided, set *<b>can_dl_again_out</b> to 1 + * if it's okay to try to download an extrainfo with this same digest again, + * and 0 if it isn't. (It might not be okay to download it again if part of + * the part covered by the digest is invalid.) + */ +extrainfo_t * +extrainfo_parse_entry_from_string(const char *s, const char *end, + int cache_copy, struct digest_ri_map_t *routermap, + int *can_dl_again_out) +{ + extrainfo_t *extrainfo = NULL; + char digest[128]; + smartlist_t *tokens = NULL; + directory_token_t *tok; + crypto_pk_t *key = NULL; + routerinfo_t *router = NULL; + memarea_t *area = NULL; + const char *s_dup = s; + /* Do not set this to '1' until we have parsed everything that we intend to + * parse that's covered by the hash. */ + int can_dl_again = 0; + + if (BUG(s == NULL)) + return NULL; + + if (!end) { + end = s + strlen(s); + } + + /* point 'end' to a point immediately after the final newline. */ + while (end > s+2 && *(end-1) == '\n' && *(end-2) == '\n') + --end; + + if (router_get_extrainfo_hash(s, end-s, digest) < 0) { + log_warn(LD_DIR, "Couldn't compute router hash."); + goto err; + } + tokens = smartlist_new(); + area = memarea_new(); + if (tokenize_string(area,s,end,tokens,extrainfo_token_table,0)) { + log_warn(LD_DIR, "Error tokenizing extra-info document."); + goto err; + } + + if (smartlist_len(tokens) < 2) { + log_warn(LD_DIR, "Impossibly short extra-info document."); + goto err; + } + + /* XXXX Accept this in position 1 too, and ed identity in position 0. */ + tok = smartlist_get(tokens,0); + if (tok->tp != K_EXTRA_INFO) { + log_warn(LD_DIR,"Entry does not start with \"extra-info\""); + goto err; + } + + extrainfo = tor_malloc_zero(sizeof(extrainfo_t)); + extrainfo->cache_info.is_extrainfo = 1; + if (cache_copy) + extrainfo->cache_info.signed_descriptor_body = tor_memdup_nulterm(s,end-s); + extrainfo->cache_info.signed_descriptor_len = end-s; + memcpy(extrainfo->cache_info.signed_descriptor_digest, digest, DIGEST_LEN); + crypto_digest256((char*)extrainfo->digest256, s, end-s, DIGEST_SHA256); + + tor_assert(tok->n_args >= 2); + if (!is_legal_nickname(tok->args[0])) { + log_warn(LD_DIR,"Bad nickname %s on \"extra-info\"",escaped(tok->args[0])); + goto err; + } + strlcpy(extrainfo->nickname, tok->args[0], sizeof(extrainfo->nickname)); + if (strlen(tok->args[1]) != HEX_DIGEST_LEN || + base16_decode(extrainfo->cache_info.identity_digest, DIGEST_LEN, + tok->args[1], HEX_DIGEST_LEN) != DIGEST_LEN) { + log_warn(LD_DIR,"Invalid fingerprint %s on \"extra-info\"", + escaped(tok->args[1])); + goto err; + } + + tok = find_by_keyword(tokens, K_PUBLISHED); + if (parse_iso_time(tok->args[0], &extrainfo->cache_info.published_on)) { + log_warn(LD_DIR,"Invalid published time %s on \"extra-info\"", + escaped(tok->args[0])); + goto err; + } + + { + directory_token_t *ed_sig_tok, *ed_cert_tok; + ed_sig_tok = find_opt_by_keyword(tokens, K_ROUTER_SIG_ED25519); + ed_cert_tok = find_opt_by_keyword(tokens, K_IDENTITY_ED25519); + int n_ed_toks = !!ed_sig_tok + !!ed_cert_tok; + if (n_ed_toks != 0 && n_ed_toks != 2) { + log_warn(LD_DIR, "Router descriptor with only partial ed25519/" + "cross-certification support"); + goto err; + } + if (ed_sig_tok) { + tor_assert(ed_cert_tok); + const int ed_cert_token_pos = smartlist_pos(tokens, ed_cert_tok); + if (ed_cert_token_pos != 1) { + /* Accept this in position 0 XXXX */ + log_warn(LD_DIR, "Ed25519 certificate in wrong position"); + goto err; + } + if (ed_sig_tok != smartlist_get(tokens, smartlist_len(tokens)-2)) { + log_warn(LD_DIR, "Ed25519 signature in wrong position"); + goto err; + } + if (strcmp(ed_cert_tok->object_type, "ED25519 CERT")) { + log_warn(LD_DIR, "Wrong object type on identity-ed25519 in decriptor"); + goto err; + } + + uint8_t d256[DIGEST256_LEN]; + const char *signed_start, *signed_end; + tor_cert_t *cert = tor_cert_parse( + (const uint8_t*)ed_cert_tok->object_body, + ed_cert_tok->object_size); + if (! cert) { + log_warn(LD_DIR, "Couldn't parse ed25519 cert"); + goto err; + } + /* makes sure it gets freed. */ + extrainfo->cache_info.signing_key_cert = cert; + + if (cert->cert_type != CERT_TYPE_ID_SIGNING || + ! cert->signing_key_included) { + log_warn(LD_DIR, "Invalid form for ed25519 cert"); + goto err; + } + + if (router_get_hash_impl_helper(s, end-s, "extra-info ", + "\nrouter-sig-ed25519", + ' ', LOG_WARN, + &signed_start, &signed_end) < 0) { + log_warn(LD_DIR, "Can't find ed25519-signed portion of extrainfo"); + goto err; + } + crypto_digest_t *d = crypto_digest256_new(DIGEST_SHA256); + crypto_digest_add_bytes(d, ED_DESC_SIGNATURE_PREFIX, + strlen(ED_DESC_SIGNATURE_PREFIX)); + crypto_digest_add_bytes(d, signed_start, signed_end-signed_start); + crypto_digest_get_digest(d, (char*)d256, sizeof(d256)); + crypto_digest_free(d); + + ed25519_checkable_t check[2]; + int check_ok[2]; + if (tor_cert_get_checkable_sig(&check[0], cert, NULL, NULL) < 0) { + log_err(LD_BUG, "Couldn't create 'checkable' for cert."); + goto err; + } + + if (ed25519_signature_from_base64(&check[1].signature, + ed_sig_tok->args[0])<0) { + log_warn(LD_DIR, "Couldn't decode ed25519 signature"); + goto err; + } + check[1].pubkey = &cert->signed_key; + check[1].msg = d256; + check[1].len = DIGEST256_LEN; + + if (ed25519_checksig_batch(check_ok, check, 2) < 0) { + log_warn(LD_DIR, "Incorrect ed25519 signature(s)"); + goto err; + } + /* We don't check the certificate expiration time: checking that it + * matches the cert in the router descriptor is adequate. */ + } + } + + /* We've checked everything that's covered by the hash. */ + can_dl_again = 1; + + if (routermap && + (router = digestmap_get((digestmap_t*)routermap, + extrainfo->cache_info.identity_digest))) { + key = router->identity_pkey; + } + + tok = find_by_keyword(tokens, K_ROUTER_SIGNATURE); + if (strcmp(tok->object_type, "SIGNATURE") || + tok->object_size < 128 || tok->object_size > 512) { + log_warn(LD_DIR, "Bad object type or length on extra-info signature"); + goto err; + } + + if (key) { + if (check_signature_token(digest, DIGEST_LEN, tok, key, 0, + "extra-info") < 0) + goto err; + + if (router) + extrainfo->cache_info.send_unencrypted = + router->cache_info.send_unencrypted; + } else { + extrainfo->pending_sig = tor_memdup(tok->object_body, + tok->object_size); + extrainfo->pending_sig_len = tok->object_size; + } + + goto done; + err: + dump_desc(s_dup, "extra-info descriptor"); + extrainfo_free(extrainfo); + extrainfo = NULL; + done: + if (tokens) { + SMARTLIST_FOREACH(tokens, directory_token_t *, t, token_clear(t)); + smartlist_free(tokens); + } + if (area) { + DUMP_AREA(area, "extrainfo"); + memarea_drop_all(area); + } + if (can_dl_again_out) + *can_dl_again_out = can_dl_again; + return extrainfo; +} + +/** Add an exit policy stored in the token <b>tok</b> to the router info in + * <b>router</b>. Return 0 on success, -1 on failure. */ +static int +router_add_exit_policy(routerinfo_t *router, directory_token_t *tok) +{ + addr_policy_t *newe; + /* Use the standard interpretation of accept/reject *, an IPv4 wildcard. */ + newe = router_parse_addr_policy(tok, 0); + if (!newe) + return -1; + if (! router->exit_policy) + router->exit_policy = smartlist_new(); + + /* Ensure that in descriptors, accept/reject fields are followed by + * IPv4 addresses, and accept6/reject6 fields are followed by + * IPv6 addresses. Unlike torrcs, descriptor exit policies do not permit + * accept/reject followed by IPv6. */ + if (((tok->tp == K_ACCEPT6 || tok->tp == K_REJECT6) && + tor_addr_family(&newe->addr) == AF_INET) + || + ((tok->tp == K_ACCEPT || tok->tp == K_REJECT) && + tor_addr_family(&newe->addr) == AF_INET6)) { + /* There's nothing the user can do about other relays' descriptors, + * so we don't provide usage advice here. */ + log_warn(LD_DIR, "Mismatch between field type and address type in exit " + "policy '%s'. Discarding entire router descriptor.", + tok->n_args == 1 ? tok->args[0] : ""); + addr_policy_free(newe); + return -1; + } + + smartlist_add(router->exit_policy, newe); + + return 0; +} + +/** Return a newly allocated smartlist of all accept or reject tokens in + * <b>s</b>. + */ +static smartlist_t * +find_all_exitpolicy(smartlist_t *s) +{ + smartlist_t *out = smartlist_new(); + SMARTLIST_FOREACH(s, directory_token_t *, t, + if (t->tp == K_ACCEPT || t->tp == K_ACCEPT6 || + t->tp == K_REJECT || t->tp == K_REJECT6) + smartlist_add(out,t)); + return out; +} + +/** Called on startup; right now we just handle scanning the unparseable + * descriptor dumps, but hang anything else we might need to do in the + * future here as well. + */ +void +routerparse_init(void) +{ + /* + * Check both if the sandbox is active and whether it's configured; no + * point in loading all that if we won't be able to use it after the + * sandbox becomes active. + */ + if (!(sandbox_is_active() || get_options()->Sandbox)) { + dump_desc_init(); + } +} + +/** Clean up all data structures used by routerparse.c at exit */ +void +routerparse_free_all(void) +{ + dump_desc_fifo_cleanup(); +} diff --git a/src/feature/dirparse/routerparse.h b/src/feature/dirparse/routerparse.h new file mode 100644 index 0000000000..6568dce0a4 --- /dev/null +++ b/src/feature/dirparse/routerparse.h @@ -0,0 +1,49 @@ +/* Copyright (c) 2001 Matej Pfajfar. + * Copyright (c) 2001-2004, Roger Dingledine. + * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson. + * Copyright (c) 2007-2018, The Tor Project, Inc. */ +/* See LICENSE for licensing information */ + +/** + * \file routerparse.h + * \brief Header file for routerparse.c. + **/ + +#ifndef TOR_ROUTERPARSE_H +#define TOR_ROUTERPARSE_H + +int router_get_router_hash(const char *s, size_t s_len, char *digest); +int router_get_extrainfo_hash(const char *s, size_t s_len, char *digest); + +int router_parse_list_from_string(const char **s, const char *eos, + smartlist_t *dest, + saved_location_t saved_location, + int is_extrainfo, + int allow_annotations, + const char *prepend_annotations, + smartlist_t *invalid_digests_out); + +routerinfo_t *router_parse_entry_from_string(const char *s, const char *end, + int cache_copy, + int allow_annotations, + const char *prepend_annotations, + int *can_dl_again_out); +struct digest_ri_map_t; +extrainfo_t *extrainfo_parse_entry_from_string(const char *s, const char *end, + int cache_copy, struct digest_ri_map_t *routermap, + int *can_dl_again_out); + +int find_single_ipv6_orport(const smartlist_t *list, + tor_addr_t *addr_out, + uint16_t *port_out); + +void routerparse_init(void); +void routerparse_free_all(void); + +#ifdef EXPOSE_ROUTERDESC_TOKEN_TABLE +extern const struct token_rule_t routerdesc_token_table[]; +#endif + +#define ED_DESC_SIGNATURE_PREFIX "Tor router descriptor signature v1" + +#endif /* !defined(TOR_ROUTERPARSE_H) */ diff --git a/src/feature/dirparse/sigcommon.c b/src/feature/dirparse/sigcommon.c new file mode 100644 index 0000000000..28e6ff56ed --- /dev/null +++ b/src/feature/dirparse/sigcommon.c @@ -0,0 +1,185 @@ +/* Copyright (c) 2001 Matej Pfajfar. + * Copyright (c) 2001-2004, Roger Dingledine. + * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson. + * Copyright (c) 2007-2018, The Tor Project, Inc. */ +/* See LICENSE for licensing information */ + +/** + * \file sigcommon.c + * \brief Shared hashing, signing, and signature-checking code for directory + * objects. + **/ + +#define SIGCOMMON_PRIVATE + +#include "core/or/or.h" +#include "feature/dirparse/parsecommon.h" +#include "feature/dirparse/sigcommon.h" + +/** Helper function for <b>router_get_hash_impl</b>: given <b>s</b>, + * <b>s_len</b>, <b>start_str</b>, <b>end_str</b>, and <b>end_c</b> with the + * same semantics as in that function, set *<b>start_out</b> (inclusive) and + * *<b>end_out</b> (exclusive) to the boundaries of the string to be hashed. + * + * Return 0 on success and -1 on failure. + */ +int +router_get_hash_impl_helper(const char *s, size_t s_len, + const char *start_str, + const char *end_str, char end_c, + int log_severity, + const char **start_out, const char **end_out) +{ + const char *start, *end; + start = tor_memstr(s, s_len, start_str); + if (!start) { + log_fn(log_severity,LD_DIR, + "couldn't find start of hashed material \"%s\"",start_str); + return -1; + } + if (start != s && *(start-1) != '\n') { + log_fn(log_severity,LD_DIR, + "first occurrence of \"%s\" is not at the start of a line", + start_str); + return -1; + } + end = tor_memstr(start+strlen(start_str), + s_len - (start-s) - strlen(start_str), end_str); + if (!end) { + log_fn(log_severity,LD_DIR, + "couldn't find end of hashed material \"%s\"",end_str); + return -1; + } + end = memchr(end+strlen(end_str), end_c, s_len - (end-s) - strlen(end_str)); + if (!end) { + log_fn(log_severity,LD_DIR, + "couldn't find EOL"); + return -1; + } + ++end; + + *start_out = start; + *end_out = end; + return 0; +} + +/** Compute the digest of the substring of <b>s</b> taken from the first + * occurrence of <b>start_str</b> through the first instance of c after the + * first subsequent occurrence of <b>end_str</b>; store the 20-byte or 32-byte + * result in <b>digest</b>; return 0 on success. + * + * If no such substring exists, return -1. + */ +int +router_get_hash_impl(const char *s, size_t s_len, char *digest, + const char *start_str, + const char *end_str, char end_c, + digest_algorithm_t alg) +{ + const char *start=NULL, *end=NULL; + if (router_get_hash_impl_helper(s,s_len,start_str,end_str,end_c,LOG_WARN, + &start,&end)<0) + return -1; + + return router_compute_hash_final(digest, start, end-start, alg); +} + +/** Compute the digest of the <b>len</b>-byte directory object at + * <b>start</b>, using <b>alg</b>. Store the result in <b>digest</b>, which + * must be long enough to hold it. */ +MOCK_IMPL(STATIC int, +router_compute_hash_final,(char *digest, + const char *start, size_t len, + digest_algorithm_t alg)) +{ + if (alg == DIGEST_SHA1) { + if (crypto_digest(digest, start, len) < 0) { + log_warn(LD_BUG,"couldn't compute digest"); + return -1; + } + } else { + if (crypto_digest256(digest, start, len, alg) < 0) { + log_warn(LD_BUG,"couldn't compute digest"); + return -1; + } + } + + return 0; +} + +/** As router_get_hash_impl, but compute all hashes. */ +int +router_get_hashes_impl(const char *s, size_t s_len, common_digests_t *digests, + const char *start_str, + const char *end_str, char end_c) +{ + const char *start=NULL, *end=NULL; + if (router_get_hash_impl_helper(s,s_len,start_str,end_str,end_c,LOG_WARN, + &start,&end)<0) + return -1; + + if (crypto_common_digests(digests, start, end-start)) { + log_warn(LD_BUG,"couldn't compute digests"); + return -1; + } + + return 0; +} + +MOCK_IMPL(STATIC int, +signed_digest_equals, (const uint8_t *d1, const uint8_t *d2, size_t len)) +{ + return tor_memeq(d1, d2, len); +} + +/** Check whether the object body of the token in <b>tok</b> has a good + * signature for <b>digest</b> using key <b>pkey</b>. + * If <b>CST_NO_CHECK_OBJTYPE</b> is set, do not check + * the object type of the signature object. Use <b>doctype</b> as the type of + * the document when generating log messages. Return 0 on success, negative + * on failure. + */ +int +check_signature_token(const char *digest, + ssize_t digest_len, + directory_token_t *tok, + crypto_pk_t *pkey, + int flags, + const char *doctype) +{ + char *signed_digest; + size_t keysize; + const int check_objtype = ! (flags & CST_NO_CHECK_OBJTYPE); + + tor_assert(pkey); + tor_assert(tok); + tor_assert(digest); + tor_assert(doctype); + + if (check_objtype) { + if (strcmp(tok->object_type, "SIGNATURE")) { + log_warn(LD_DIR, "Bad object type on %s signature", doctype); + return -1; + } + } + + keysize = crypto_pk_keysize(pkey); + signed_digest = tor_malloc(keysize); + if (crypto_pk_public_checksig(pkey, signed_digest, keysize, + tok->object_body, tok->object_size) + < digest_len) { + log_warn(LD_DIR, "Error reading %s: invalid signature.", doctype); + tor_free(signed_digest); + return -1; + } + // log_debug(LD_DIR,"Signed %s hash starts %s", doctype, + // hex_str(signed_digest,4)); + if (! signed_digest_equals((const uint8_t *)digest, + (const uint8_t *)signed_digest, digest_len)) { + log_warn(LD_DIR, "Error reading %s: signature does not match.", doctype); + tor_free(signed_digest); + return -1; + } + tor_free(signed_digest); + return 0; +} diff --git a/src/feature/dirparse/sigcommon.h b/src/feature/dirparse/sigcommon.h new file mode 100644 index 0000000000..5f25817cdb --- /dev/null +++ b/src/feature/dirparse/sigcommon.h @@ -0,0 +1,48 @@ +/* Copyright (c) 2001 Matej Pfajfar. + * Copyright (c) 2001-2004, Roger Dingledine. + * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson. + * Copyright (c) 2007-2018, The Tor Project, Inc. */ +/* See LICENSE for licensing information */ + +/** + * \file sigcommon.h + * \brief Header file for sigcommon.c. + **/ + +#ifndef TOR_SIGCOMMON_H +#define TOR_SIGCOMMON_H + +/* TODO: Rename all of these functions */ +int router_get_hash_impl(const char *s, size_t s_len, char *digest, + const char *start_str, const char *end_str, + char end_char, + digest_algorithm_t alg); + +#define CST_NO_CHECK_OBJTYPE (1<<0) +struct directory_token_t; +int check_signature_token(const char *digest, + ssize_t digest_len, + struct directory_token_t *tok, + crypto_pk_t *pkey, + int flags, + const char *doctype); + +int router_get_hash_impl_helper(const char *s, size_t s_len, + const char *start_str, + const char *end_str, char end_c, + int log_severity, + const char **start_out, const char **end_out); +int router_get_hashes_impl(const char *s, size_t s_len, + common_digests_t *digests, + const char *start_str, const char *end_str, + char end_char); + +#ifdef SIGCOMMON_PRIVATE +MOCK_DECL(STATIC int, signed_digest_equals, + (const uint8_t *d1, const uint8_t *d2, size_t len)); +MOCK_DECL(STATIC int, router_compute_hash_final,(char *digest, + const char *start, size_t len, + digest_algorithm_t alg)); +#endif + +#endif /* !defined(TOR_SIGCOMMON_H) */ diff --git a/src/feature/dirparse/signing.c b/src/feature/dirparse/signing.c new file mode 100644 index 0000000000..8d6a40605b --- /dev/null +++ b/src/feature/dirparse/signing.c @@ -0,0 +1,98 @@ +/* Copyright (c) 2001 Matej Pfajfar. + * Copyright (c) 2001-2004, Roger Dingledine. + * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson. + * Copyright (c) 2007-2018, The Tor Project, Inc. */ +/* See LICENSE for licensing information */ + +/** + * \file signing.c + * \brief Code to sign directory objects. + **/ + +#include "core/or/or.h" +#include "feature/dirparse/signing.h" + +/** Helper: used to generate signatures for routers, directories and + * network-status objects. Given a <b>digest_len</b>-byte digest in + * <b>digest</b> and a secret <b>private_key</b>, generate an PKCS1-padded + * signature, BASE64-encode it, surround it with -----BEGIN/END----- pairs, + * and return the new signature on success or NULL on failure. + */ +char * +router_get_dirobj_signature(const char *digest, + size_t digest_len, + const crypto_pk_t *private_key) +{ + char *signature; + size_t i, keysize; + int siglen; + char *buf = NULL; + size_t buf_len; + /* overestimate of BEGIN/END lines total len. */ +#define BEGIN_END_OVERHEAD_LEN 64 + + keysize = crypto_pk_keysize(private_key); + signature = tor_malloc(keysize); + siglen = crypto_pk_private_sign(private_key, signature, keysize, + digest, digest_len); + if (siglen < 0) { + log_warn(LD_BUG,"Couldn't sign digest."); + goto err; + } + + /* The *2 here is a ridiculous overestimate of base-64 overhead. */ + buf_len = (siglen * 2) + BEGIN_END_OVERHEAD_LEN; + buf = tor_malloc(buf_len); + + if (strlcpy(buf, "-----BEGIN SIGNATURE-----\n", buf_len) >= buf_len) + goto truncated; + + i = strlen(buf); + if (base64_encode(buf+i, buf_len-i, signature, siglen, + BASE64_ENCODE_MULTILINE) < 0) { + log_warn(LD_BUG,"couldn't base64-encode signature"); + goto err; + } + + if (strlcat(buf, "-----END SIGNATURE-----\n", buf_len) >= buf_len) + goto truncated; + + tor_free(signature); + return buf; + + truncated: + log_warn(LD_BUG,"tried to exceed string length."); + err: + tor_free(signature); + tor_free(buf); + return NULL; +} + +/** Helper: used to generate signatures for routers, directories and + * network-status objects. Given a digest in <b>digest</b> and a secret + * <b>private_key</b>, generate a PKCS1-padded signature, BASE64-encode it, + * surround it with -----BEGIN/END----- pairs, and write it to the + * <b>buf_len</b>-byte buffer at <b>buf</b>. Return 0 on success, -1 on + * failure. + */ +int +router_append_dirobj_signature(char *buf, size_t buf_len, const char *digest, + size_t digest_len, crypto_pk_t *private_key) +{ + size_t sig_len, s_len; + char *sig = router_get_dirobj_signature(digest, digest_len, private_key); + if (!sig) { + log_warn(LD_BUG, "No signature generated"); + return -1; + } + sig_len = strlen(sig); + s_len = strlen(buf); + if (sig_len + s_len + 1 > buf_len) { + log_warn(LD_BUG, "Not enough room for signature"); + tor_free(sig); + return -1; + } + memcpy(buf+s_len, sig, sig_len+1); + tor_free(sig); + return 0; +} diff --git a/src/feature/dirparse/signing.h b/src/feature/dirparse/signing.h new file mode 100644 index 0000000000..2b547a185f --- /dev/null +++ b/src/feature/dirparse/signing.h @@ -0,0 +1,23 @@ +/* Copyright (c) 2001 Matej Pfajfar. + * Copyright (c) 2001-2004, Roger Dingledine. + * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson. + * Copyright (c) 2007-2018, The Tor Project, Inc. */ +/* See LICENSE for licensing information */ + +/** + * \file signing.h + * \brief Header file for signing.c. + **/ + +#ifndef TOR_SIGNING_H +#define TOR_SIGNING_H + +#define DIROBJ_MAX_SIG_LEN 256 +char *router_get_dirobj_signature(const char *digest, + size_t digest_len, + const crypto_pk_t *private_key); +int router_append_dirobj_signature(char *buf, size_t buf_len, + const char *digest, + size_t digest_len, + crypto_pk_t *private_key); +#endif diff --git a/src/feature/dirparse/unparseable.c b/src/feature/dirparse/unparseable.c new file mode 100644 index 0000000000..80e38d0703 --- /dev/null +++ b/src/feature/dirparse/unparseable.c @@ -0,0 +1,591 @@ +/* Copyright (c) 2001 Matej Pfajfar. + * Copyright (c) 2001-2004, Roger Dingledine. + * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson. + * Copyright (c) 2007-2018, The Tor Project, Inc. */ +/* See LICENSE for licensing information */ + +#define UNPARSEABLE_PRIVATE + +#include "core/or/or.h" +#include "app/config/config.h" +#include "feature/dirparse/unparseable.h" +#include "lib/sandbox/sandbox.h" + +#ifdef HAVE_SYS_STAT_H +#include <sys/stat.h> +#endif + +/* Dump mechanism for unparseable descriptors */ + +/** List of dumped descriptors for FIFO cleanup purposes */ +STATIC smartlist_t *descs_dumped = NULL; +/** Total size of dumped descriptors for FIFO cleanup */ +STATIC uint64_t len_descs_dumped = 0; +/** Directory to stash dumps in */ +static int have_dump_desc_dir = 0; +static int problem_with_dump_desc_dir = 0; + +#define DESC_DUMP_DATADIR_SUBDIR "unparseable-descs" +#define DESC_DUMP_BASE_FILENAME "unparseable-desc" + +/** Find the dump directory and check if we'll be able to create it */ +void +dump_desc_init(void) +{ + char *dump_desc_dir; + + dump_desc_dir = get_datadir_fname(DESC_DUMP_DATADIR_SUBDIR); + + /* + * We just check for it, don't create it at this point; we'll + * create it when we need it if it isn't already there. + */ + if (check_private_dir(dump_desc_dir, CPD_CHECK, get_options()->User) < 0) { + /* Error, log and flag it as having a problem */ + log_notice(LD_DIR, + "Doesn't look like we'll be able to create descriptor dump " + "directory %s; dumps will be disabled.", + dump_desc_dir); + problem_with_dump_desc_dir = 1; + tor_free(dump_desc_dir); + return; + } + + /* Check if it exists */ + switch (file_status(dump_desc_dir)) { + case FN_DIR: + /* We already have a directory */ + have_dump_desc_dir = 1; + break; + case FN_NOENT: + /* Nothing, we'll need to create it later */ + have_dump_desc_dir = 0; + break; + case FN_ERROR: + /* Log and flag having a problem */ + log_notice(LD_DIR, + "Couldn't check whether descriptor dump directory %s already" + " exists: %s", + dump_desc_dir, strerror(errno)); + problem_with_dump_desc_dir = 1; + break; + case FN_FILE: + case FN_EMPTY: + default: + /* Something else was here! */ + log_notice(LD_DIR, + "Descriptor dump directory %s already exists and isn't a " + "directory", + dump_desc_dir); + problem_with_dump_desc_dir = 1; + } + + if (have_dump_desc_dir && !problem_with_dump_desc_dir) { + dump_desc_populate_fifo_from_directory(dump_desc_dir); + } + + tor_free(dump_desc_dir); +} + +/** Create the dump directory if needed and possible */ +static void +dump_desc_create_dir(void) +{ + char *dump_desc_dir; + + /* If the problem flag is set, skip it */ + if (problem_with_dump_desc_dir) return; + + /* Do we need it? */ + if (!have_dump_desc_dir) { + dump_desc_dir = get_datadir_fname(DESC_DUMP_DATADIR_SUBDIR); + + if (check_private_dir(dump_desc_dir, CPD_CREATE, + get_options()->User) < 0) { + log_notice(LD_DIR, + "Failed to create descriptor dump directory %s", + dump_desc_dir); + problem_with_dump_desc_dir = 1; + } + + /* Okay, we created it */ + have_dump_desc_dir = 1; + + tor_free(dump_desc_dir); + } +} + +/** Dump desc FIFO/cleanup; take ownership of the given filename, add it to + * the FIFO, and clean up the oldest entries to the extent they exceed the + * configured cap. If any old entries with a matching hash existed, they + * just got overwritten right before this was called and we should adjust + * the total size counter without deleting them. + */ +static void +dump_desc_fifo_add_and_clean(char *filename, const uint8_t *digest_sha256, + size_t len) +{ + dumped_desc_t *ent = NULL, *tmp; + uint64_t max_len; + + tor_assert(filename != NULL); + tor_assert(digest_sha256 != NULL); + + if (descs_dumped == NULL) { + /* We better have no length, then */ + tor_assert(len_descs_dumped == 0); + /* Make a smartlist */ + descs_dumped = smartlist_new(); + } + + /* Make a new entry to put this one in */ + ent = tor_malloc_zero(sizeof(*ent)); + ent->filename = filename; + ent->len = len; + ent->when = time(NULL); + memcpy(ent->digest_sha256, digest_sha256, DIGEST256_LEN); + + /* Do we need to do some cleanup? */ + max_len = get_options()->MaxUnparseableDescSizeToLog; + /* Iterate over the list until we've freed enough space */ + while (len > max_len - len_descs_dumped && + smartlist_len(descs_dumped) > 0) { + /* Get the oldest thing on the list */ + tmp = (dumped_desc_t *)(smartlist_get(descs_dumped, 0)); + + /* + * Check if it matches the filename we just added, so we don't delete + * something we just emitted if we get repeated identical descriptors. + */ + if (strcmp(tmp->filename, filename) != 0) { + /* Delete it and adjust the length counter */ + tor_unlink(tmp->filename); + tor_assert(len_descs_dumped >= tmp->len); + len_descs_dumped -= tmp->len; + log_info(LD_DIR, + "Deleting old unparseable descriptor dump %s due to " + "space limits", + tmp->filename); + } else { + /* + * Don't delete, but do adjust the counter since we will bump it + * later + */ + tor_assert(len_descs_dumped >= tmp->len); + len_descs_dumped -= tmp->len; + log_info(LD_DIR, + "Replacing old descriptor dump %s with new identical one", + tmp->filename); + } + + /* Free it and remove it from the list */ + smartlist_del_keeporder(descs_dumped, 0); + tor_free(tmp->filename); + tor_free(tmp); + } + + /* Append our entry to the end of the list and bump the counter */ + smartlist_add(descs_dumped, ent); + len_descs_dumped += len; +} + +/** Check if we already have a descriptor for this hash and move it to the + * head of the queue if so. Return 1 if one existed and 0 otherwise. + */ +static int +dump_desc_fifo_bump_hash(const uint8_t *digest_sha256) +{ + dumped_desc_t *match = NULL; + + tor_assert(digest_sha256); + + if (descs_dumped) { + /* Find a match if one exists */ + SMARTLIST_FOREACH_BEGIN(descs_dumped, dumped_desc_t *, ent) { + if (ent && + tor_memeq(ent->digest_sha256, digest_sha256, DIGEST256_LEN)) { + /* + * Save a pointer to the match and remove it from its current + * position. + */ + match = ent; + SMARTLIST_DEL_CURRENT_KEEPORDER(descs_dumped, ent); + break; + } + } SMARTLIST_FOREACH_END(ent); + + if (match) { + /* Update the timestamp */ + match->when = time(NULL); + /* Add it back at the end of the list */ + smartlist_add(descs_dumped, match); + + /* Indicate we found one */ + return 1; + } + } + + return 0; +} + +/** Clean up on exit; just memory, leave the dumps behind + */ +void +dump_desc_fifo_cleanup(void) +{ + if (descs_dumped) { + /* Free each descriptor */ + SMARTLIST_FOREACH_BEGIN(descs_dumped, dumped_desc_t *, ent) { + tor_assert(ent); + tor_free(ent->filename); + tor_free(ent); + } SMARTLIST_FOREACH_END(ent); + /* Free the list */ + smartlist_free(descs_dumped); + descs_dumped = NULL; + len_descs_dumped = 0; + } +} + +/** Handle one file for dump_desc_populate_fifo_from_directory(); make sure + * the filename is sensibly formed and matches the file content, and either + * return a dumped_desc_t for it or remove the file and return NULL. + */ +MOCK_IMPL(STATIC dumped_desc_t *, +dump_desc_populate_one_file, (const char *dirname, const char *f)) +{ + dumped_desc_t *ent = NULL; + char *path = NULL, *desc = NULL; + const char *digest_str; + char digest[DIGEST256_LEN], content_digest[DIGEST256_LEN]; + /* Expected prefix before digest in filenames */ + const char *f_pfx = DESC_DUMP_BASE_FILENAME "."; + /* + * Stat while reading; this is important in case the file + * contains a NUL character. + */ + struct stat st; + + /* Sanity-check args */ + tor_assert(dirname != NULL); + tor_assert(f != NULL); + + /* Form the full path */ + tor_asprintf(&path, "%s" PATH_SEPARATOR "%s", dirname, f); + + /* Check that f has the form DESC_DUMP_BASE_FILENAME.<digest256> */ + + if (!strcmpstart(f, f_pfx)) { + /* It matches the form, but is the digest parseable as such? */ + digest_str = f + strlen(f_pfx); + if (base16_decode(digest, DIGEST256_LEN, + digest_str, strlen(digest_str)) != DIGEST256_LEN) { + /* We failed to decode it */ + digest_str = NULL; + } + } else { + /* No match */ + digest_str = NULL; + } + + if (!digest_str) { + /* We couldn't get a sensible digest */ + log_notice(LD_DIR, + "Removing unrecognized filename %s from unparseable " + "descriptors directory", f); + tor_unlink(path); + /* We're done */ + goto done; + } + + /* + * The filename has the form DESC_DUMP_BASE_FILENAME "." <digest256> and + * we've decoded the digest. Next, check that we can read it and the + * content matches this digest. We are relying on the fact that if the + * file contains a '\0', read_file_to_str() will allocate space for and + * read the entire file and return the correct size in st. + */ + desc = read_file_to_str(path, RFTS_IGNORE_MISSING|RFTS_BIN, &st); + if (!desc) { + /* We couldn't read it */ + log_notice(LD_DIR, + "Failed to read %s from unparseable descriptors directory; " + "attempting to remove it.", f); + tor_unlink(path); + /* We're done */ + goto done; + } + +#if SIZE_MAX > UINT64_MAX + if (BUG((uint64_t)st.st_size > (uint64_t)SIZE_MAX)) { + /* LCOV_EXCL_START + * Should be impossible since RFTS above should have failed to read the + * huge file into RAM. */ + goto done; + /* LCOV_EXCL_STOP */ + } +#endif /* SIZE_MAX > UINT64_MAX */ + if (BUG(st.st_size < 0)) { + /* LCOV_EXCL_START + * Should be impossible, since the OS isn't supposed to be b0rken. */ + goto done; + /* LCOV_EXCL_STOP */ + } + /* (Now we can be sure that st.st_size is safe to cast to a size_t.) */ + + /* + * We got one; now compute its digest and check that it matches the + * filename. + */ + if (crypto_digest256((char *)content_digest, desc, (size_t) st.st_size, + DIGEST_SHA256) < 0) { + /* Weird, but okay */ + log_info(LD_DIR, + "Unable to hash content of %s from unparseable descriptors " + "directory", f); + tor_unlink(path); + /* We're done */ + goto done; + } + + /* Compare the digests */ + if (tor_memneq(digest, content_digest, DIGEST256_LEN)) { + /* No match */ + log_info(LD_DIR, + "Hash of %s from unparseable descriptors directory didn't " + "match its filename; removing it", f); + tor_unlink(path); + /* We're done */ + goto done; + } + + /* Okay, it's a match, we should prepare ent */ + ent = tor_malloc_zero(sizeof(dumped_desc_t)); + ent->filename = path; + memcpy(ent->digest_sha256, digest, DIGEST256_LEN); + ent->len = (size_t) st.st_size; + ent->when = st.st_mtime; + /* Null out path so we don't free it out from under ent */ + path = NULL; + + done: + /* Free allocations if we had them */ + tor_free(desc); + tor_free(path); + + return ent; +} + +/** Sort helper for dump_desc_populate_fifo_from_directory(); compares + * the when field of dumped_desc_ts in a smartlist to put the FIFO in + * the correct order after reconstructing it from the directory. + */ +static int +dump_desc_compare_fifo_entries(const void **a_v, const void **b_v) +{ + const dumped_desc_t **a = (const dumped_desc_t **)a_v; + const dumped_desc_t **b = (const dumped_desc_t **)b_v; + + if ((a != NULL) && (*a != NULL)) { + if ((b != NULL) && (*b != NULL)) { + /* We have sensible dumped_desc_ts to compare */ + if ((*a)->when < (*b)->when) { + return -1; + } else if ((*a)->when == (*b)->when) { + return 0; + } else { + return 1; + } + } else { + /* + * We shouldn't see this, but what the hell, NULLs precede everythin + * else + */ + return 1; + } + } else { + return -1; + } +} + +/** Scan the contents of the directory, and update FIFO/counters; this will + * consistency-check descriptor dump filenames against hashes of descriptor + * dump file content, and remove any inconsistent/unreadable dumps, and then + * reconstruct the dump FIFO as closely as possible for the last time the + * tor process shut down. If a previous dump was repeated more than once and + * moved ahead in the FIFO, the mtime will not have been updated and the + * reconstructed order will be wrong, but will always be a permutation of + * the original. + */ +STATIC void +dump_desc_populate_fifo_from_directory(const char *dirname) +{ + smartlist_t *files = NULL; + dumped_desc_t *ent = NULL; + + tor_assert(dirname != NULL); + + /* Get a list of files */ + files = tor_listdir(dirname); + if (!files) { + log_notice(LD_DIR, + "Unable to get contents of unparseable descriptor dump " + "directory %s", + dirname); + return; + } + + /* + * Iterate through the list and decide which files should go in the + * FIFO and which should be purged. + */ + + SMARTLIST_FOREACH_BEGIN(files, char *, f) { + /* Try to get a FIFO entry */ + ent = dump_desc_populate_one_file(dirname, f); + if (ent) { + /* + * We got one; add it to the FIFO. No need for duplicate checking + * here since we just verified the name and digest match. + */ + + /* Make sure we have a list to add it to */ + if (!descs_dumped) { + descs_dumped = smartlist_new(); + len_descs_dumped = 0; + } + + /* Add it and adjust the counter */ + smartlist_add(descs_dumped, ent); + len_descs_dumped += ent->len; + } + /* + * If we didn't, we will have unlinked the file if necessary and + * possible, and emitted a log message about it, so just go on to + * the next. + */ + } SMARTLIST_FOREACH_END(f); + + /* Did we get anything? */ + if (descs_dumped != NULL) { + /* Sort the FIFO in order of increasing timestamp */ + smartlist_sort(descs_dumped, dump_desc_compare_fifo_entries); + + /* Log some stats */ + log_info(LD_DIR, + "Reloaded unparseable descriptor dump FIFO with %d dump(s) " + "totaling %"PRIu64 " bytes", + smartlist_len(descs_dumped), (len_descs_dumped)); + } + + /* Free the original list */ + SMARTLIST_FOREACH(files, char *, f, tor_free(f)); + smartlist_free(files); +} + +/** For debugging purposes, dump unparseable descriptor *<b>desc</b> of + * type *<b>type</b> to file $DATADIR/unparseable-desc. Do not write more + * than one descriptor to disk per minute. If there is already such a + * file in the data directory, overwrite it. */ +MOCK_IMPL(void, +dump_desc,(const char *desc, const char *type)) +{ + tor_assert(desc); + tor_assert(type); + size_t len; + /* The SHA256 of the string */ + uint8_t digest_sha256[DIGEST256_LEN]; + char digest_sha256_hex[HEX_DIGEST256_LEN+1]; + /* Filename to log it to */ + char *debugfile, *debugfile_base; + + /* Get the hash for logging purposes anyway */ + len = strlen(desc); + if (crypto_digest256((char *)digest_sha256, desc, len, + DIGEST_SHA256) < 0) { + log_info(LD_DIR, + "Unable to parse descriptor of type %s, and unable to even hash" + " it!", type); + goto err; + } + + base16_encode(digest_sha256_hex, sizeof(digest_sha256_hex), + (const char *)digest_sha256, sizeof(digest_sha256)); + + /* + * We mention type and hash in the main log; don't clutter up the files + * with anything but the exact dump. + */ + tor_asprintf(&debugfile_base, + DESC_DUMP_BASE_FILENAME ".%s", digest_sha256_hex); + debugfile = get_datadir_fname2(DESC_DUMP_DATADIR_SUBDIR, debugfile_base); + + /* + * Check if the sandbox is active or will become active; see comment + * below at the log message for why. + */ + if (!(sandbox_is_active() || get_options()->Sandbox)) { + if (len <= get_options()->MaxUnparseableDescSizeToLog) { + if (!dump_desc_fifo_bump_hash(digest_sha256)) { + /* Create the directory if needed */ + dump_desc_create_dir(); + /* Make sure we've got it */ + if (have_dump_desc_dir && !problem_with_dump_desc_dir) { + /* Write it, and tell the main log about it */ + write_str_to_file(debugfile, desc, 1); + log_info(LD_DIR, + "Unable to parse descriptor of type %s with hash %s and " + "length %lu. See file %s in data directory for details.", + type, digest_sha256_hex, (unsigned long)len, + debugfile_base); + dump_desc_fifo_add_and_clean(debugfile, digest_sha256, len); + /* Since we handed ownership over, don't free debugfile later */ + debugfile = NULL; + } else { + /* Problem with the subdirectory */ + log_info(LD_DIR, + "Unable to parse descriptor of type %s with hash %s and " + "length %lu. Descriptor not dumped because we had a " + "problem creating the " DESC_DUMP_DATADIR_SUBDIR + " subdirectory", + type, digest_sha256_hex, (unsigned long)len); + /* We do have to free debugfile in this case */ + } + } else { + /* We already had one with this hash dumped */ + log_info(LD_DIR, + "Unable to parse descriptor of type %s with hash %s and " + "length %lu. Descriptor not dumped because one with that " + "hash has already been dumped.", + type, digest_sha256_hex, (unsigned long)len); + /* We do have to free debugfile in this case */ + } + } else { + /* Just log that it happened without dumping */ + log_info(LD_DIR, + "Unable to parse descriptor of type %s with hash %s and " + "length %lu. Descriptor not dumped because it exceeds maximum" + " log size all by itself.", + type, digest_sha256_hex, (unsigned long)len); + /* We do have to free debugfile in this case */ + } + } else { + /* + * Not logging because the sandbox is active and seccomp2 apparently + * doesn't have a sensible way to allow filenames according to a pattern + * match. (If we ever figure out how to say "allow writes to /regex/", + * remove this checK). + */ + log_info(LD_DIR, + "Unable to parse descriptor of type %s with hash %s and " + "length %lu. Descriptor not dumped because the sandbox is " + "configured", + type, digest_sha256_hex, (unsigned long)len); + } + + tor_free(debugfile_base); + tor_free(debugfile); + + err: + return; +} diff --git a/src/feature/dirparse/unparseable.h b/src/feature/dirparse/unparseable.h new file mode 100644 index 0000000000..2e48c6a9a0 --- /dev/null +++ b/src/feature/dirparse/unparseable.h @@ -0,0 +1,56 @@ +/* Copyright (c) 2001 Matej Pfajfar. + * Copyright (c) 2001-2004, Roger Dingledine. + * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson. + * Copyright (c) 2007-2018, The Tor Project, Inc. */ +/* See LICENSE for licensing information */ + +/** + * \file unparseable.h + * \brief Header file for unparseable.c. + **/ + +#ifndef TOR_UNPARSEABLE_H +#define TOR_UNPARSEABLE_H + +#include "lib/cc/torint.h" + +MOCK_DECL(void,dump_desc,(const char *desc, const char *type)); +void dump_desc_fifo_cleanup(void); +void dump_desc_init(void); + +#undef DEBUG_AREA_ALLOC +#ifdef DEBUG_AREA_ALLOC +#define DUMP_AREA(a,name) STMT_BEGIN \ + size_t alloc=0, used=0; \ + memarea_get_stats((a),&alloc,&used); \ + log_debug(LD_MM, "Area for %s has %lu allocated; using %lu.", \ + name, (unsigned long)alloc, (unsigned long)used); \ + STMT_END +#else /* !(defined(DEBUG_AREA_ALLOC)) */ +#define DUMP_AREA(a,name) STMT_NIL +#endif /* defined(DEBUG_AREA_ALLOC) */ + +#ifdef UNPARSEABLE_PRIVATE + +/* + * One entry in the list of dumped descriptors; filename dumped to, length, + * SHA-256 and timestamp. + */ + +typedef struct { + char *filename; + size_t len; + uint8_t digest_sha256[DIGEST256_LEN]; + time_t when; +} dumped_desc_t; +struct smartlist_t; + +EXTERN(uint64_t, len_descs_dumped) +EXTERN(struct smartlist_t *, descs_dumped) + +MOCK_DECL(STATIC dumped_desc_t *, dump_desc_populate_one_file, + (const char *dirname, const char *f)); +STATIC void dump_desc_populate_fifo_from_directory(const char *dirname); +#endif + +#endif /* !defined(TOR_UNPARSEABLE_H) */ diff --git a/src/feature/hs/hs_descriptor.c b/src/feature/hs/hs_descriptor.c index b9a0c0ef1f..8515314b38 100644 --- a/src/feature/hs/hs_descriptor.c +++ b/src/feature/hs/hs_descriptor.c @@ -61,7 +61,7 @@ #include "core/or/circuitbuild.h" #include "lib/crypt_ops/crypto_rand.h" #include "lib/crypt_ops/crypto_util.h" -#include "feature/nodelist/parsecommon.h" +#include "feature/dirparse/parsecommon.h" #include "feature/rend/rendcache.h" #include "feature/hs/hs_cache.h" #include "feature/hs/hs_config.h" diff --git a/src/feature/nodelist/authcert.c b/src/feature/nodelist/authcert.c index 2624ed5eef..b111422d0d 100644 --- a/src/feature/nodelist/authcert.c +++ b/src/feature/nodelist/authcert.c @@ -24,17 +24,17 @@ #include "core/or/policies.h" #include "feature/client/bridges.h" #include "feature/dirauth/authmode.h" -#include "feature/dircommon/directory.h" #include "feature/dirclient/dirclient.h" #include "feature/dirclient/dlstatus.h" +#include "feature/dircommon/directory.h" #include "feature/dircommon/fp_pair.h" +#include "feature/dirparse/authcert_parse.h" #include "feature/nodelist/authcert.h" #include "feature/nodelist/dirlist.h" #include "feature/nodelist/networkstatus.h" #include "feature/nodelist/node_select.h" #include "feature/nodelist/nodelist.h" #include "feature/nodelist/routerlist.h" -#include "feature/nodelist/routerparse.h" #include "feature/relay/routermode.h" #include "core/or/connection_st.h" diff --git a/src/feature/nodelist/microdesc.c b/src/feature/nodelist/microdesc.c index 96696b603a..146c772daf 100644 --- a/src/feature/nodelist/microdesc.c +++ b/src/feature/nodelist/microdesc.c @@ -12,20 +12,20 @@ #include "lib/fdio/fdio.h" -#include "core/or/circuitbuild.h" #include "app/config/config.h" -#include "feature/dircommon/directory.h" +#include "core/or/circuitbuild.h" +#include "core/or/policies.h" +#include "feature/client/entrynodes.h" #include "feature/dircache/dirserv.h" #include "feature/dirclient/dlstatus.h" -#include "feature/client/entrynodes.h" +#include "feature/dircommon/directory.h" +#include "feature/dirparse/microdesc_parse.h" +#include "feature/nodelist/dirlist.h" #include "feature/nodelist/microdesc.h" #include "feature/nodelist/networkstatus.h" #include "feature/nodelist/nodelist.h" -#include "core/or/policies.h" -#include "feature/relay/router.h" -#include "feature/nodelist/dirlist.h" #include "feature/nodelist/routerlist.h" -#include "feature/nodelist/routerparse.h" +#include "feature/relay/router.h" #include "feature/nodelist/microdesc_st.h" #include "feature/nodelist/networkstatus_st.h" diff --git a/src/feature/nodelist/networkstatus.c b/src/feature/nodelist/networkstatus.c index 67b5a1d046..de2451b79c 100644 --- a/src/feature/nodelist/networkstatus.c +++ b/src/feature/nodelist/networkstatus.c @@ -53,6 +53,7 @@ #include "core/or/protover.h" #include "core/or/relay.h" #include "core/or/scheduler.h" +#include "core/or/versions.h" #include "feature/client/bridges.h" #include "feature/client/entrynodes.h" #include "feature/client/transports.h" @@ -64,6 +65,7 @@ #include "feature/dirclient/dlstatus.h" #include "feature/dircommon/directory.h" #include "feature/dircommon/voting_schedule.h" +#include "feature/dirparse/ns_parse.h" #include "feature/hibernate/hibernate.h" #include "feature/nodelist/authcert.h" #include "feature/nodelist/dirlist.h" @@ -74,7 +76,6 @@ #include "feature/nodelist/nodelist.h" #include "feature/nodelist/routerinfo.h" #include "feature/nodelist/routerlist.h" -#include "feature/nodelist/routerparse.h" #include "feature/nodelist/torcert.h" #include "feature/relay/routermode.h" #include "lib/crypt_ops/crypto_rand.h" @@ -2705,25 +2706,6 @@ networkstatus_check_required_protocols(const networkstatus_t *ns, return 0; } -/** Release all storage held in <b>s</b>. */ -void -ns_detached_signatures_free_(ns_detached_signatures_t *s) -{ - if (!s) - return; - if (s->signatures) { - STRMAP_FOREACH(s->signatures, flavor, smartlist_t *, sigs) { - SMARTLIST_FOREACH(sigs, document_signature_t *, sig, - document_signature_free(sig)); - smartlist_free(sigs); - } STRMAP_FOREACH_END; - strmap_free(s->signatures, NULL); - strmap_free(s->digests, tor_free_); - } - - tor_free(s); -} - /** Free all storage held locally in this module. */ void networkstatus_free_all(void) diff --git a/src/feature/nodelist/networkstatus.h b/src/feature/nodelist/networkstatus.h index cc6badf0b2..6f8b2dc964 100644 --- a/src/feature/nodelist/networkstatus.h +++ b/src/feature/nodelist/networkstatus.h @@ -24,9 +24,6 @@ void routerstatus_free_(routerstatus_t *rs); void networkstatus_vote_free_(networkstatus_t *ns); #define networkstatus_vote_free(ns) \ FREE_AND_NULL(networkstatus_t, networkstatus_vote_free_, (ns)) -void ns_detached_signatures_free_(ns_detached_signatures_t *s); -#define ns_detached_signatures_free(s) \ - FREE_AND_NULL(ns_detached_signatures_t, ns_detached_signatures_free_, (s)) networkstatus_voter_info_t *networkstatus_get_voter_by_id( networkstatus_t *vote, const char *identity); diff --git a/src/feature/nodelist/nodelist.c b/src/feature/nodelist/nodelist.c index 90ca579b7d..600dfcf56c 100644 --- a/src/feature/nodelist/nodelist.c +++ b/src/feature/nodelist/nodelist.c @@ -61,7 +61,6 @@ #include "feature/nodelist/node_select.h" #include "feature/nodelist/nodelist.h" #include "feature/nodelist/routerlist.h" -#include "feature/nodelist/routerparse.h" #include "feature/nodelist/routerset.h" #include "feature/nodelist/torcert.h" #include "feature/rend/rendservice.h" diff --git a/src/feature/nodelist/routerlist.c b/src/feature/nodelist/routerlist.c index 20956d8cca..a8c9003e68 100644 --- a/src/feature/nodelist/routerlist.c +++ b/src/feature/nodelist/routerlist.c @@ -84,7 +84,7 @@ #include "feature/nodelist/nodelist.h" #include "feature/nodelist/routerinfo.h" #include "feature/nodelist/routerlist.h" -#include "feature/nodelist/routerparse.h" +#include "feature/dirparse/routerparse.h" #include "feature/nodelist/routerset.h" #include "feature/nodelist/torcert.h" #include "feature/relay/routermode.h" diff --git a/src/feature/nodelist/routerparse.c b/src/feature/nodelist/routerparse.c deleted file mode 100644 index c12f411e87..0000000000 --- a/src/feature/nodelist/routerparse.c +++ /dev/null @@ -1,5701 +0,0 @@ -/* Copyright (c) 2001 Matej Pfajfar. - * Copyright (c) 2001-2004, Roger Dingledine. - * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson. - * Copyright (c) 2007-2018, The Tor Project, Inc. */ -/* See LICENSE for licensing information */ - -/** - * \file routerparse.c - * \brief Code to parse and validate router descriptors, consenus directories, - * and similar objects. - * - * The objects parsed by this module use a common text-based metaformat, - * documented in dir-spec.txt in torspec.git. This module is itself divided - * into two major kinds of function: code to handle the metaformat, and code - * to convert from particular instances of the metaformat into the - * objects that Tor uses. - * - * The generic parsing code works by calling a table-based tokenizer on the - * input string. Each token corresponds to a single line with a token, plus - * optional arguments on that line, plus an optional base-64 encoded object - * after that line. Each token has a definition in a table of token_rule_t - * entries that describes how many arguments it can take, whether it takes an - * object, how many times it may appear, whether it must appear first, and so - * on. - * - * The tokenizer function tokenize_string() converts its string input into a - * smartlist full of instances of directory_token_t, according to a provided - * table of token_rule_t. - * - * The generic parts of this module additionally include functions for - * finding the start and end of signed information inside a signed object, and - * computing the digest that will be signed. - * - * There are also functions for saving objects to disk that have caused - * parsing to fail. - * - * The specific parts of this module describe conversions between - * particular lists of directory_token_t and particular objects. The - * kinds of objects that can be parsed here are: - * <ul> - * <li>router descriptors (managed from routerlist.c) - * <li>extra-info documents (managed from routerlist.c) - * <li>microdescriptors (managed from microdesc.c) - * <li>vote and consensus networkstatus documents, and the routerstatus_t - * objects that they comprise (managed from networkstatus.c) - * <li>detached-signature objects used by authorities for gathering - * signatures on the networkstatus consensus (managed from dirvote.c) - * <li>authority key certificates (managed from routerlist.c) - * <li>hidden service descriptors (managed from rendcommon.c and rendcache.c) - * </ul> - * - * For no terribly good reason, the functions to <i>generate</i> signatures on - * the above directory objects are also in this module. - **/ - -#define ROUTERPARSE_PRIVATE - -#include "core/or/or.h" -#include "app/config/config.h" -#include "core/or/circuitstats.h" -#include "core/or/policies.h" -#include "core/or/protover.h" -#include "feature/client/entrynodes.h" -#include "feature/dirauth/shared_random.h" -#include "feature/dircommon/voting_schedule.h" -#include "feature/hs_common/shared_random_client.h" -#include "feature/nodelist/authcert.h" -#include "feature/nodelist/describe.h" -#include "feature/nodelist/microdesc.h" -#include "feature/nodelist/networkstatus.h" -#include "feature/nodelist/nickname.h" -#include "feature/nodelist/parsecommon.h" -#include "feature/nodelist/routerinfo.h" -#include "feature/nodelist/routerlist.h" -#include "feature/nodelist/routerparse.h" -#include "feature/nodelist/torcert.h" -#include "feature/relay/router.h" -#include "feature/relay/routerkeys.h" -#include "feature/rend/rendcommon.h" -#include "feature/stats/rephist.h" -#include "lib/crypt_ops/crypto_format.h" -#include "lib/crypt_ops/crypto_util.h" -#include "lib/memarea/memarea.h" -#include "lib/sandbox/sandbox.h" - -#include "feature/dirauth/dirvote.h" - -#include "core/or/addr_policy_st.h" -#include "feature/nodelist/authority_cert_st.h" -#include "feature/nodelist/document_signature_st.h" -#include "core/or/extend_info_st.h" -#include "feature/nodelist/extrainfo_st.h" -#include "feature/nodelist/microdesc_st.h" -#include "feature/nodelist/networkstatus_st.h" -#include "feature/nodelist/networkstatus_voter_info_st.h" -#include "feature/dirauth/ns_detached_signatures_st.h" -#include "feature/rend/rend_authorized_client_st.h" -#include "feature/rend/rend_intro_point_st.h" -#include "feature/rend/rend_service_descriptor_st.h" -#include "feature/nodelist/routerinfo_st.h" -#include "feature/nodelist/routerlist_st.h" -#include "core/or/tor_version_st.h" -#include "feature/dirauth/vote_microdesc_hash_st.h" -#include "feature/nodelist/vote_routerstatus_st.h" - -#include "lib/container/bloomfilt.h" - -#undef log -#include <math.h> -#ifdef HAVE_SYS_STAT_H -#include <sys/stat.h> -#endif - -/****************************************************************************/ - -/** List of tokens recognized in router descriptors */ -static token_rule_t routerdesc_token_table[] = { - T0N("reject", K_REJECT, ARGS, NO_OBJ ), - T0N("accept", K_ACCEPT, ARGS, NO_OBJ ), - T0N("reject6", K_REJECT6, ARGS, NO_OBJ ), - T0N("accept6", K_ACCEPT6, ARGS, NO_OBJ ), - T1_START( "router", K_ROUTER, GE(5), NO_OBJ ), - T01("ipv6-policy", K_IPV6_POLICY, CONCAT_ARGS, NO_OBJ), - T1( "signing-key", K_SIGNING_KEY, NO_ARGS, NEED_KEY_1024 ), - T1( "onion-key", K_ONION_KEY, NO_ARGS, NEED_KEY_1024 ), - T01("ntor-onion-key", K_ONION_KEY_NTOR, GE(1), NO_OBJ ), - T1_END( "router-signature", K_ROUTER_SIGNATURE, NO_ARGS, NEED_OBJ ), - T1( "published", K_PUBLISHED, CONCAT_ARGS, NO_OBJ ), - T01("uptime", K_UPTIME, GE(1), NO_OBJ ), - T01("fingerprint", K_FINGERPRINT, CONCAT_ARGS, NO_OBJ ), - T01("hibernating", K_HIBERNATING, GE(1), NO_OBJ ), - T01("platform", K_PLATFORM, CONCAT_ARGS, NO_OBJ ), - T01("proto", K_PROTO, CONCAT_ARGS, NO_OBJ ), - T01("contact", K_CONTACT, CONCAT_ARGS, NO_OBJ ), - T01("read-history", K_READ_HISTORY, ARGS, NO_OBJ ), - T01("write-history", K_WRITE_HISTORY, ARGS, NO_OBJ ), - T01("extra-info-digest", K_EXTRA_INFO_DIGEST, GE(1), NO_OBJ ), - T01("hidden-service-dir", K_HIDDEN_SERVICE_DIR, NO_ARGS, NO_OBJ ), - T01("identity-ed25519", K_IDENTITY_ED25519, NO_ARGS, NEED_OBJ ), - T01("master-key-ed25519", K_MASTER_KEY_ED25519, GE(1), NO_OBJ ), - T01("router-sig-ed25519", K_ROUTER_SIG_ED25519, GE(1), NO_OBJ ), - T01("onion-key-crosscert", K_ONION_KEY_CROSSCERT, NO_ARGS, NEED_OBJ ), - T01("ntor-onion-key-crosscert", K_NTOR_ONION_KEY_CROSSCERT, - EQ(1), NEED_OBJ ), - - T01("allow-single-hop-exits",K_ALLOW_SINGLE_HOP_EXITS, NO_ARGS, NO_OBJ ), - - T01("family", K_FAMILY, ARGS, NO_OBJ ), - T01("caches-extra-info", K_CACHES_EXTRA_INFO, NO_ARGS, NO_OBJ ), - T0N("or-address", K_OR_ADDRESS, GE(1), NO_OBJ ), - - T0N("opt", K_OPT, CONCAT_ARGS, OBJ_OK ), - T1( "bandwidth", K_BANDWIDTH, GE(3), NO_OBJ ), - A01("@purpose", A_PURPOSE, GE(1), NO_OBJ ), - T01("tunnelled-dir-server",K_DIR_TUNNELLED, NO_ARGS, NO_OBJ ), - - END_OF_TABLE -}; - -/** List of tokens recognized in extra-info documents. */ -static token_rule_t extrainfo_token_table[] = { - T1_END( "router-signature", K_ROUTER_SIGNATURE, NO_ARGS, NEED_OBJ ), - T1( "published", K_PUBLISHED, CONCAT_ARGS, NO_OBJ ), - T01("identity-ed25519", K_IDENTITY_ED25519, NO_ARGS, NEED_OBJ ), - T01("router-sig-ed25519", K_ROUTER_SIG_ED25519, GE(1), NO_OBJ ), - T0N("opt", K_OPT, CONCAT_ARGS, OBJ_OK ), - T01("read-history", K_READ_HISTORY, ARGS, NO_OBJ ), - T01("write-history", K_WRITE_HISTORY, ARGS, NO_OBJ ), - T01("dirreq-stats-end", K_DIRREQ_END, ARGS, NO_OBJ ), - T01("dirreq-v2-ips", K_DIRREQ_V2_IPS, ARGS, NO_OBJ ), - T01("dirreq-v3-ips", K_DIRREQ_V3_IPS, ARGS, NO_OBJ ), - T01("dirreq-v2-reqs", K_DIRREQ_V2_REQS, ARGS, NO_OBJ ), - T01("dirreq-v3-reqs", K_DIRREQ_V3_REQS, ARGS, NO_OBJ ), - T01("dirreq-v2-share", K_DIRREQ_V2_SHARE, ARGS, NO_OBJ ), - T01("dirreq-v3-share", K_DIRREQ_V3_SHARE, ARGS, NO_OBJ ), - T01("dirreq-v2-resp", K_DIRREQ_V2_RESP, ARGS, NO_OBJ ), - T01("dirreq-v3-resp", K_DIRREQ_V3_RESP, ARGS, NO_OBJ ), - T01("dirreq-v2-direct-dl", K_DIRREQ_V2_DIR, ARGS, NO_OBJ ), - T01("dirreq-v3-direct-dl", K_DIRREQ_V3_DIR, ARGS, NO_OBJ ), - T01("dirreq-v2-tunneled-dl", K_DIRREQ_V2_TUN, ARGS, NO_OBJ ), - T01("dirreq-v3-tunneled-dl", K_DIRREQ_V3_TUN, ARGS, NO_OBJ ), - T01("entry-stats-end", K_ENTRY_END, ARGS, NO_OBJ ), - T01("entry-ips", K_ENTRY_IPS, ARGS, NO_OBJ ), - T01("cell-stats-end", K_CELL_END, ARGS, NO_OBJ ), - T01("cell-processed-cells", K_CELL_PROCESSED, ARGS, NO_OBJ ), - T01("cell-queued-cells", K_CELL_QUEUED, ARGS, NO_OBJ ), - T01("cell-time-in-queue", K_CELL_TIME, ARGS, NO_OBJ ), - T01("cell-circuits-per-decile", K_CELL_CIRCS, ARGS, NO_OBJ ), - T01("exit-stats-end", K_EXIT_END, ARGS, NO_OBJ ), - T01("exit-kibibytes-written", K_EXIT_WRITTEN, ARGS, NO_OBJ ), - T01("exit-kibibytes-read", K_EXIT_READ, ARGS, NO_OBJ ), - T01("exit-streams-opened", K_EXIT_OPENED, ARGS, NO_OBJ ), - - T1_START( "extra-info", K_EXTRA_INFO, GE(2), NO_OBJ ), - - END_OF_TABLE -}; - -/** List of tokens recognized in the body part of v3 networkstatus - * documents. */ -static token_rule_t rtrstatus_token_table[] = { - T01("p", K_P, CONCAT_ARGS, NO_OBJ ), - T1( "r", K_R, GE(7), NO_OBJ ), - T0N("a", K_A, GE(1), NO_OBJ ), - T1( "s", K_S, ARGS, NO_OBJ ), - T01("v", K_V, CONCAT_ARGS, NO_OBJ ), - T01("w", K_W, ARGS, NO_OBJ ), - T0N("m", K_M, CONCAT_ARGS, NO_OBJ ), - T0N("id", K_ID, GE(2), NO_OBJ ), - T01("pr", K_PROTO, CONCAT_ARGS, NO_OBJ ), - T0N("opt", K_OPT, CONCAT_ARGS, OBJ_OK ), - END_OF_TABLE -}; - -/** List of tokens common to V3 authority certificates and V3 consensuses. */ -#define CERTIFICATE_MEMBERS \ - T1("dir-key-certificate-version", K_DIR_KEY_CERTIFICATE_VERSION, \ - GE(1), NO_OBJ ), \ - T1("dir-identity-key", K_DIR_IDENTITY_KEY, NO_ARGS, NEED_KEY ),\ - T1("dir-key-published",K_DIR_KEY_PUBLISHED, CONCAT_ARGS, NO_OBJ), \ - T1("dir-key-expires", K_DIR_KEY_EXPIRES, CONCAT_ARGS, NO_OBJ), \ - T1("dir-signing-key", K_DIR_SIGNING_KEY, NO_ARGS, NEED_KEY ),\ - T1("dir-key-crosscert", K_DIR_KEY_CROSSCERT, NO_ARGS, NEED_OBJ ),\ - T1("dir-key-certification", K_DIR_KEY_CERTIFICATION, \ - NO_ARGS, NEED_OBJ), \ - T01("dir-address", K_DIR_ADDRESS, GE(1), NO_OBJ), - -/** List of tokens recognized in V3 authority certificates. */ -static token_rule_t dir_key_certificate_table[] = { - CERTIFICATE_MEMBERS - T1("fingerprint", K_FINGERPRINT, CONCAT_ARGS, NO_OBJ ), - END_OF_TABLE -}; - -/** List of tokens recognized in rendezvous service descriptors */ -static token_rule_t desc_token_table[] = { - T1_START("rendezvous-service-descriptor", R_RENDEZVOUS_SERVICE_DESCRIPTOR, - EQ(1), NO_OBJ), - T1("version", R_VERSION, EQ(1), NO_OBJ), - T1("permanent-key", R_PERMANENT_KEY, NO_ARGS, NEED_KEY_1024), - T1("secret-id-part", R_SECRET_ID_PART, EQ(1), NO_OBJ), - T1("publication-time", R_PUBLICATION_TIME, CONCAT_ARGS, NO_OBJ), - T1("protocol-versions", R_PROTOCOL_VERSIONS, EQ(1), NO_OBJ), - T01("introduction-points", R_INTRODUCTION_POINTS, NO_ARGS, NEED_OBJ), - T1_END("signature", R_SIGNATURE, NO_ARGS, NEED_OBJ), - END_OF_TABLE -}; - -/** List of tokens recognized in the (encrypted) list of introduction points of - * rendezvous service descriptors */ -static token_rule_t ipo_token_table[] = { - T1_START("introduction-point", R_IPO_IDENTIFIER, EQ(1), NO_OBJ), - T1("ip-address", R_IPO_IP_ADDRESS, EQ(1), NO_OBJ), - T1("onion-port", R_IPO_ONION_PORT, EQ(1), NO_OBJ), - T1("onion-key", R_IPO_ONION_KEY, NO_ARGS, NEED_KEY_1024), - T1("service-key", R_IPO_SERVICE_KEY, NO_ARGS, NEED_KEY_1024), - END_OF_TABLE -}; - -/** List of tokens recognized in the (possibly encrypted) list of introduction - * points of rendezvous service descriptors */ -static token_rule_t client_keys_token_table[] = { - T1_START("client-name", C_CLIENT_NAME, CONCAT_ARGS, NO_OBJ), - T1("descriptor-cookie", C_DESCRIPTOR_COOKIE, EQ(1), NO_OBJ), - T01("client-key", C_CLIENT_KEY, NO_ARGS, NEED_SKEY_1024), - END_OF_TABLE -}; - -/** List of tokens recognized in V3 networkstatus votes. */ -static token_rule_t networkstatus_token_table[] = { - T1_START("network-status-version", K_NETWORK_STATUS_VERSION, - GE(1), NO_OBJ ), - T1("vote-status", K_VOTE_STATUS, GE(1), NO_OBJ ), - T1("published", K_PUBLISHED, CONCAT_ARGS, NO_OBJ ), - T1("valid-after", K_VALID_AFTER, CONCAT_ARGS, NO_OBJ ), - T1("fresh-until", K_FRESH_UNTIL, CONCAT_ARGS, NO_OBJ ), - T1("valid-until", K_VALID_UNTIL, CONCAT_ARGS, NO_OBJ ), - T1("voting-delay", K_VOTING_DELAY, GE(2), NO_OBJ ), - T1("known-flags", K_KNOWN_FLAGS, ARGS, NO_OBJ ), - T01("params", K_PARAMS, ARGS, NO_OBJ ), - T( "fingerprint", K_FINGERPRINT, CONCAT_ARGS, NO_OBJ ), - T01("signing-ed25519", K_SIGNING_CERT_ED, NO_ARGS , NEED_OBJ ), - T01("shared-rand-participate",K_SR_FLAG, NO_ARGS, NO_OBJ ), - T0N("shared-rand-commit", K_COMMIT, GE(3), NO_OBJ ), - T01("shared-rand-previous-value", K_PREVIOUS_SRV,EQ(2), NO_OBJ ), - T01("shared-rand-current-value", K_CURRENT_SRV, EQ(2), NO_OBJ ), - T0N("package", K_PACKAGE, CONCAT_ARGS, NO_OBJ ), - T01("recommended-client-protocols", K_RECOMMENDED_CLIENT_PROTOCOLS, - CONCAT_ARGS, NO_OBJ ), - T01("recommended-relay-protocols", K_RECOMMENDED_RELAY_PROTOCOLS, - CONCAT_ARGS, NO_OBJ ), - T01("required-client-protocols", K_REQUIRED_CLIENT_PROTOCOLS, - CONCAT_ARGS, NO_OBJ ), - T01("required-relay-protocols", K_REQUIRED_RELAY_PROTOCOLS, - CONCAT_ARGS, NO_OBJ ), - - CERTIFICATE_MEMBERS - - T0N("opt", K_OPT, CONCAT_ARGS, OBJ_OK ), - T1( "contact", K_CONTACT, CONCAT_ARGS, NO_OBJ ), - T1( "dir-source", K_DIR_SOURCE, GE(6), NO_OBJ ), - T01("legacy-dir-key", K_LEGACY_DIR_KEY, GE(1), NO_OBJ ), - T1( "known-flags", K_KNOWN_FLAGS, CONCAT_ARGS, NO_OBJ ), - T01("client-versions", K_CLIENT_VERSIONS, CONCAT_ARGS, NO_OBJ ), - T01("server-versions", K_SERVER_VERSIONS, CONCAT_ARGS, NO_OBJ ), - T1( "consensus-methods", K_CONSENSUS_METHODS, GE(1), NO_OBJ ), - - END_OF_TABLE -}; - -/** List of tokens recognized in V3 networkstatus consensuses. */ -static token_rule_t networkstatus_consensus_token_table[] = { - T1_START("network-status-version", K_NETWORK_STATUS_VERSION, - GE(1), NO_OBJ ), - T1("vote-status", K_VOTE_STATUS, GE(1), NO_OBJ ), - T1("valid-after", K_VALID_AFTER, CONCAT_ARGS, NO_OBJ ), - T1("fresh-until", K_FRESH_UNTIL, CONCAT_ARGS, NO_OBJ ), - T1("valid-until", K_VALID_UNTIL, CONCAT_ARGS, NO_OBJ ), - T1("voting-delay", K_VOTING_DELAY, GE(2), NO_OBJ ), - - T0N("opt", K_OPT, CONCAT_ARGS, OBJ_OK ), - - T1N("dir-source", K_DIR_SOURCE, GE(6), NO_OBJ ), - T1N("contact", K_CONTACT, CONCAT_ARGS, NO_OBJ ), - T1N("vote-digest", K_VOTE_DIGEST, GE(1), NO_OBJ ), - - T1( "known-flags", K_KNOWN_FLAGS, CONCAT_ARGS, NO_OBJ ), - - T01("client-versions", K_CLIENT_VERSIONS, CONCAT_ARGS, NO_OBJ ), - T01("server-versions", K_SERVER_VERSIONS, CONCAT_ARGS, NO_OBJ ), - T01("consensus-method", K_CONSENSUS_METHOD, EQ(1), NO_OBJ), - T01("params", K_PARAMS, ARGS, NO_OBJ ), - - T01("shared-rand-previous-value", K_PREVIOUS_SRV, EQ(2), NO_OBJ ), - T01("shared-rand-current-value", K_CURRENT_SRV, EQ(2), NO_OBJ ), - - T01("recommended-client-protocols", K_RECOMMENDED_CLIENT_PROTOCOLS, - CONCAT_ARGS, NO_OBJ ), - T01("recommended-relay-protocols", K_RECOMMENDED_RELAY_PROTOCOLS, - CONCAT_ARGS, NO_OBJ ), - T01("required-client-protocols", K_REQUIRED_CLIENT_PROTOCOLS, - CONCAT_ARGS, NO_OBJ ), - T01("required-relay-protocols", K_REQUIRED_RELAY_PROTOCOLS, - CONCAT_ARGS, NO_OBJ ), - - END_OF_TABLE -}; - -/** List of tokens recognized in the footer of v1 directory footers. */ -static token_rule_t networkstatus_vote_footer_token_table[] = { - T01("directory-footer", K_DIRECTORY_FOOTER, NO_ARGS, NO_OBJ ), - T01("bandwidth-weights", K_BW_WEIGHTS, ARGS, NO_OBJ ), - T( "directory-signature", K_DIRECTORY_SIGNATURE, GE(2), NEED_OBJ ), - END_OF_TABLE -}; - -/** List of tokens recognized in detached networkstatus signature documents. */ -static token_rule_t networkstatus_detached_signature_token_table[] = { - T1_START("consensus-digest", K_CONSENSUS_DIGEST, GE(1), NO_OBJ ), - T("additional-digest", K_ADDITIONAL_DIGEST,GE(3), NO_OBJ ), - T1("valid-after", K_VALID_AFTER, CONCAT_ARGS, NO_OBJ ), - T1("fresh-until", K_FRESH_UNTIL, CONCAT_ARGS, NO_OBJ ), - T1("valid-until", K_VALID_UNTIL, CONCAT_ARGS, NO_OBJ ), - T("additional-signature", K_ADDITIONAL_SIGNATURE, GE(4), NEED_OBJ ), - T1N("directory-signature", K_DIRECTORY_SIGNATURE, GE(2), NEED_OBJ ), - END_OF_TABLE -}; - -/** List of tokens recognized in microdescriptors */ -static token_rule_t microdesc_token_table[] = { - T1_START("onion-key", K_ONION_KEY, NO_ARGS, NEED_KEY_1024), - T01("ntor-onion-key", K_ONION_KEY_NTOR, GE(1), NO_OBJ ), - T0N("id", K_ID, GE(2), NO_OBJ ), - T0N("a", K_A, GE(1), NO_OBJ ), - T01("family", K_FAMILY, ARGS, NO_OBJ ), - T01("p", K_P, CONCAT_ARGS, NO_OBJ ), - T01("p6", K_P6, CONCAT_ARGS, NO_OBJ ), - A01("@last-listed", A_LAST_LISTED, CONCAT_ARGS, NO_OBJ ), - END_OF_TABLE -}; - -#undef T - -/* static function prototypes */ -static int router_add_exit_policy(routerinfo_t *router,directory_token_t *tok); -static addr_policy_t *router_parse_addr_policy(directory_token_t *tok, - unsigned fmt_flags); -static addr_policy_t *router_parse_addr_policy_private(directory_token_t *tok); - -static int router_get_hash_impl_helper(const char *s, size_t s_len, - const char *start_str, - const char *end_str, char end_c, - int log_severity, - const char **start_out, const char **end_out); -static int router_get_hash_impl(const char *s, size_t s_len, char *digest, - const char *start_str, const char *end_str, - char end_char, - digest_algorithm_t alg); -static int router_get_hashes_impl(const char *s, size_t s_len, - common_digests_t *digests, - const char *start_str, const char *end_str, - char end_char); -static smartlist_t *find_all_exitpolicy(smartlist_t *s); - -#define CST_NO_CHECK_OBJTYPE (1<<0) -static int check_signature_token(const char *digest, - ssize_t digest_len, - directory_token_t *tok, - crypto_pk_t *pkey, - int flags, - const char *doctype); - -#undef DEBUG_AREA_ALLOC - -#ifdef DEBUG_AREA_ALLOC -#define DUMP_AREA(a,name) STMT_BEGIN \ - size_t alloc=0, used=0; \ - memarea_get_stats((a),&alloc,&used); \ - log_debug(LD_MM, "Area for %s has %lu allocated; using %lu.", \ - name, (unsigned long)alloc, (unsigned long)used); \ - STMT_END -#else /* !(defined(DEBUG_AREA_ALLOC)) */ -#define DUMP_AREA(a,name) STMT_NIL -#endif /* defined(DEBUG_AREA_ALLOC) */ - -/* Dump mechanism for unparseable descriptors */ - -/** List of dumped descriptors for FIFO cleanup purposes */ -STATIC smartlist_t *descs_dumped = NULL; -/** Total size of dumped descriptors for FIFO cleanup */ -STATIC uint64_t len_descs_dumped = 0; -/** Directory to stash dumps in */ -static int have_dump_desc_dir = 0; -static int problem_with_dump_desc_dir = 0; - -#define DESC_DUMP_DATADIR_SUBDIR "unparseable-descs" -#define DESC_DUMP_BASE_FILENAME "unparseable-desc" - -/** Find the dump directory and check if we'll be able to create it */ -static void -dump_desc_init(void) -{ - char *dump_desc_dir; - - dump_desc_dir = get_datadir_fname(DESC_DUMP_DATADIR_SUBDIR); - - /* - * We just check for it, don't create it at this point; we'll - * create it when we need it if it isn't already there. - */ - if (check_private_dir(dump_desc_dir, CPD_CHECK, get_options()->User) < 0) { - /* Error, log and flag it as having a problem */ - log_notice(LD_DIR, - "Doesn't look like we'll be able to create descriptor dump " - "directory %s; dumps will be disabled.", - dump_desc_dir); - problem_with_dump_desc_dir = 1; - tor_free(dump_desc_dir); - return; - } - - /* Check if it exists */ - switch (file_status(dump_desc_dir)) { - case FN_DIR: - /* We already have a directory */ - have_dump_desc_dir = 1; - break; - case FN_NOENT: - /* Nothing, we'll need to create it later */ - have_dump_desc_dir = 0; - break; - case FN_ERROR: - /* Log and flag having a problem */ - log_notice(LD_DIR, - "Couldn't check whether descriptor dump directory %s already" - " exists: %s", - dump_desc_dir, strerror(errno)); - problem_with_dump_desc_dir = 1; - break; - case FN_FILE: - case FN_EMPTY: - default: - /* Something else was here! */ - log_notice(LD_DIR, - "Descriptor dump directory %s already exists and isn't a " - "directory", - dump_desc_dir); - problem_with_dump_desc_dir = 1; - } - - if (have_dump_desc_dir && !problem_with_dump_desc_dir) { - dump_desc_populate_fifo_from_directory(dump_desc_dir); - } - - tor_free(dump_desc_dir); -} - -/** Create the dump directory if needed and possible */ -static void -dump_desc_create_dir(void) -{ - char *dump_desc_dir; - - /* If the problem flag is set, skip it */ - if (problem_with_dump_desc_dir) return; - - /* Do we need it? */ - if (!have_dump_desc_dir) { - dump_desc_dir = get_datadir_fname(DESC_DUMP_DATADIR_SUBDIR); - - if (check_private_dir(dump_desc_dir, CPD_CREATE, - get_options()->User) < 0) { - log_notice(LD_DIR, - "Failed to create descriptor dump directory %s", - dump_desc_dir); - problem_with_dump_desc_dir = 1; - } - - /* Okay, we created it */ - have_dump_desc_dir = 1; - - tor_free(dump_desc_dir); - } -} - -/** Dump desc FIFO/cleanup; take ownership of the given filename, add it to - * the FIFO, and clean up the oldest entries to the extent they exceed the - * configured cap. If any old entries with a matching hash existed, they - * just got overwritten right before this was called and we should adjust - * the total size counter without deleting them. - */ -static void -dump_desc_fifo_add_and_clean(char *filename, const uint8_t *digest_sha256, - size_t len) -{ - dumped_desc_t *ent = NULL, *tmp; - uint64_t max_len; - - tor_assert(filename != NULL); - tor_assert(digest_sha256 != NULL); - - if (descs_dumped == NULL) { - /* We better have no length, then */ - tor_assert(len_descs_dumped == 0); - /* Make a smartlist */ - descs_dumped = smartlist_new(); - } - - /* Make a new entry to put this one in */ - ent = tor_malloc_zero(sizeof(*ent)); - ent->filename = filename; - ent->len = len; - ent->when = time(NULL); - memcpy(ent->digest_sha256, digest_sha256, DIGEST256_LEN); - - /* Do we need to do some cleanup? */ - max_len = get_options()->MaxUnparseableDescSizeToLog; - /* Iterate over the list until we've freed enough space */ - while (len > max_len - len_descs_dumped && - smartlist_len(descs_dumped) > 0) { - /* Get the oldest thing on the list */ - tmp = (dumped_desc_t *)(smartlist_get(descs_dumped, 0)); - - /* - * Check if it matches the filename we just added, so we don't delete - * something we just emitted if we get repeated identical descriptors. - */ - if (strcmp(tmp->filename, filename) != 0) { - /* Delete it and adjust the length counter */ - tor_unlink(tmp->filename); - tor_assert(len_descs_dumped >= tmp->len); - len_descs_dumped -= tmp->len; - log_info(LD_DIR, - "Deleting old unparseable descriptor dump %s due to " - "space limits", - tmp->filename); - } else { - /* - * Don't delete, but do adjust the counter since we will bump it - * later - */ - tor_assert(len_descs_dumped >= tmp->len); - len_descs_dumped -= tmp->len; - log_info(LD_DIR, - "Replacing old descriptor dump %s with new identical one", - tmp->filename); - } - - /* Free it and remove it from the list */ - smartlist_del_keeporder(descs_dumped, 0); - tor_free(tmp->filename); - tor_free(tmp); - } - - /* Append our entry to the end of the list and bump the counter */ - smartlist_add(descs_dumped, ent); - len_descs_dumped += len; -} - -/** Check if we already have a descriptor for this hash and move it to the - * head of the queue if so. Return 1 if one existed and 0 otherwise. - */ -static int -dump_desc_fifo_bump_hash(const uint8_t *digest_sha256) -{ - dumped_desc_t *match = NULL; - - tor_assert(digest_sha256); - - if (descs_dumped) { - /* Find a match if one exists */ - SMARTLIST_FOREACH_BEGIN(descs_dumped, dumped_desc_t *, ent) { - if (ent && - tor_memeq(ent->digest_sha256, digest_sha256, DIGEST256_LEN)) { - /* - * Save a pointer to the match and remove it from its current - * position. - */ - match = ent; - SMARTLIST_DEL_CURRENT_KEEPORDER(descs_dumped, ent); - break; - } - } SMARTLIST_FOREACH_END(ent); - - if (match) { - /* Update the timestamp */ - match->when = time(NULL); - /* Add it back at the end of the list */ - smartlist_add(descs_dumped, match); - - /* Indicate we found one */ - return 1; - } - } - - return 0; -} - -/** Clean up on exit; just memory, leave the dumps behind - */ -STATIC void -dump_desc_fifo_cleanup(void) -{ - if (descs_dumped) { - /* Free each descriptor */ - SMARTLIST_FOREACH_BEGIN(descs_dumped, dumped_desc_t *, ent) { - tor_assert(ent); - tor_free(ent->filename); - tor_free(ent); - } SMARTLIST_FOREACH_END(ent); - /* Free the list */ - smartlist_free(descs_dumped); - descs_dumped = NULL; - len_descs_dumped = 0; - } -} - -/** Handle one file for dump_desc_populate_fifo_from_directory(); make sure - * the filename is sensibly formed and matches the file content, and either - * return a dumped_desc_t for it or remove the file and return NULL. - */ -MOCK_IMPL(STATIC dumped_desc_t *, -dump_desc_populate_one_file, (const char *dirname, const char *f)) -{ - dumped_desc_t *ent = NULL; - char *path = NULL, *desc = NULL; - const char *digest_str; - char digest[DIGEST256_LEN], content_digest[DIGEST256_LEN]; - /* Expected prefix before digest in filenames */ - const char *f_pfx = DESC_DUMP_BASE_FILENAME "."; - /* - * Stat while reading; this is important in case the file - * contains a NUL character. - */ - struct stat st; - - /* Sanity-check args */ - tor_assert(dirname != NULL); - tor_assert(f != NULL); - - /* Form the full path */ - tor_asprintf(&path, "%s" PATH_SEPARATOR "%s", dirname, f); - - /* Check that f has the form DESC_DUMP_BASE_FILENAME.<digest256> */ - - if (!strcmpstart(f, f_pfx)) { - /* It matches the form, but is the digest parseable as such? */ - digest_str = f + strlen(f_pfx); - if (base16_decode(digest, DIGEST256_LEN, - digest_str, strlen(digest_str)) != DIGEST256_LEN) { - /* We failed to decode it */ - digest_str = NULL; - } - } else { - /* No match */ - digest_str = NULL; - } - - if (!digest_str) { - /* We couldn't get a sensible digest */ - log_notice(LD_DIR, - "Removing unrecognized filename %s from unparseable " - "descriptors directory", f); - tor_unlink(path); - /* We're done */ - goto done; - } - - /* - * The filename has the form DESC_DUMP_BASE_FILENAME "." <digest256> and - * we've decoded the digest. Next, check that we can read it and the - * content matches this digest. We are relying on the fact that if the - * file contains a '\0', read_file_to_str() will allocate space for and - * read the entire file and return the correct size in st. - */ - desc = read_file_to_str(path, RFTS_IGNORE_MISSING|RFTS_BIN, &st); - if (!desc) { - /* We couldn't read it */ - log_notice(LD_DIR, - "Failed to read %s from unparseable descriptors directory; " - "attempting to remove it.", f); - tor_unlink(path); - /* We're done */ - goto done; - } - -#if SIZE_MAX > UINT64_MAX - if (BUG((uint64_t)st.st_size > (uint64_t)SIZE_MAX)) { - /* LCOV_EXCL_START - * Should be impossible since RFTS above should have failed to read the - * huge file into RAM. */ - goto done; - /* LCOV_EXCL_STOP */ - } -#endif /* SIZE_MAX > UINT64_MAX */ - if (BUG(st.st_size < 0)) { - /* LCOV_EXCL_START - * Should be impossible, since the OS isn't supposed to be b0rken. */ - goto done; - /* LCOV_EXCL_STOP */ - } - /* (Now we can be sure that st.st_size is safe to cast to a size_t.) */ - - /* - * We got one; now compute its digest and check that it matches the - * filename. - */ - if (crypto_digest256((char *)content_digest, desc, (size_t) st.st_size, - DIGEST_SHA256) < 0) { - /* Weird, but okay */ - log_info(LD_DIR, - "Unable to hash content of %s from unparseable descriptors " - "directory", f); - tor_unlink(path); - /* We're done */ - goto done; - } - - /* Compare the digests */ - if (tor_memneq(digest, content_digest, DIGEST256_LEN)) { - /* No match */ - log_info(LD_DIR, - "Hash of %s from unparseable descriptors directory didn't " - "match its filename; removing it", f); - tor_unlink(path); - /* We're done */ - goto done; - } - - /* Okay, it's a match, we should prepare ent */ - ent = tor_malloc_zero(sizeof(dumped_desc_t)); - ent->filename = path; - memcpy(ent->digest_sha256, digest, DIGEST256_LEN); - ent->len = (size_t) st.st_size; - ent->when = st.st_mtime; - /* Null out path so we don't free it out from under ent */ - path = NULL; - - done: - /* Free allocations if we had them */ - tor_free(desc); - tor_free(path); - - return ent; -} - -/** Sort helper for dump_desc_populate_fifo_from_directory(); compares - * the when field of dumped_desc_ts in a smartlist to put the FIFO in - * the correct order after reconstructing it from the directory. - */ -static int -dump_desc_compare_fifo_entries(const void **a_v, const void **b_v) -{ - const dumped_desc_t **a = (const dumped_desc_t **)a_v; - const dumped_desc_t **b = (const dumped_desc_t **)b_v; - - if ((a != NULL) && (*a != NULL)) { - if ((b != NULL) && (*b != NULL)) { - /* We have sensible dumped_desc_ts to compare */ - if ((*a)->when < (*b)->when) { - return -1; - } else if ((*a)->when == (*b)->when) { - return 0; - } else { - return 1; - } - } else { - /* - * We shouldn't see this, but what the hell, NULLs precede everythin - * else - */ - return 1; - } - } else { - return -1; - } -} - -/** Scan the contents of the directory, and update FIFO/counters; this will - * consistency-check descriptor dump filenames against hashes of descriptor - * dump file content, and remove any inconsistent/unreadable dumps, and then - * reconstruct the dump FIFO as closely as possible for the last time the - * tor process shut down. If a previous dump was repeated more than once and - * moved ahead in the FIFO, the mtime will not have been updated and the - * reconstructed order will be wrong, but will always be a permutation of - * the original. - */ -STATIC void -dump_desc_populate_fifo_from_directory(const char *dirname) -{ - smartlist_t *files = NULL; - dumped_desc_t *ent = NULL; - - tor_assert(dirname != NULL); - - /* Get a list of files */ - files = tor_listdir(dirname); - if (!files) { - log_notice(LD_DIR, - "Unable to get contents of unparseable descriptor dump " - "directory %s", - dirname); - return; - } - - /* - * Iterate through the list and decide which files should go in the - * FIFO and which should be purged. - */ - - SMARTLIST_FOREACH_BEGIN(files, char *, f) { - /* Try to get a FIFO entry */ - ent = dump_desc_populate_one_file(dirname, f); - if (ent) { - /* - * We got one; add it to the FIFO. No need for duplicate checking - * here since we just verified the name and digest match. - */ - - /* Make sure we have a list to add it to */ - if (!descs_dumped) { - descs_dumped = smartlist_new(); - len_descs_dumped = 0; - } - - /* Add it and adjust the counter */ - smartlist_add(descs_dumped, ent); - len_descs_dumped += ent->len; - } - /* - * If we didn't, we will have unlinked the file if necessary and - * possible, and emitted a log message about it, so just go on to - * the next. - */ - } SMARTLIST_FOREACH_END(f); - - /* Did we get anything? */ - if (descs_dumped != NULL) { - /* Sort the FIFO in order of increasing timestamp */ - smartlist_sort(descs_dumped, dump_desc_compare_fifo_entries); - - /* Log some stats */ - log_info(LD_DIR, - "Reloaded unparseable descriptor dump FIFO with %d dump(s) " - "totaling %"PRIu64 " bytes", - smartlist_len(descs_dumped), (len_descs_dumped)); - } - - /* Free the original list */ - SMARTLIST_FOREACH(files, char *, f, tor_free(f)); - smartlist_free(files); -} - -/** For debugging purposes, dump unparseable descriptor *<b>desc</b> of - * type *<b>type</b> to file $DATADIR/unparseable-desc. Do not write more - * than one descriptor to disk per minute. If there is already such a - * file in the data directory, overwrite it. */ -MOCK_IMPL(STATIC void, -dump_desc,(const char *desc, const char *type)) -{ - tor_assert(desc); - tor_assert(type); - size_t len; - /* The SHA256 of the string */ - uint8_t digest_sha256[DIGEST256_LEN]; - char digest_sha256_hex[HEX_DIGEST256_LEN+1]; - /* Filename to log it to */ - char *debugfile, *debugfile_base; - - /* Get the hash for logging purposes anyway */ - len = strlen(desc); - if (crypto_digest256((char *)digest_sha256, desc, len, - DIGEST_SHA256) < 0) { - log_info(LD_DIR, - "Unable to parse descriptor of type %s, and unable to even hash" - " it!", type); - goto err; - } - - base16_encode(digest_sha256_hex, sizeof(digest_sha256_hex), - (const char *)digest_sha256, sizeof(digest_sha256)); - - /* - * We mention type and hash in the main log; don't clutter up the files - * with anything but the exact dump. - */ - tor_asprintf(&debugfile_base, - DESC_DUMP_BASE_FILENAME ".%s", digest_sha256_hex); - debugfile = get_datadir_fname2(DESC_DUMP_DATADIR_SUBDIR, debugfile_base); - - /* - * Check if the sandbox is active or will become active; see comment - * below at the log message for why. - */ - if (!(sandbox_is_active() || get_options()->Sandbox)) { - if (len <= get_options()->MaxUnparseableDescSizeToLog) { - if (!dump_desc_fifo_bump_hash(digest_sha256)) { - /* Create the directory if needed */ - dump_desc_create_dir(); - /* Make sure we've got it */ - if (have_dump_desc_dir && !problem_with_dump_desc_dir) { - /* Write it, and tell the main log about it */ - write_str_to_file(debugfile, desc, 1); - log_info(LD_DIR, - "Unable to parse descriptor of type %s with hash %s and " - "length %lu. See file %s in data directory for details.", - type, digest_sha256_hex, (unsigned long)len, - debugfile_base); - dump_desc_fifo_add_and_clean(debugfile, digest_sha256, len); - /* Since we handed ownership over, don't free debugfile later */ - debugfile = NULL; - } else { - /* Problem with the subdirectory */ - log_info(LD_DIR, - "Unable to parse descriptor of type %s with hash %s and " - "length %lu. Descriptor not dumped because we had a " - "problem creating the " DESC_DUMP_DATADIR_SUBDIR - " subdirectory", - type, digest_sha256_hex, (unsigned long)len); - /* We do have to free debugfile in this case */ - } - } else { - /* We already had one with this hash dumped */ - log_info(LD_DIR, - "Unable to parse descriptor of type %s with hash %s and " - "length %lu. Descriptor not dumped because one with that " - "hash has already been dumped.", - type, digest_sha256_hex, (unsigned long)len); - /* We do have to free debugfile in this case */ - } - } else { - /* Just log that it happened without dumping */ - log_info(LD_DIR, - "Unable to parse descriptor of type %s with hash %s and " - "length %lu. Descriptor not dumped because it exceeds maximum" - " log size all by itself.", - type, digest_sha256_hex, (unsigned long)len); - /* We do have to free debugfile in this case */ - } - } else { - /* - * Not logging because the sandbox is active and seccomp2 apparently - * doesn't have a sensible way to allow filenames according to a pattern - * match. (If we ever figure out how to say "allow writes to /regex/", - * remove this checK). - */ - log_info(LD_DIR, - "Unable to parse descriptor of type %s with hash %s and " - "length %lu. Descriptor not dumped because the sandbox is " - "configured", - type, digest_sha256_hex, (unsigned long)len); - } - - tor_free(debugfile_base); - tor_free(debugfile); - - err: - return; -} - -/** Set <b>digest</b> to the SHA-1 digest of the hash of the directory in - * <b>s</b>. Return 0 on success, -1 on failure. - */ -int -router_get_dir_hash(const char *s, char *digest) -{ - return router_get_hash_impl(s, strlen(s), digest, - "signed-directory","\ndirectory-signature",'\n', - DIGEST_SHA1); -} - -/** Set <b>digest</b> to the SHA-1 digest of the hash of the first router in - * <b>s</b>. Return 0 on success, -1 on failure. - */ -int -router_get_router_hash(const char *s, size_t s_len, char *digest) -{ - return router_get_hash_impl(s, s_len, digest, - "router ","\nrouter-signature", '\n', - DIGEST_SHA1); -} - -/** Try to find the start and end of the signed portion of a networkstatus - * document in <b>s</b>. On success, set <b>start_out</b> to the first - * character of the document, and <b>end_out</b> to a position one after the - * final character of the signed document, and return 0. On failure, return - * -1. */ -int -router_get_networkstatus_v3_signed_boundaries(const char *s, - const char **start_out, - const char **end_out) -{ - return router_get_hash_impl_helper(s, strlen(s), - "network-status-version", - "\ndirectory-signature", - ' ', LOG_INFO, - start_out, end_out); -} - -/** Set <b>digest_out</b> to the SHA3-256 digest of the signed portion of the - * networkstatus vote in <b>s</b> -- or of the entirety of <b>s</b> if no - * signed portion can be identified. Return 0 on success, -1 on failure. */ -int -router_get_networkstatus_v3_sha3_as_signed(uint8_t *digest_out, - const char *s) -{ - const char *start, *end; - if (router_get_networkstatus_v3_signed_boundaries(s, &start, &end) < 0) { - start = s; - end = s + strlen(s); - } - tor_assert(start); - tor_assert(end); - return crypto_digest256((char*)digest_out, start, end-start, - DIGEST_SHA3_256); -} - -/** Set <b>digests</b> to all the digests of the consensus document in - * <b>s</b> */ -int -router_get_networkstatus_v3_hashes(const char *s, common_digests_t *digests) -{ - return router_get_hashes_impl(s,strlen(s),digests, - "network-status-version", - "\ndirectory-signature", - ' '); -} - -/** Set <b>digest</b> to the SHA-1 digest of the hash of the <b>s_len</b>-byte - * extrainfo string at <b>s</b>. Return 0 on success, -1 on failure. */ -int -router_get_extrainfo_hash(const char *s, size_t s_len, char *digest) -{ - return router_get_hash_impl(s, s_len, digest, "extra-info", - "\nrouter-signature",'\n', DIGEST_SHA1); -} - -/** Helper: used to generate signatures for routers, directories and - * network-status objects. Given a <b>digest_len</b>-byte digest in - * <b>digest</b> and a secret <b>private_key</b>, generate an PKCS1-padded - * signature, BASE64-encode it, surround it with -----BEGIN/END----- pairs, - * and return the new signature on success or NULL on failure. - */ -char * -router_get_dirobj_signature(const char *digest, - size_t digest_len, - const crypto_pk_t *private_key) -{ - char *signature; - size_t i, keysize; - int siglen; - char *buf = NULL; - size_t buf_len; - /* overestimate of BEGIN/END lines total len. */ -#define BEGIN_END_OVERHEAD_LEN 64 - - keysize = crypto_pk_keysize(private_key); - signature = tor_malloc(keysize); - siglen = crypto_pk_private_sign(private_key, signature, keysize, - digest, digest_len); - if (siglen < 0) { - log_warn(LD_BUG,"Couldn't sign digest."); - goto err; - } - - /* The *2 here is a ridiculous overestimate of base-64 overhead. */ - buf_len = (siglen * 2) + BEGIN_END_OVERHEAD_LEN; - buf = tor_malloc(buf_len); - - if (strlcpy(buf, "-----BEGIN SIGNATURE-----\n", buf_len) >= buf_len) - goto truncated; - - i = strlen(buf); - if (base64_encode(buf+i, buf_len-i, signature, siglen, - BASE64_ENCODE_MULTILINE) < 0) { - log_warn(LD_BUG,"couldn't base64-encode signature"); - goto err; - } - - if (strlcat(buf, "-----END SIGNATURE-----\n", buf_len) >= buf_len) - goto truncated; - - tor_free(signature); - return buf; - - truncated: - log_warn(LD_BUG,"tried to exceed string length."); - err: - tor_free(signature); - tor_free(buf); - return NULL; -} - -/** Helper: used to generate signatures for routers, directories and - * network-status objects. Given a digest in <b>digest</b> and a secret - * <b>private_key</b>, generate a PKCS1-padded signature, BASE64-encode it, - * surround it with -----BEGIN/END----- pairs, and write it to the - * <b>buf_len</b>-byte buffer at <b>buf</b>. Return 0 on success, -1 on - * failure. - */ -int -router_append_dirobj_signature(char *buf, size_t buf_len, const char *digest, - size_t digest_len, crypto_pk_t *private_key) -{ - size_t sig_len, s_len; - char *sig = router_get_dirobj_signature(digest, digest_len, private_key); - if (!sig) { - log_warn(LD_BUG, "No signature generated"); - return -1; - } - sig_len = strlen(sig); - s_len = strlen(buf); - if (sig_len + s_len + 1 > buf_len) { - log_warn(LD_BUG, "Not enough room for signature"); - tor_free(sig); - return -1; - } - memcpy(buf+s_len, sig, sig_len+1); - tor_free(sig); - return 0; -} - -/** Return VS_RECOMMENDED if <b>myversion</b> is contained in - * <b>versionlist</b>. Else, return VS_EMPTY if versionlist has no - * entries. Else, return VS_OLD if every member of - * <b>versionlist</b> is newer than <b>myversion</b>. Else, return - * VS_NEW_IN_SERIES if there is at least one member of <b>versionlist</b> in - * the same series (major.minor.micro) as <b>myversion</b>, but no such member - * is newer than <b>myversion.</b>. Else, return VS_NEW if every member of - * <b>versionlist</b> is older than <b>myversion</b>. Else, return - * VS_UNRECOMMENDED. - * - * (versionlist is a comma-separated list of version strings, - * optionally prefixed with "Tor". Versions that can't be parsed are - * ignored.) - */ -version_status_t -tor_version_is_obsolete(const char *myversion, const char *versionlist) -{ - tor_version_t mine, other; - int found_newer = 0, found_older = 0, found_newer_in_series = 0, - found_any_in_series = 0, r, same; - version_status_t ret = VS_UNRECOMMENDED; - smartlist_t *version_sl; - - log_debug(LD_CONFIG,"Checking whether version '%s' is in '%s'", - myversion, versionlist); - - if (tor_version_parse(myversion, &mine)) { - log_err(LD_BUG,"I couldn't parse my own version (%s)", myversion); - tor_assert(0); - } - version_sl = smartlist_new(); - smartlist_split_string(version_sl, versionlist, ",", SPLIT_SKIP_SPACE, 0); - - if (!strlen(versionlist)) { /* no authorities cared or agreed */ - ret = VS_EMPTY; - goto done; - } - - SMARTLIST_FOREACH_BEGIN(version_sl, const char *, cp) { - if (!strcmpstart(cp, "Tor ")) - cp += 4; - - if (tor_version_parse(cp, &other)) { - /* Couldn't parse other; it can't be a match. */ - } else { - same = tor_version_same_series(&mine, &other); - if (same) - found_any_in_series = 1; - r = tor_version_compare(&mine, &other); - if (r==0) { - ret = VS_RECOMMENDED; - goto done; - } else if (r<0) { - found_newer = 1; - if (same) - found_newer_in_series = 1; - } else if (r>0) { - found_older = 1; - } - } - } SMARTLIST_FOREACH_END(cp); - - /* We didn't find the listed version. Is it new or old? */ - if (found_any_in_series && !found_newer_in_series && found_newer) { - ret = VS_NEW_IN_SERIES; - } else if (found_newer && !found_older) { - ret = VS_OLD; - } else if (found_older && !found_newer) { - ret = VS_NEW; - } else { - ret = VS_UNRECOMMENDED; - } - - done: - SMARTLIST_FOREACH(version_sl, char *, version, tor_free(version)); - smartlist_free(version_sl); - return ret; -} - -MOCK_IMPL(STATIC int, -signed_digest_equals, (const uint8_t *d1, const uint8_t *d2, size_t len)) -{ - return tor_memeq(d1, d2, len); -} - -/** Check whether the object body of the token in <b>tok</b> has a good - * signature for <b>digest</b> using key <b>pkey</b>. - * If <b>CST_NO_CHECK_OBJTYPE</b> is set, do not check - * the object type of the signature object. Use <b>doctype</b> as the type of - * the document when generating log messages. Return 0 on success, negative - * on failure. - */ -static int -check_signature_token(const char *digest, - ssize_t digest_len, - directory_token_t *tok, - crypto_pk_t *pkey, - int flags, - const char *doctype) -{ - char *signed_digest; - size_t keysize; - const int check_objtype = ! (flags & CST_NO_CHECK_OBJTYPE); - - tor_assert(pkey); - tor_assert(tok); - tor_assert(digest); - tor_assert(doctype); - - if (check_objtype) { - if (strcmp(tok->object_type, "SIGNATURE")) { - log_warn(LD_DIR, "Bad object type on %s signature", doctype); - return -1; - } - } - - keysize = crypto_pk_keysize(pkey); - signed_digest = tor_malloc(keysize); - if (crypto_pk_public_checksig(pkey, signed_digest, keysize, - tok->object_body, tok->object_size) - < digest_len) { - log_warn(LD_DIR, "Error reading %s: invalid signature.", doctype); - tor_free(signed_digest); - return -1; - } - // log_debug(LD_DIR,"Signed %s hash starts %s", doctype, - // hex_str(signed_digest,4)); - if (! signed_digest_equals((const uint8_t *)digest, - (const uint8_t *)signed_digest, digest_len)) { - log_warn(LD_DIR, "Error reading %s: signature does not match.", doctype); - tor_free(signed_digest); - return -1; - } - tor_free(signed_digest); - return 0; -} - -/** Helper: move *<b>s_ptr</b> ahead to the next router, the next extra-info, - * or to the first of the annotations proceeding the next router or - * extra-info---whichever comes first. Set <b>is_extrainfo_out</b> to true if - * we found an extrainfo, or false if found a router. Do not scan beyond - * <b>eos</b>. Return -1 if we found nothing; 0 if we found something. */ -static int -find_start_of_next_router_or_extrainfo(const char **s_ptr, - const char *eos, - int *is_extrainfo_out) -{ - const char *annotations = NULL; - const char *s = *s_ptr; - - s = eat_whitespace_eos(s, eos); - - while (s < eos-32) { /* 32 gives enough room for a the first keyword. */ - /* We're at the start of a line. */ - tor_assert(*s != '\n'); - - if (*s == '@' && !annotations) { - annotations = s; - } else if (*s == 'r' && !strcmpstart(s, "router ")) { - *s_ptr = annotations ? annotations : s; - *is_extrainfo_out = 0; - return 0; - } else if (*s == 'e' && !strcmpstart(s, "extra-info ")) { - *s_ptr = annotations ? annotations : s; - *is_extrainfo_out = 1; - return 0; - } - - if (!(s = memchr(s+1, '\n', eos-(s+1)))) - break; - s = eat_whitespace_eos(s, eos); - } - return -1; -} - -/** Given a string *<b>s</b> containing a concatenated sequence of router - * descriptors (or extra-info documents if <b>want_extrainfo</b> is set), - * parses them and stores the result in <b>dest</b>. All routers are marked - * running and valid. Advances *s to a point immediately following the last - * router entry. Ignore any trailing router entries that are not complete. - * - * If <b>saved_location</b> isn't SAVED_IN_CACHE, make a local copy of each - * descriptor in the signed_descriptor_body field of each routerinfo_t. If it - * isn't SAVED_NOWHERE, remember the offset of each descriptor. - * - * Returns 0 on success and -1 on failure. Adds a digest to - * <b>invalid_digests_out</b> for every entry that was unparseable or - * invalid. (This may cause duplicate entries.) - */ -int -router_parse_list_from_string(const char **s, const char *eos, - smartlist_t *dest, - saved_location_t saved_location, - int want_extrainfo, - int allow_annotations, - const char *prepend_annotations, - smartlist_t *invalid_digests_out) -{ - routerinfo_t *router; - extrainfo_t *extrainfo; - signed_descriptor_t *signed_desc = NULL; - void *elt; - const char *end, *start; - int have_extrainfo; - - tor_assert(s); - tor_assert(*s); - tor_assert(dest); - - start = *s; - if (!eos) - eos = *s + strlen(*s); - - tor_assert(eos >= *s); - - while (1) { - char raw_digest[DIGEST_LEN]; - int have_raw_digest = 0; - int dl_again = 0; - if (find_start_of_next_router_or_extrainfo(s, eos, &have_extrainfo) < 0) - break; - - end = tor_memstr(*s, eos-*s, "\nrouter-signature"); - if (end) - end = tor_memstr(end, eos-end, "\n-----END SIGNATURE-----\n"); - if (end) - end += strlen("\n-----END SIGNATURE-----\n"); - - if (!end) - break; - - elt = NULL; - - if (have_extrainfo && want_extrainfo) { - routerlist_t *rl = router_get_routerlist(); - have_raw_digest = router_get_extrainfo_hash(*s, end-*s, raw_digest) == 0; - extrainfo = extrainfo_parse_entry_from_string(*s, end, - saved_location != SAVED_IN_CACHE, - rl->identity_map, &dl_again); - if (extrainfo) { - signed_desc = &extrainfo->cache_info; - elt = extrainfo; - } - } else if (!have_extrainfo && !want_extrainfo) { - have_raw_digest = router_get_router_hash(*s, end-*s, raw_digest) == 0; - router = router_parse_entry_from_string(*s, end, - saved_location != SAVED_IN_CACHE, - allow_annotations, - prepend_annotations, &dl_again); - if (router) { - log_debug(LD_DIR, "Read router '%s', purpose '%s'", - router_describe(router), - router_purpose_to_string(router->purpose)); - signed_desc = &router->cache_info; - elt = router; - } - } - if (! elt && ! dl_again && have_raw_digest && invalid_digests_out) { - smartlist_add(invalid_digests_out, tor_memdup(raw_digest, DIGEST_LEN)); - } - if (!elt) { - *s = end; - continue; - } - if (saved_location != SAVED_NOWHERE) { - tor_assert(signed_desc); - signed_desc->saved_location = saved_location; - signed_desc->saved_offset = *s - start; - } - *s = end; - smartlist_add(dest, elt); - } - - return 0; -} - -/* For debugging: define to count every descriptor digest we've seen so we - * know if we need to try harder to avoid duplicate verifies. */ -#undef COUNT_DISTINCT_DIGESTS - -#ifdef COUNT_DISTINCT_DIGESTS -static digestmap_t *verified_digests = NULL; -#endif - -/** Log the total count of the number of distinct router digests we've ever - * verified. When compared to the number of times we've verified routerdesc - * signatures <i>in toto</i>, this will tell us if we're doing too much - * multiple-verification. */ -void -dump_distinct_digest_count(int severity) -{ -#ifdef COUNT_DISTINCT_DIGESTS - if (!verified_digests) - verified_digests = digestmap_new(); - tor_log(severity, LD_GENERAL, "%d *distinct* router digests verified", - digestmap_size(verified_digests)); -#else /* !(defined(COUNT_DISTINCT_DIGESTS)) */ - (void)severity; /* suppress "unused parameter" warning */ -#endif /* defined(COUNT_DISTINCT_DIGESTS) */ -} - -/** Try to find an IPv6 OR port in <b>list</b> of directory_token_t's - * with at least one argument (use GE(1) in setup). If found, store - * address and port number to <b>addr_out</b> and - * <b>port_out</b>. Return number of OR ports found. */ -static int -find_single_ipv6_orport(const smartlist_t *list, - tor_addr_t *addr_out, - uint16_t *port_out) -{ - int ret = 0; - tor_assert(list != NULL); - tor_assert(addr_out != NULL); - tor_assert(port_out != NULL); - - SMARTLIST_FOREACH_BEGIN(list, directory_token_t *, t) { - tor_addr_t a; - maskbits_t bits; - uint16_t port_min, port_max; - tor_assert(t->n_args >= 1); - /* XXXX Prop186 the full spec allows much more than this. */ - if (tor_addr_parse_mask_ports(t->args[0], 0, - &a, &bits, &port_min, - &port_max) == AF_INET6 && - bits == 128 && - port_min == port_max) { - /* Okay, this is one we can understand. Use it and ignore - any potential more addresses in list. */ - tor_addr_copy(addr_out, &a); - *port_out = port_min; - ret = 1; - break; - } - } SMARTLIST_FOREACH_END(t); - - return ret; -} - -/** Helper function: reads a single router entry from *<b>s</b> ... - * *<b>end</b>. Mallocs a new router and returns it if all goes well, else - * returns NULL. If <b>cache_copy</b> is true, duplicate the contents of - * s through end into the signed_descriptor_body of the resulting - * routerinfo_t. - * - * If <b>end</b> is NULL, <b>s</b> must be properly NUL-terminated. - * - * If <b>allow_annotations</b>, it's okay to encounter annotations in <b>s</b> - * before the router; if it's false, reject the router if it's annotated. If - * <b>prepend_annotations</b> is set, it should contain some annotations: - * append them to the front of the router before parsing it, and keep them - * around when caching the router. - * - * Only one of allow_annotations and prepend_annotations may be set. - * - * If <b>can_dl_again_out</b> is provided, set *<b>can_dl_again_out</b> to 1 - * if it's okay to try to download a descriptor with this same digest again, - * and 0 if it isn't. (It might not be okay to download it again if part of - * the part covered by the digest is invalid.) - */ -routerinfo_t * -router_parse_entry_from_string(const char *s, const char *end, - int cache_copy, int allow_annotations, - const char *prepend_annotations, - int *can_dl_again_out) -{ - routerinfo_t *router = NULL; - char digest[128]; - smartlist_t *tokens = NULL, *exit_policy_tokens = NULL; - directory_token_t *tok; - struct in_addr in; - const char *start_of_annotations, *cp, *s_dup = s; - size_t prepend_len = prepend_annotations ? strlen(prepend_annotations) : 0; - int ok = 1; - memarea_t *area = NULL; - tor_cert_t *ntor_cc_cert = NULL; - /* Do not set this to '1' until we have parsed everything that we intend to - * parse that's covered by the hash. */ - int can_dl_again = 0; - crypto_pk_t *rsa_pubkey = NULL; - - tor_assert(!allow_annotations || !prepend_annotations); - - if (!end) { - end = s + strlen(s); - } - - /* point 'end' to a point immediately after the final newline. */ - while (end > s+2 && *(end-1) == '\n' && *(end-2) == '\n') - --end; - - area = memarea_new(); - tokens = smartlist_new(); - if (prepend_annotations) { - if (tokenize_string(area,prepend_annotations,NULL,tokens, - routerdesc_token_table,TS_NOCHECK)) { - log_warn(LD_DIR, "Error tokenizing router descriptor (annotations)."); - goto err; - } - } - - start_of_annotations = s; - cp = tor_memstr(s, end-s, "\nrouter "); - if (!cp) { - if (end-s < 7 || strcmpstart(s, "router ")) { - log_warn(LD_DIR, "No router keyword found."); - goto err; - } - } else { - s = cp+1; - } - - if (start_of_annotations != s) { /* We have annotations */ - if (allow_annotations) { - if (tokenize_string(area,start_of_annotations,s,tokens, - routerdesc_token_table,TS_NOCHECK)) { - log_warn(LD_DIR, "Error tokenizing router descriptor (annotations)."); - goto err; - } - } else { - log_warn(LD_DIR, "Found unexpected annotations on router descriptor not " - "loaded from disk. Dropping it."); - goto err; - } - } - - if (router_get_router_hash(s, end - s, digest) < 0) { - log_warn(LD_DIR, "Couldn't compute router hash."); - goto err; - } - { - int flags = 0; - if (allow_annotations) - flags |= TS_ANNOTATIONS_OK; - if (prepend_annotations) - flags |= TS_ANNOTATIONS_OK|TS_NO_NEW_ANNOTATIONS; - - if (tokenize_string(area,s,end,tokens,routerdesc_token_table, flags)) { - log_warn(LD_DIR, "Error tokenizing router descriptor."); - goto err; - } - } - - if (smartlist_len(tokens) < 2) { - log_warn(LD_DIR, "Impossibly short router descriptor."); - goto err; - } - - tok = find_by_keyword(tokens, K_ROUTER); - const int router_token_pos = smartlist_pos(tokens, tok); - tor_assert(tok->n_args >= 5); - - router = tor_malloc_zero(sizeof(routerinfo_t)); - router->cert_expiration_time = TIME_MAX; - router->cache_info.routerlist_index = -1; - router->cache_info.annotations_len = s-start_of_annotations + prepend_len; - router->cache_info.signed_descriptor_len = end-s; - if (cache_copy) { - size_t len = router->cache_info.signed_descriptor_len + - router->cache_info.annotations_len; - char *signed_body = - router->cache_info.signed_descriptor_body = tor_malloc(len+1); - if (prepend_annotations) { - memcpy(signed_body, prepend_annotations, prepend_len); - signed_body += prepend_len; - } - /* This assertion will always succeed. - * len == signed_desc_len + annotations_len - * == end-s + s-start_of_annotations + prepend_len - * == end-start_of_annotations + prepend_len - * We already wrote prepend_len bytes into the buffer; now we're - * writing end-start_of_annotations -NM. */ - tor_assert(signed_body+(end-start_of_annotations) == - router->cache_info.signed_descriptor_body+len); - memcpy(signed_body, start_of_annotations, end-start_of_annotations); - router->cache_info.signed_descriptor_body[len] = '\0'; - tor_assert(strlen(router->cache_info.signed_descriptor_body) == len); - } - memcpy(router->cache_info.signed_descriptor_digest, digest, DIGEST_LEN); - - router->nickname = tor_strdup(tok->args[0]); - if (!is_legal_nickname(router->nickname)) { - log_warn(LD_DIR,"Router nickname is invalid"); - goto err; - } - if (!tor_inet_aton(tok->args[1], &in)) { - log_warn(LD_DIR,"Router address is not an IP address."); - goto err; - } - router->addr = ntohl(in.s_addr); - - router->or_port = - (uint16_t) tor_parse_long(tok->args[2],10,0,65535,&ok,NULL); - if (!ok) { - log_warn(LD_DIR,"Invalid OR port %s", escaped(tok->args[2])); - goto err; - } - router->dir_port = - (uint16_t) tor_parse_long(tok->args[4],10,0,65535,&ok,NULL); - if (!ok) { - log_warn(LD_DIR,"Invalid dir port %s", escaped(tok->args[4])); - goto err; - } - - tok = find_by_keyword(tokens, K_BANDWIDTH); - tor_assert(tok->n_args >= 3); - router->bandwidthrate = (int) - tor_parse_long(tok->args[0],10,1,INT_MAX,&ok,NULL); - - if (!ok) { - log_warn(LD_DIR, "bandwidthrate %s unreadable or 0. Failing.", - escaped(tok->args[0])); - goto err; - } - router->bandwidthburst = - (int) tor_parse_long(tok->args[1],10,0,INT_MAX,&ok,NULL); - if (!ok) { - log_warn(LD_DIR, "Invalid bandwidthburst %s", escaped(tok->args[1])); - goto err; - } - router->bandwidthcapacity = (int) - tor_parse_long(tok->args[2],10,0,INT_MAX,&ok,NULL); - if (!ok) { - log_warn(LD_DIR, "Invalid bandwidthcapacity %s", escaped(tok->args[1])); - goto err; - } - - if ((tok = find_opt_by_keyword(tokens, A_PURPOSE))) { - tor_assert(tok->n_args); - router->purpose = router_purpose_from_string(tok->args[0]); - } else { - router->purpose = ROUTER_PURPOSE_GENERAL; - } - router->cache_info.send_unencrypted = - (router->purpose == ROUTER_PURPOSE_GENERAL) ? 1 : 0; - - if ((tok = find_opt_by_keyword(tokens, K_UPTIME))) { - tor_assert(tok->n_args >= 1); - router->uptime = tor_parse_long(tok->args[0],10,0,LONG_MAX,&ok,NULL); - if (!ok) { - log_warn(LD_DIR, "Invalid uptime %s", escaped(tok->args[0])); - goto err; - } - } - - if ((tok = find_opt_by_keyword(tokens, K_HIBERNATING))) { - tor_assert(tok->n_args >= 1); - router->is_hibernating - = (tor_parse_long(tok->args[0],10,0,LONG_MAX,NULL,NULL) != 0); - } - - tok = find_by_keyword(tokens, K_PUBLISHED); - tor_assert(tok->n_args == 1); - if (parse_iso_time(tok->args[0], &router->cache_info.published_on) < 0) - goto err; - - tok = find_by_keyword(tokens, K_ONION_KEY); - if (!crypto_pk_public_exponent_ok(tok->key)) { - log_warn(LD_DIR, - "Relay's onion key had invalid exponent."); - goto err; - } - router_set_rsa_onion_pkey(tok->key, &router->onion_pkey, - &router->onion_pkey_len); - crypto_pk_free(tok->key); - - if ((tok = find_opt_by_keyword(tokens, K_ONION_KEY_NTOR))) { - curve25519_public_key_t k; - tor_assert(tok->n_args >= 1); - if (curve25519_public_from_base64(&k, tok->args[0]) < 0) { - log_warn(LD_DIR, "Bogus ntor-onion-key in routerinfo"); - goto err; - } - router->onion_curve25519_pkey = - tor_memdup(&k, sizeof(curve25519_public_key_t)); - } - - tok = find_by_keyword(tokens, K_SIGNING_KEY); - router->identity_pkey = tok->key; - tok->key = NULL; /* Prevent free */ - if (crypto_pk_get_digest(router->identity_pkey, - router->cache_info.identity_digest)) { - log_warn(LD_DIR, "Couldn't calculate key digest"); goto err; - } - - { - directory_token_t *ed_sig_tok, *ed_cert_tok, *cc_tap_tok, *cc_ntor_tok, - *master_key_tok; - ed_sig_tok = find_opt_by_keyword(tokens, K_ROUTER_SIG_ED25519); - ed_cert_tok = find_opt_by_keyword(tokens, K_IDENTITY_ED25519); - master_key_tok = find_opt_by_keyword(tokens, K_MASTER_KEY_ED25519); - cc_tap_tok = find_opt_by_keyword(tokens, K_ONION_KEY_CROSSCERT); - cc_ntor_tok = find_opt_by_keyword(tokens, K_NTOR_ONION_KEY_CROSSCERT); - int n_ed_toks = !!ed_sig_tok + !!ed_cert_tok + - !!cc_tap_tok + !!cc_ntor_tok; - if ((n_ed_toks != 0 && n_ed_toks != 4) || - (n_ed_toks == 4 && !router->onion_curve25519_pkey)) { - log_warn(LD_DIR, "Router descriptor with only partial ed25519/" - "cross-certification support"); - goto err; - } - if (master_key_tok && !ed_sig_tok) { - log_warn(LD_DIR, "Router descriptor has ed25519 master key but no " - "certificate"); - goto err; - } - if (ed_sig_tok) { - tor_assert(ed_cert_tok && cc_tap_tok && cc_ntor_tok); - const int ed_cert_token_pos = smartlist_pos(tokens, ed_cert_tok); - if (ed_cert_token_pos == -1 || router_token_pos == -1 || - (ed_cert_token_pos != router_token_pos + 1 && - ed_cert_token_pos != router_token_pos - 1)) { - log_warn(LD_DIR, "Ed25519 certificate in wrong position"); - goto err; - } - if (ed_sig_tok != smartlist_get(tokens, smartlist_len(tokens)-2)) { - log_warn(LD_DIR, "Ed25519 signature in wrong position"); - goto err; - } - if (strcmp(ed_cert_tok->object_type, "ED25519 CERT")) { - log_warn(LD_DIR, "Wrong object type on identity-ed25519 in decriptor"); - goto err; - } - if (strcmp(cc_ntor_tok->object_type, "ED25519 CERT")) { - log_warn(LD_DIR, "Wrong object type on ntor-onion-key-crosscert " - "in decriptor"); - goto err; - } - if (strcmp(cc_tap_tok->object_type, "CROSSCERT")) { - log_warn(LD_DIR, "Wrong object type on onion-key-crosscert " - "in decriptor"); - goto err; - } - if (strcmp(cc_ntor_tok->args[0], "0") && - strcmp(cc_ntor_tok->args[0], "1")) { - log_warn(LD_DIR, "Bad sign bit on ntor-onion-key-crosscert"); - goto err; - } - int ntor_cc_sign_bit = !strcmp(cc_ntor_tok->args[0], "1"); - - uint8_t d256[DIGEST256_LEN]; - const char *signed_start, *signed_end; - tor_cert_t *cert = tor_cert_parse( - (const uint8_t*)ed_cert_tok->object_body, - ed_cert_tok->object_size); - if (! cert) { - log_warn(LD_DIR, "Couldn't parse ed25519 cert"); - goto err; - } - /* makes sure it gets freed. */ - router->cache_info.signing_key_cert = cert; - - if (cert->cert_type != CERT_TYPE_ID_SIGNING || - ! cert->signing_key_included) { - log_warn(LD_DIR, "Invalid form for ed25519 cert"); - goto err; - } - - if (master_key_tok) { - /* This token is optional, but if it's present, it must match - * the signature in the signing cert, or supplant it. */ - tor_assert(master_key_tok->n_args >= 1); - ed25519_public_key_t pkey; - if (ed25519_public_from_base64(&pkey, master_key_tok->args[0])<0) { - log_warn(LD_DIR, "Can't parse ed25519 master key"); - goto err; - } - - if (fast_memneq(&cert->signing_key.pubkey, - pkey.pubkey, ED25519_PUBKEY_LEN)) { - log_warn(LD_DIR, "Ed25519 master key does not match " - "key in certificate"); - goto err; - } - } - ntor_cc_cert = tor_cert_parse((const uint8_t*)cc_ntor_tok->object_body, - cc_ntor_tok->object_size); - if (!ntor_cc_cert) { - log_warn(LD_DIR, "Couldn't parse ntor-onion-key-crosscert cert"); - goto err; - } - if (ntor_cc_cert->cert_type != CERT_TYPE_ONION_ID || - ! ed25519_pubkey_eq(&ntor_cc_cert->signed_key, &cert->signing_key)) { - log_warn(LD_DIR, "Invalid contents for ntor-onion-key-crosscert cert"); - goto err; - } - - ed25519_public_key_t ntor_cc_pk; - if (ed25519_public_key_from_curve25519_public_key(&ntor_cc_pk, - router->onion_curve25519_pkey, - ntor_cc_sign_bit)<0) { - log_warn(LD_DIR, "Error converting onion key to ed25519"); - goto err; - } - - if (router_get_hash_impl_helper(s, end-s, "router ", - "\nrouter-sig-ed25519", - ' ', LOG_WARN, - &signed_start, &signed_end) < 0) { - log_warn(LD_DIR, "Can't find ed25519-signed portion of descriptor"); - goto err; - } - crypto_digest_t *d = crypto_digest256_new(DIGEST_SHA256); - crypto_digest_add_bytes(d, ED_DESC_SIGNATURE_PREFIX, - strlen(ED_DESC_SIGNATURE_PREFIX)); - crypto_digest_add_bytes(d, signed_start, signed_end-signed_start); - crypto_digest_get_digest(d, (char*)d256, sizeof(d256)); - crypto_digest_free(d); - - ed25519_checkable_t check[3]; - int check_ok[3]; - time_t expires = TIME_MAX; - if (tor_cert_get_checkable_sig(&check[0], cert, NULL, &expires) < 0) { - log_err(LD_BUG, "Couldn't create 'checkable' for cert."); - goto err; - } - if (tor_cert_get_checkable_sig(&check[1], - ntor_cc_cert, &ntor_cc_pk, &expires) < 0) { - log_err(LD_BUG, "Couldn't create 'checkable' for ntor_cc_cert."); - goto err; - } - - if (ed25519_signature_from_base64(&check[2].signature, - ed_sig_tok->args[0])<0) { - log_warn(LD_DIR, "Couldn't decode ed25519 signature"); - goto err; - } - check[2].pubkey = &cert->signed_key; - check[2].msg = d256; - check[2].len = DIGEST256_LEN; - - if (ed25519_checksig_batch(check_ok, check, 3) < 0) { - log_warn(LD_DIR, "Incorrect ed25519 signature(s)"); - goto err; - } - - rsa_pubkey = router_get_rsa_onion_pkey(router->onion_pkey, - router->onion_pkey_len); - if (check_tap_onion_key_crosscert( - (const uint8_t*)cc_tap_tok->object_body, - (int)cc_tap_tok->object_size, - rsa_pubkey, - &cert->signing_key, - (const uint8_t*)router->cache_info.identity_digest)<0) { - log_warn(LD_DIR, "Incorrect TAP cross-verification"); - goto err; - } - - /* We check this before adding it to the routerlist. */ - router->cert_expiration_time = expires; - } - } - - if ((tok = find_opt_by_keyword(tokens, K_FINGERPRINT))) { - /* If there's a fingerprint line, it must match the identity digest. */ - char d[DIGEST_LEN]; - tor_assert(tok->n_args == 1); - tor_strstrip(tok->args[0], " "); - if (base16_decode(d, DIGEST_LEN, - tok->args[0], strlen(tok->args[0])) != DIGEST_LEN) { - log_warn(LD_DIR, "Couldn't decode router fingerprint %s", - escaped(tok->args[0])); - goto err; - } - if (tor_memneq(d,router->cache_info.identity_digest, DIGEST_LEN)) { - log_warn(LD_DIR, "Fingerprint '%s' does not match identity digest.", - tok->args[0]); - goto err; - } - } - - { - const char *version = NULL, *protocols = NULL; - if ((tok = find_opt_by_keyword(tokens, K_PLATFORM))) { - router->platform = tor_strdup(tok->args[0]); - version = tok->args[0]; - } - - if ((tok = find_opt_by_keyword(tokens, K_PROTO))) { - router->protocol_list = tor_strdup(tok->args[0]); - protocols = tok->args[0]; - } - - summarize_protover_flags(&router->pv, protocols, version); - } - - if ((tok = find_opt_by_keyword(tokens, K_CONTACT))) { - router->contact_info = tor_strdup(tok->args[0]); - } - - if (find_opt_by_keyword(tokens, K_REJECT6) || - find_opt_by_keyword(tokens, K_ACCEPT6)) { - log_warn(LD_DIR, "Rejecting router with reject6/accept6 line: they crash " - "older Tors."); - goto err; - } - { - smartlist_t *or_addresses = find_all_by_keyword(tokens, K_OR_ADDRESS); - if (or_addresses) { - find_single_ipv6_orport(or_addresses, &router->ipv6_addr, - &router->ipv6_orport); - smartlist_free(or_addresses); - } - } - exit_policy_tokens = find_all_exitpolicy(tokens); - if (!smartlist_len(exit_policy_tokens)) { - log_warn(LD_DIR, "No exit policy tokens in descriptor."); - goto err; - } - SMARTLIST_FOREACH(exit_policy_tokens, directory_token_t *, t, - if (router_add_exit_policy(router,t)<0) { - log_warn(LD_DIR,"Error in exit policy"); - goto err; - }); - policy_expand_private(&router->exit_policy); - - if ((tok = find_opt_by_keyword(tokens, K_IPV6_POLICY)) && tok->n_args) { - router->ipv6_exit_policy = parse_short_policy(tok->args[0]); - if (! router->ipv6_exit_policy) { - log_warn(LD_DIR , "Error in ipv6-policy %s", escaped(tok->args[0])); - goto err; - } - } - - if (policy_is_reject_star(router->exit_policy, AF_INET, 1) && - (!router->ipv6_exit_policy || - short_policy_is_reject_star(router->ipv6_exit_policy))) - router->policy_is_reject_star = 1; - - if ((tok = find_opt_by_keyword(tokens, K_FAMILY)) && tok->n_args) { - int i; - router->declared_family = smartlist_new(); - for (i=0;i<tok->n_args;++i) { - if (!is_legal_nickname_or_hexdigest(tok->args[i])) { - log_warn(LD_DIR, "Illegal nickname %s in family line", - escaped(tok->args[i])); - goto err; - } - smartlist_add_strdup(router->declared_family, tok->args[i]); - } - } - - if (find_opt_by_keyword(tokens, K_CACHES_EXTRA_INFO)) - router->caches_extra_info = 1; - - if (find_opt_by_keyword(tokens, K_ALLOW_SINGLE_HOP_EXITS)) - router->allow_single_hop_exits = 1; - - if ((tok = find_opt_by_keyword(tokens, K_EXTRA_INFO_DIGEST))) { - tor_assert(tok->n_args >= 1); - if (strlen(tok->args[0]) == HEX_DIGEST_LEN) { - if (base16_decode(router->cache_info.extra_info_digest, DIGEST_LEN, - tok->args[0], HEX_DIGEST_LEN) != DIGEST_LEN) { - log_warn(LD_DIR,"Invalid extra info digest"); - } - } else { - log_warn(LD_DIR, "Invalid extra info digest %s", escaped(tok->args[0])); - } - - if (tok->n_args >= 2) { - if (digest256_from_base64(router->cache_info.extra_info_digest256, - tok->args[1]) < 0) { - log_warn(LD_DIR, "Invalid extra info digest256 %s", - escaped(tok->args[1])); - } - } - } - - if (find_opt_by_keyword(tokens, K_HIDDEN_SERVICE_DIR)) { - router->wants_to_be_hs_dir = 1; - } - - /* This router accepts tunnelled directory requests via begindir if it has - * an open dirport or it included "tunnelled-dir-server". */ - if (find_opt_by_keyword(tokens, K_DIR_TUNNELLED) || router->dir_port > 0) { - router->supports_tunnelled_dir_requests = 1; - } - - tok = find_by_keyword(tokens, K_ROUTER_SIGNATURE); -#ifdef COUNT_DISTINCT_DIGESTS - if (!verified_digests) - verified_digests = digestmap_new(); - digestmap_set(verified_digests, signed_digest, (void*)(uintptr_t)1); -#endif - - if (!router->or_port) { - log_warn(LD_DIR,"or_port unreadable or 0. Failing."); - goto err; - } - - /* We've checked everything that's covered by the hash. */ - can_dl_again = 1; - if (check_signature_token(digest, DIGEST_LEN, tok, router->identity_pkey, 0, - "router descriptor") < 0) - goto err; - - if (!router->platform) { - router->platform = tor_strdup("<unknown>"); - } - goto done; - - err: - dump_desc(s_dup, "router descriptor"); - routerinfo_free(router); - router = NULL; - done: - crypto_pk_free(rsa_pubkey); - tor_cert_free(ntor_cc_cert); - if (tokens) { - SMARTLIST_FOREACH(tokens, directory_token_t *, t, token_clear(t)); - smartlist_free(tokens); - } - smartlist_free(exit_policy_tokens); - if (area) { - DUMP_AREA(area, "routerinfo"); - memarea_drop_all(area); - } - if (can_dl_again_out) - *can_dl_again_out = can_dl_again; - return router; -} - -/** Parse a single extrainfo entry from the string <b>s</b>, ending at - * <b>end</b>. (If <b>end</b> is NULL, parse up to the end of <b>s</b>.) If - * <b>cache_copy</b> is true, make a copy of the extra-info document in the - * cache_info fields of the result. If <b>routermap</b> is provided, use it - * as a map from router identity to routerinfo_t when looking up signing keys. - * - * If <b>can_dl_again_out</b> is provided, set *<b>can_dl_again_out</b> to 1 - * if it's okay to try to download an extrainfo with this same digest again, - * and 0 if it isn't. (It might not be okay to download it again if part of - * the part covered by the digest is invalid.) - */ -extrainfo_t * -extrainfo_parse_entry_from_string(const char *s, const char *end, - int cache_copy, struct digest_ri_map_t *routermap, - int *can_dl_again_out) -{ - extrainfo_t *extrainfo = NULL; - char digest[128]; - smartlist_t *tokens = NULL; - directory_token_t *tok; - crypto_pk_t *key = NULL; - routerinfo_t *router = NULL; - memarea_t *area = NULL; - const char *s_dup = s; - /* Do not set this to '1' until we have parsed everything that we intend to - * parse that's covered by the hash. */ - int can_dl_again = 0; - - if (BUG(s == NULL)) - return NULL; - - if (!end) { - end = s + strlen(s); - } - - /* point 'end' to a point immediately after the final newline. */ - while (end > s+2 && *(end-1) == '\n' && *(end-2) == '\n') - --end; - - if (router_get_extrainfo_hash(s, end-s, digest) < 0) { - log_warn(LD_DIR, "Couldn't compute router hash."); - goto err; - } - tokens = smartlist_new(); - area = memarea_new(); - if (tokenize_string(area,s,end,tokens,extrainfo_token_table,0)) { - log_warn(LD_DIR, "Error tokenizing extra-info document."); - goto err; - } - - if (smartlist_len(tokens) < 2) { - log_warn(LD_DIR, "Impossibly short extra-info document."); - goto err; - } - - /* XXXX Accept this in position 1 too, and ed identity in position 0. */ - tok = smartlist_get(tokens,0); - if (tok->tp != K_EXTRA_INFO) { - log_warn(LD_DIR,"Entry does not start with \"extra-info\""); - goto err; - } - - extrainfo = tor_malloc_zero(sizeof(extrainfo_t)); - extrainfo->cache_info.is_extrainfo = 1; - if (cache_copy) - extrainfo->cache_info.signed_descriptor_body = tor_memdup_nulterm(s,end-s); - extrainfo->cache_info.signed_descriptor_len = end-s; - memcpy(extrainfo->cache_info.signed_descriptor_digest, digest, DIGEST_LEN); - crypto_digest256((char*)extrainfo->digest256, s, end-s, DIGEST_SHA256); - - tor_assert(tok->n_args >= 2); - if (!is_legal_nickname(tok->args[0])) { - log_warn(LD_DIR,"Bad nickname %s on \"extra-info\"",escaped(tok->args[0])); - goto err; - } - strlcpy(extrainfo->nickname, tok->args[0], sizeof(extrainfo->nickname)); - if (strlen(tok->args[1]) != HEX_DIGEST_LEN || - base16_decode(extrainfo->cache_info.identity_digest, DIGEST_LEN, - tok->args[1], HEX_DIGEST_LEN) != DIGEST_LEN) { - log_warn(LD_DIR,"Invalid fingerprint %s on \"extra-info\"", - escaped(tok->args[1])); - goto err; - } - - tok = find_by_keyword(tokens, K_PUBLISHED); - if (parse_iso_time(tok->args[0], &extrainfo->cache_info.published_on)) { - log_warn(LD_DIR,"Invalid published time %s on \"extra-info\"", - escaped(tok->args[0])); - goto err; - } - - { - directory_token_t *ed_sig_tok, *ed_cert_tok; - ed_sig_tok = find_opt_by_keyword(tokens, K_ROUTER_SIG_ED25519); - ed_cert_tok = find_opt_by_keyword(tokens, K_IDENTITY_ED25519); - int n_ed_toks = !!ed_sig_tok + !!ed_cert_tok; - if (n_ed_toks != 0 && n_ed_toks != 2) { - log_warn(LD_DIR, "Router descriptor with only partial ed25519/" - "cross-certification support"); - goto err; - } - if (ed_sig_tok) { - tor_assert(ed_cert_tok); - const int ed_cert_token_pos = smartlist_pos(tokens, ed_cert_tok); - if (ed_cert_token_pos != 1) { - /* Accept this in position 0 XXXX */ - log_warn(LD_DIR, "Ed25519 certificate in wrong position"); - goto err; - } - if (ed_sig_tok != smartlist_get(tokens, smartlist_len(tokens)-2)) { - log_warn(LD_DIR, "Ed25519 signature in wrong position"); - goto err; - } - if (strcmp(ed_cert_tok->object_type, "ED25519 CERT")) { - log_warn(LD_DIR, "Wrong object type on identity-ed25519 in decriptor"); - goto err; - } - - uint8_t d256[DIGEST256_LEN]; - const char *signed_start, *signed_end; - tor_cert_t *cert = tor_cert_parse( - (const uint8_t*)ed_cert_tok->object_body, - ed_cert_tok->object_size); - if (! cert) { - log_warn(LD_DIR, "Couldn't parse ed25519 cert"); - goto err; - } - /* makes sure it gets freed. */ - extrainfo->cache_info.signing_key_cert = cert; - - if (cert->cert_type != CERT_TYPE_ID_SIGNING || - ! cert->signing_key_included) { - log_warn(LD_DIR, "Invalid form for ed25519 cert"); - goto err; - } - - if (router_get_hash_impl_helper(s, end-s, "extra-info ", - "\nrouter-sig-ed25519", - ' ', LOG_WARN, - &signed_start, &signed_end) < 0) { - log_warn(LD_DIR, "Can't find ed25519-signed portion of extrainfo"); - goto err; - } - crypto_digest_t *d = crypto_digest256_new(DIGEST_SHA256); - crypto_digest_add_bytes(d, ED_DESC_SIGNATURE_PREFIX, - strlen(ED_DESC_SIGNATURE_PREFIX)); - crypto_digest_add_bytes(d, signed_start, signed_end-signed_start); - crypto_digest_get_digest(d, (char*)d256, sizeof(d256)); - crypto_digest_free(d); - - ed25519_checkable_t check[2]; - int check_ok[2]; - if (tor_cert_get_checkable_sig(&check[0], cert, NULL, NULL) < 0) { - log_err(LD_BUG, "Couldn't create 'checkable' for cert."); - goto err; - } - - if (ed25519_signature_from_base64(&check[1].signature, - ed_sig_tok->args[0])<0) { - log_warn(LD_DIR, "Couldn't decode ed25519 signature"); - goto err; - } - check[1].pubkey = &cert->signed_key; - check[1].msg = d256; - check[1].len = DIGEST256_LEN; - - if (ed25519_checksig_batch(check_ok, check, 2) < 0) { - log_warn(LD_DIR, "Incorrect ed25519 signature(s)"); - goto err; - } - /* We don't check the certificate expiration time: checking that it - * matches the cert in the router descriptor is adequate. */ - } - } - - /* We've checked everything that's covered by the hash. */ - can_dl_again = 1; - - if (routermap && - (router = digestmap_get((digestmap_t*)routermap, - extrainfo->cache_info.identity_digest))) { - key = router->identity_pkey; - } - - tok = find_by_keyword(tokens, K_ROUTER_SIGNATURE); - if (strcmp(tok->object_type, "SIGNATURE") || - tok->object_size < 128 || tok->object_size > 512) { - log_warn(LD_DIR, "Bad object type or length on extra-info signature"); - goto err; - } - - if (key) { - if (check_signature_token(digest, DIGEST_LEN, tok, key, 0, - "extra-info") < 0) - goto err; - - if (router) - extrainfo->cache_info.send_unencrypted = - router->cache_info.send_unencrypted; - } else { - extrainfo->pending_sig = tor_memdup(tok->object_body, - tok->object_size); - extrainfo->pending_sig_len = tok->object_size; - } - - goto done; - err: - dump_desc(s_dup, "extra-info descriptor"); - extrainfo_free(extrainfo); - extrainfo = NULL; - done: - if (tokens) { - SMARTLIST_FOREACH(tokens, directory_token_t *, t, token_clear(t)); - smartlist_free(tokens); - } - if (area) { - DUMP_AREA(area, "extrainfo"); - memarea_drop_all(area); - } - if (can_dl_again_out) - *can_dl_again_out = can_dl_again; - return extrainfo; -} - -/** Parse a key certificate from <b>s</b>; point <b>end-of-string</b> to - * the first character after the certificate. */ -authority_cert_t * -authority_cert_parse_from_string(const char *s, const char **end_of_string) -{ - /** Reject any certificate at least this big; it is probably an overflow, an - * attack, a bug, or some other nonsense. */ -#define MAX_CERT_SIZE (128*1024) - - authority_cert_t *cert = NULL, *old_cert; - smartlist_t *tokens = NULL; - char digest[DIGEST_LEN]; - directory_token_t *tok; - char fp_declared[DIGEST_LEN]; - char *eos; - size_t len; - int found; - memarea_t *area = NULL; - const char *s_dup = s; - - s = eat_whitespace(s); - eos = strstr(s, "\ndir-key-certification"); - if (! eos) { - log_warn(LD_DIR, "No signature found on key certificate"); - return NULL; - } - eos = strstr(eos, "\n-----END SIGNATURE-----\n"); - if (! eos) { - log_warn(LD_DIR, "No end-of-signature found on key certificate"); - return NULL; - } - eos = strchr(eos+2, '\n'); - tor_assert(eos); - ++eos; - len = eos - s; - - if (len > MAX_CERT_SIZE) { - log_warn(LD_DIR, "Certificate is far too big (at %lu bytes long); " - "rejecting", (unsigned long)len); - return NULL; - } - - tokens = smartlist_new(); - area = memarea_new(); - if (tokenize_string(area,s, eos, tokens, dir_key_certificate_table, 0) < 0) { - log_warn(LD_DIR, "Error tokenizing key certificate"); - goto err; - } - if (router_get_hash_impl(s, strlen(s), digest, "dir-key-certificate-version", - "\ndir-key-certification", '\n', DIGEST_SHA1) < 0) - goto err; - tok = smartlist_get(tokens, 0); - if (tok->tp != K_DIR_KEY_CERTIFICATE_VERSION || strcmp(tok->args[0], "3")) { - log_warn(LD_DIR, - "Key certificate does not begin with a recognized version (3)."); - goto err; - } - - cert = tor_malloc_zero(sizeof(authority_cert_t)); - memcpy(cert->cache_info.signed_descriptor_digest, digest, DIGEST_LEN); - - tok = find_by_keyword(tokens, K_DIR_SIGNING_KEY); - tor_assert(tok->key); - cert->signing_key = tok->key; - tok->key = NULL; - if (crypto_pk_get_digest(cert->signing_key, cert->signing_key_digest)) - goto err; - - tok = find_by_keyword(tokens, K_DIR_IDENTITY_KEY); - tor_assert(tok->key); - cert->identity_key = tok->key; - tok->key = NULL; - - tok = find_by_keyword(tokens, K_FINGERPRINT); - tor_assert(tok->n_args); - if (base16_decode(fp_declared, DIGEST_LEN, tok->args[0], - strlen(tok->args[0])) != DIGEST_LEN) { - log_warn(LD_DIR, "Couldn't decode key certificate fingerprint %s", - escaped(tok->args[0])); - goto err; - } - - if (crypto_pk_get_digest(cert->identity_key, - cert->cache_info.identity_digest)) - goto err; - - if (tor_memneq(cert->cache_info.identity_digest, fp_declared, DIGEST_LEN)) { - log_warn(LD_DIR, "Digest of certificate key didn't match declared " - "fingerprint"); - goto err; - } - - tok = find_opt_by_keyword(tokens, K_DIR_ADDRESS); - if (tok) { - struct in_addr in; - char *address = NULL; - tor_assert(tok->n_args); - /* XXX++ use some tor_addr parse function below instead. -RD */ - if (tor_addr_port_split(LOG_WARN, tok->args[0], &address, - &cert->dir_port) < 0 || - tor_inet_aton(address, &in) == 0) { - log_warn(LD_DIR, "Couldn't parse dir-address in certificate"); - tor_free(address); - goto err; - } - cert->addr = ntohl(in.s_addr); - tor_free(address); - } - - tok = find_by_keyword(tokens, K_DIR_KEY_PUBLISHED); - if (parse_iso_time(tok->args[0], &cert->cache_info.published_on) < 0) { - goto err; - } - tok = find_by_keyword(tokens, K_DIR_KEY_EXPIRES); - if (parse_iso_time(tok->args[0], &cert->expires) < 0) { - goto err; - } - - tok = smartlist_get(tokens, smartlist_len(tokens)-1); - if (tok->tp != K_DIR_KEY_CERTIFICATION) { - log_warn(LD_DIR, "Certificate didn't end with dir-key-certification."); - goto err; - } - - /* If we already have this cert, don't bother checking the signature. */ - old_cert = authority_cert_get_by_digests( - cert->cache_info.identity_digest, - cert->signing_key_digest); - found = 0; - if (old_cert) { - /* XXXX We could just compare signed_descriptor_digest, but that wouldn't - * buy us much. */ - if (old_cert->cache_info.signed_descriptor_len == len && - old_cert->cache_info.signed_descriptor_body && - tor_memeq(s, old_cert->cache_info.signed_descriptor_body, len)) { - log_debug(LD_DIR, "We already checked the signature on this " - "certificate; no need to do so again."); - found = 1; - } - } - if (!found) { - if (check_signature_token(digest, DIGEST_LEN, tok, cert->identity_key, 0, - "key certificate")) { - goto err; - } - - tok = find_by_keyword(tokens, K_DIR_KEY_CROSSCERT); - if (check_signature_token(cert->cache_info.identity_digest, - DIGEST_LEN, - tok, - cert->signing_key, - CST_NO_CHECK_OBJTYPE, - "key cross-certification")) { - goto err; - } - } - - cert->cache_info.signed_descriptor_len = len; - cert->cache_info.signed_descriptor_body = tor_malloc(len+1); - memcpy(cert->cache_info.signed_descriptor_body, s, len); - cert->cache_info.signed_descriptor_body[len] = 0; - cert->cache_info.saved_location = SAVED_NOWHERE; - - if (end_of_string) { - *end_of_string = eat_whitespace(eos); - } - SMARTLIST_FOREACH(tokens, directory_token_t *, t, token_clear(t)); - smartlist_free(tokens); - if (area) { - DUMP_AREA(area, "authority cert"); - memarea_drop_all(area); - } - return cert; - err: - dump_desc(s_dup, "authority cert"); - authority_cert_free(cert); - SMARTLIST_FOREACH(tokens, directory_token_t *, t, token_clear(t)); - smartlist_free(tokens); - if (area) { - DUMP_AREA(area, "authority cert"); - memarea_drop_all(area); - } - return NULL; -} - -/** Helper: given a string <b>s</b>, return the start of the next router-status - * object (starting with "r " at the start of a line). If none is found, - * return the start of the directory footer, or the next directory signature. - * If none is found, return the end of the string. */ -static inline const char * -find_start_of_next_routerstatus(const char *s) -{ - const char *eos, *footer, *sig; - if ((eos = strstr(s, "\nr "))) - ++eos; - else - eos = s + strlen(s); - - footer = tor_memstr(s, eos-s, "\ndirectory-footer"); - sig = tor_memstr(s, eos-s, "\ndirectory-signature"); - - if (footer && sig) - return MIN(footer, sig) + 1; - else if (footer) - return footer+1; - else if (sig) - return sig+1; - else - return eos; -} - -/** Parse the GuardFraction string from a consensus or vote. - * - * If <b>vote</b> or <b>vote_rs</b> are set the document getting - * parsed is a vote routerstatus. Otherwise it's a consensus. This is - * the same semantic as in routerstatus_parse_entry_from_string(). */ -STATIC int -routerstatus_parse_guardfraction(const char *guardfraction_str, - networkstatus_t *vote, - vote_routerstatus_t *vote_rs, - routerstatus_t *rs) -{ - int ok; - const char *end_of_header = NULL; - int is_consensus = !vote_rs; - uint32_t guardfraction; - - tor_assert(bool_eq(vote, vote_rs)); - - /* If this info comes from a consensus, but we should't apply - guardfraction, just exit. */ - if (is_consensus && !should_apply_guardfraction(NULL)) { - return 0; - } - - end_of_header = strchr(guardfraction_str, '='); - if (!end_of_header) { - return -1; - } - - guardfraction = (uint32_t)tor_parse_ulong(end_of_header+1, - 10, 0, 100, &ok, NULL); - if (!ok) { - log_warn(LD_DIR, "Invalid GuardFraction %s", escaped(guardfraction_str)); - return -1; - } - - log_debug(LD_GENERAL, "[*] Parsed %s guardfraction '%s' for '%s'.", - is_consensus ? "consensus" : "vote", - guardfraction_str, rs->nickname); - - if (!is_consensus) { /* We are parsing a vote */ - vote_rs->status.guardfraction_percentage = guardfraction; - vote_rs->status.has_guardfraction = 1; - } else { - /* We are parsing a consensus. Only apply guardfraction to guards. */ - if (rs->is_possible_guard) { - rs->guardfraction_percentage = guardfraction; - rs->has_guardfraction = 1; - } else { - log_warn(LD_BUG, "Got GuardFraction for non-guard %s. " - "This is not supposed to happen. Not applying. ", rs->nickname); - } - } - - return 0; -} - -/** Summarize the protocols listed in <b>protocols</b> into <b>out</b>, - * falling back or correcting them based on <b>version</b> as appropriate. - */ -STATIC void -summarize_protover_flags(protover_summary_flags_t *out, - const char *protocols, - const char *version) -{ - tor_assert(out); - memset(out, 0, sizeof(*out)); - if (protocols) { - out->protocols_known = 1; - out->supports_extend2_cells = - protocol_list_supports_protocol(protocols, PRT_RELAY, 2); - out->supports_ed25519_link_handshake_compat = - protocol_list_supports_protocol(protocols, PRT_LINKAUTH, 3); - out->supports_ed25519_link_handshake_any = - protocol_list_supports_protocol_or_later(protocols, PRT_LINKAUTH, 3); - out->supports_ed25519_hs_intro = - protocol_list_supports_protocol(protocols, PRT_HSINTRO, 4); - out->supports_v3_hsdir = - protocol_list_supports_protocol(protocols, PRT_HSDIR, - PROTOVER_HSDIR_V3); - out->supports_v3_rendezvous_point = - protocol_list_supports_protocol(protocols, PRT_HSREND, - PROTOVER_HS_RENDEZVOUS_POINT_V3); - } - if (version && !strcmpstart(version, "Tor ")) { - if (!out->protocols_known) { - /* The version is a "Tor" version, and where there is no - * list of protocol versions that we should be looking at instead. */ - - out->supports_extend2_cells = - tor_version_as_new_as(version, "0.2.4.8-alpha"); - out->protocols_known = 1; - } else { - /* Bug #22447 forces us to filter on this version. */ - if (!tor_version_as_new_as(version, "0.3.0.8")) { - out->supports_v3_hsdir = 0; - } - } - } -} - -/** Given a string at *<b>s</b>, containing a routerstatus object, and an - * empty smartlist at <b>tokens</b>, parse and return the first router status - * object in the string, and advance *<b>s</b> to just after the end of the - * router status. Return NULL and advance *<b>s</b> on error. - * - * If <b>vote</b> and <b>vote_rs</b> are provided, don't allocate a fresh - * routerstatus but use <b>vote_rs</b> instead. - * - * If <b>consensus_method</b> is nonzero, this routerstatus is part of a - * consensus, and we should parse it according to the method used to - * make that consensus. - * - * Parse according to the syntax used by the consensus flavor <b>flav</b>. - **/ -STATIC routerstatus_t * -routerstatus_parse_entry_from_string(memarea_t *area, - const char **s, smartlist_t *tokens, - networkstatus_t *vote, - vote_routerstatus_t *vote_rs, - int consensus_method, - consensus_flavor_t flav) -{ - const char *eos, *s_dup = *s; - routerstatus_t *rs = NULL; - directory_token_t *tok; - char timebuf[ISO_TIME_LEN+1]; - struct in_addr in; - int offset = 0; - tor_assert(tokens); - tor_assert(bool_eq(vote, vote_rs)); - - if (!consensus_method) - flav = FLAV_NS; - tor_assert(flav == FLAV_NS || flav == FLAV_MICRODESC); - - eos = find_start_of_next_routerstatus(*s); - - if (tokenize_string(area,*s, eos, tokens, rtrstatus_token_table,0)) { - log_warn(LD_DIR, "Error tokenizing router status"); - goto err; - } - if (smartlist_len(tokens) < 1) { - log_warn(LD_DIR, "Impossibly short router status"); - goto err; - } - tok = find_by_keyword(tokens, K_R); - tor_assert(tok->n_args >= 7); /* guaranteed by GE(7) in K_R setup */ - if (flav == FLAV_NS) { - if (tok->n_args < 8) { - log_warn(LD_DIR, "Too few arguments to r"); - goto err; - } - } else if (flav == FLAV_MICRODESC) { - offset = -1; /* There is no descriptor digest in an md consensus r line */ - } - - if (vote_rs) { - rs = &vote_rs->status; - } else { - rs = tor_malloc_zero(sizeof(routerstatus_t)); - } - - if (!is_legal_nickname(tok->args[0])) { - log_warn(LD_DIR, - "Invalid nickname %s in router status; skipping.", - escaped(tok->args[0])); - goto err; - } - strlcpy(rs->nickname, tok->args[0], sizeof(rs->nickname)); - - if (digest_from_base64(rs->identity_digest, tok->args[1])) { - log_warn(LD_DIR, "Error decoding identity digest %s", - escaped(tok->args[1])); - goto err; - } - - if (flav == FLAV_NS) { - if (digest_from_base64(rs->descriptor_digest, tok->args[2])) { - log_warn(LD_DIR, "Error decoding descriptor digest %s", - escaped(tok->args[2])); - goto err; - } - } - - if (tor_snprintf(timebuf, sizeof(timebuf), "%s %s", - tok->args[3+offset], tok->args[4+offset]) < 0 || - parse_iso_time(timebuf, &rs->published_on)<0) { - log_warn(LD_DIR, "Error parsing time '%s %s' [%d %d]", - tok->args[3+offset], tok->args[4+offset], - offset, (int)flav); - goto err; - } - - if (tor_inet_aton(tok->args[5+offset], &in) == 0) { - log_warn(LD_DIR, "Error parsing router address in network-status %s", - escaped(tok->args[5+offset])); - goto err; - } - rs->addr = ntohl(in.s_addr); - - rs->or_port = (uint16_t) tor_parse_long(tok->args[6+offset], - 10,0,65535,NULL,NULL); - rs->dir_port = (uint16_t) tor_parse_long(tok->args[7+offset], - 10,0,65535,NULL,NULL); - - { - smartlist_t *a_lines = find_all_by_keyword(tokens, K_A); - if (a_lines) { - find_single_ipv6_orport(a_lines, &rs->ipv6_addr, &rs->ipv6_orport); - smartlist_free(a_lines); - } - } - - tok = find_opt_by_keyword(tokens, K_S); - if (tok && vote) { - int i; - vote_rs->flags = 0; - for (i=0; i < tok->n_args; ++i) { - int p = smartlist_string_pos(vote->known_flags, tok->args[i]); - if (p >= 0) { - vote_rs->flags |= (UINT64_C(1)<<p); - } else { - log_warn(LD_DIR, "Flags line had a flag %s not listed in known_flags.", - escaped(tok->args[i])); - goto err; - } - } - } else if (tok) { - /* This is a consensus, not a vote. */ - int i; - for (i=0; i < tok->n_args; ++i) { - if (!strcmp(tok->args[i], "Exit")) - rs->is_exit = 1; - else if (!strcmp(tok->args[i], "Stable")) - rs->is_stable = 1; - else if (!strcmp(tok->args[i], "Fast")) - rs->is_fast = 1; - else if (!strcmp(tok->args[i], "Running")) - rs->is_flagged_running = 1; - else if (!strcmp(tok->args[i], "Named")) - rs->is_named = 1; - else if (!strcmp(tok->args[i], "Valid")) - rs->is_valid = 1; - else if (!strcmp(tok->args[i], "Guard")) - rs->is_possible_guard = 1; - else if (!strcmp(tok->args[i], "BadExit")) - rs->is_bad_exit = 1; - else if (!strcmp(tok->args[i], "Authority")) - rs->is_authority = 1; - else if (!strcmp(tok->args[i], "Unnamed") && - consensus_method >= 2) { - /* Unnamed is computed right by consensus method 2 and later. */ - rs->is_unnamed = 1; - } else if (!strcmp(tok->args[i], "HSDir")) { - rs->is_hs_dir = 1; - } else if (!strcmp(tok->args[i], "V2Dir")) { - rs->is_v2_dir = 1; - } - } - /* These are implied true by having been included in a consensus made - * with a given method */ - rs->is_flagged_running = 1; /* Starting with consensus method 4. */ - rs->is_valid = 1; /* Starting with consensus method 24. */ - } - { - const char *protocols = NULL, *version = NULL; - if ((tok = find_opt_by_keyword(tokens, K_PROTO))) { - tor_assert(tok->n_args == 1); - protocols = tok->args[0]; - } - if ((tok = find_opt_by_keyword(tokens, K_V))) { - tor_assert(tok->n_args == 1); - version = tok->args[0]; - if (vote_rs) { - vote_rs->version = tor_strdup(tok->args[0]); - } - } - - summarize_protover_flags(&rs->pv, protocols, version); - } - - /* handle weighting/bandwidth info */ - if ((tok = find_opt_by_keyword(tokens, K_W))) { - int i; - for (i=0; i < tok->n_args; ++i) { - if (!strcmpstart(tok->args[i], "Bandwidth=")) { - int ok; - rs->bandwidth_kb = - (uint32_t)tor_parse_ulong(strchr(tok->args[i], '=')+1, - 10, 0, UINT32_MAX, - &ok, NULL); - if (!ok) { - log_warn(LD_DIR, "Invalid Bandwidth %s", escaped(tok->args[i])); - goto err; - } - rs->has_bandwidth = 1; - } else if (!strcmpstart(tok->args[i], "Measured=") && vote_rs) { - int ok; - vote_rs->measured_bw_kb = - (uint32_t)tor_parse_ulong(strchr(tok->args[i], '=')+1, - 10, 0, UINT32_MAX, &ok, NULL); - if (!ok) { - log_warn(LD_DIR, "Invalid Measured Bandwidth %s", - escaped(tok->args[i])); - goto err; - } - vote_rs->has_measured_bw = 1; - vote->has_measured_bws = 1; - } else if (!strcmpstart(tok->args[i], "Unmeasured=1")) { - rs->bw_is_unmeasured = 1; - } else if (!strcmpstart(tok->args[i], "GuardFraction=")) { - if (routerstatus_parse_guardfraction(tok->args[i], - vote, vote_rs, rs) < 0) { - goto err; - } - } - } - } - - /* parse exit policy summaries */ - if ((tok = find_opt_by_keyword(tokens, K_P))) { - tor_assert(tok->n_args == 1); - if (strcmpstart(tok->args[0], "accept ") && - strcmpstart(tok->args[0], "reject ")) { - log_warn(LD_DIR, "Unknown exit policy summary type %s.", - escaped(tok->args[0])); - goto err; - } - /* XXX weasel: parse this into ports and represent them somehow smart, - * maybe not here but somewhere on if we need it for the client. - * we should still parse it here to check it's valid tho. - */ - rs->exitsummary = tor_strdup(tok->args[0]); - rs->has_exitsummary = 1; - } - - if (vote_rs) { - SMARTLIST_FOREACH_BEGIN(tokens, directory_token_t *, t) { - if (t->tp == K_M && t->n_args) { - vote_microdesc_hash_t *line = - tor_malloc(sizeof(vote_microdesc_hash_t)); - line->next = vote_rs->microdesc; - line->microdesc_hash_line = tor_strdup(t->args[0]); - vote_rs->microdesc = line; - } - if (t->tp == K_ID) { - tor_assert(t->n_args >= 2); - if (!strcmp(t->args[0], "ed25519")) { - vote_rs->has_ed25519_listing = 1; - if (strcmp(t->args[1], "none") && - digest256_from_base64((char*)vote_rs->ed25519_id, - t->args[1])<0) { - log_warn(LD_DIR, "Bogus ed25519 key in networkstatus vote"); - goto err; - } - } - } - if (t->tp == K_PROTO) { - tor_assert(t->n_args == 1); - vote_rs->protocols = tor_strdup(t->args[0]); - } - } SMARTLIST_FOREACH_END(t); - } else if (flav == FLAV_MICRODESC) { - tok = find_opt_by_keyword(tokens, K_M); - if (tok) { - tor_assert(tok->n_args); - if (digest256_from_base64(rs->descriptor_digest, tok->args[0])) { - log_warn(LD_DIR, "Error decoding microdescriptor digest %s", - escaped(tok->args[0])); - goto err; - } - } else { - log_info(LD_BUG, "Found an entry in networkstatus with no " - "microdescriptor digest. (Router %s ($%s) at %s:%d.)", - rs->nickname, hex_str(rs->identity_digest, DIGEST_LEN), - fmt_addr32(rs->addr), rs->or_port); - } - } - - if (!strcasecmp(rs->nickname, UNNAMED_ROUTER_NICKNAME)) - rs->is_named = 0; - - goto done; - err: - dump_desc(s_dup, "routerstatus entry"); - if (rs && !vote_rs) - routerstatus_free(rs); - rs = NULL; - done: - SMARTLIST_FOREACH(tokens, directory_token_t *, t, token_clear(t)); - smartlist_clear(tokens); - if (area) { - DUMP_AREA(area, "routerstatus entry"); - memarea_clear(area); - } - *s = eos; - - return rs; -} - -int -compare_vote_routerstatus_entries(const void **_a, const void **_b) -{ - const vote_routerstatus_t *a = *_a, *b = *_b; - return fast_memcmp(a->status.identity_digest, b->status.identity_digest, - DIGEST_LEN); -} - -/** Verify the bandwidth weights of a network status document */ -int -networkstatus_verify_bw_weights(networkstatus_t *ns, int consensus_method) -{ - int64_t G=0, M=0, E=0, D=0, T=0; - double Wgg, Wgm, Wgd, Wmg, Wmm, Wme, Wmd, Weg, Wem, Wee, Wed; - double Gtotal=0, Mtotal=0, Etotal=0; - const char *casename = NULL; - int valid = 1; - (void) consensus_method; - - const int64_t weight_scale = networkstatus_get_weight_scale_param(ns); - tor_assert(weight_scale >= 1); - Wgg = networkstatus_get_bw_weight(ns, "Wgg", -1); - Wgm = networkstatus_get_bw_weight(ns, "Wgm", -1); - Wgd = networkstatus_get_bw_weight(ns, "Wgd", -1); - Wmg = networkstatus_get_bw_weight(ns, "Wmg", -1); - Wmm = networkstatus_get_bw_weight(ns, "Wmm", -1); - Wme = networkstatus_get_bw_weight(ns, "Wme", -1); - Wmd = networkstatus_get_bw_weight(ns, "Wmd", -1); - Weg = networkstatus_get_bw_weight(ns, "Weg", -1); - Wem = networkstatus_get_bw_weight(ns, "Wem", -1); - Wee = networkstatus_get_bw_weight(ns, "Wee", -1); - Wed = networkstatus_get_bw_weight(ns, "Wed", -1); - - if (Wgg<0 || Wgm<0 || Wgd<0 || Wmg<0 || Wmm<0 || Wme<0 || Wmd<0 || Weg<0 - || Wem<0 || Wee<0 || Wed<0) { - log_warn(LD_BUG, "No bandwidth weights produced in consensus!"); - return 0; - } - - // First, sanity check basic summing properties that hold for all cases - // We use > 1 as the check for these because they are computed as integers. - // Sometimes there are rounding errors. - if (fabs(Wmm - weight_scale) > 1) { - log_warn(LD_BUG, "Wmm=%f != %"PRId64, - Wmm, (weight_scale)); - valid = 0; - } - - if (fabs(Wem - Wee) > 1) { - log_warn(LD_BUG, "Wem=%f != Wee=%f", Wem, Wee); - valid = 0; - } - - if (fabs(Wgm - Wgg) > 1) { - log_warn(LD_BUG, "Wgm=%f != Wgg=%f", Wgm, Wgg); - valid = 0; - } - - if (fabs(Weg - Wed) > 1) { - log_warn(LD_BUG, "Wed=%f != Weg=%f", Wed, Weg); - valid = 0; - } - - if (fabs(Wgg + Wmg - weight_scale) > 0.001*weight_scale) { - log_warn(LD_BUG, "Wgg=%f != %"PRId64" - Wmg=%f", Wgg, - (weight_scale), Wmg); - valid = 0; - } - - if (fabs(Wee + Wme - weight_scale) > 0.001*weight_scale) { - log_warn(LD_BUG, "Wee=%f != %"PRId64" - Wme=%f", Wee, - (weight_scale), Wme); - valid = 0; - } - - if (fabs(Wgd + Wmd + Wed - weight_scale) > 0.001*weight_scale) { - log_warn(LD_BUG, "Wgd=%f + Wmd=%f + Wed=%f != %"PRId64, - Wgd, Wmd, Wed, (weight_scale)); - valid = 0; - } - - Wgg /= weight_scale; - Wgm /= weight_scale; (void) Wgm; // unused from here on. - Wgd /= weight_scale; - - Wmg /= weight_scale; - Wmm /= weight_scale; - Wme /= weight_scale; - Wmd /= weight_scale; - - Weg /= weight_scale; (void) Weg; // unused from here on. - Wem /= weight_scale; (void) Wem; // unused from here on. - Wee /= weight_scale; - Wed /= weight_scale; - - // Then, gather G, M, E, D, T to determine case - SMARTLIST_FOREACH_BEGIN(ns->routerstatus_list, routerstatus_t *, rs) { - int is_exit = 0; - /* Bug #2203: Don't count bad exits as exits for balancing */ - is_exit = rs->is_exit && !rs->is_bad_exit; - if (rs->has_bandwidth) { - T += rs->bandwidth_kb; - if (is_exit && rs->is_possible_guard) { - D += rs->bandwidth_kb; - Gtotal += Wgd*rs->bandwidth_kb; - Mtotal += Wmd*rs->bandwidth_kb; - Etotal += Wed*rs->bandwidth_kb; - } else if (is_exit) { - E += rs->bandwidth_kb; - Mtotal += Wme*rs->bandwidth_kb; - Etotal += Wee*rs->bandwidth_kb; - } else if (rs->is_possible_guard) { - G += rs->bandwidth_kb; - Gtotal += Wgg*rs->bandwidth_kb; - Mtotal += Wmg*rs->bandwidth_kb; - } else { - M += rs->bandwidth_kb; - Mtotal += Wmm*rs->bandwidth_kb; - } - } else { - log_warn(LD_BUG, "Missing consensus bandwidth for router %s", - routerstatus_describe(rs)); - } - } SMARTLIST_FOREACH_END(rs); - - // Finally, check equality conditions depending upon case 1, 2 or 3 - // Full equality cases: 1, 3b - // Partial equality cases: 2b (E=G), 3a (M=E) - // Fully unknown: 2a - if (3*E >= T && 3*G >= T) { - // Case 1: Neither are scarce - casename = "Case 1"; - if (fabs(Etotal-Mtotal) > 0.01*MAX(Etotal,Mtotal)) { - log_warn(LD_DIR, - "Bw Weight Failure for %s: Etotal %f != Mtotal %f. " - "G=%"PRId64" M=%"PRId64" E=%"PRId64" D=%"PRId64 - " T=%"PRId64". " - "Wgg=%f Wgd=%f Wmg=%f Wme=%f Wmd=%f Wee=%f Wed=%f", - casename, Etotal, Mtotal, - (G), (M), (E), - (D), (T), - Wgg, Wgd, Wmg, Wme, Wmd, Wee, Wed); - valid = 0; - } - if (fabs(Etotal-Gtotal) > 0.01*MAX(Etotal,Gtotal)) { - log_warn(LD_DIR, - "Bw Weight Failure for %s: Etotal %f != Gtotal %f. " - "G=%"PRId64" M=%"PRId64" E=%"PRId64" D=%"PRId64 - " T=%"PRId64". " - "Wgg=%f Wgd=%f Wmg=%f Wme=%f Wmd=%f Wee=%f Wed=%f", - casename, Etotal, Gtotal, - (G), (M), (E), - (D), (T), - Wgg, Wgd, Wmg, Wme, Wmd, Wee, Wed); - valid = 0; - } - if (fabs(Gtotal-Mtotal) > 0.01*MAX(Gtotal,Mtotal)) { - log_warn(LD_DIR, - "Bw Weight Failure for %s: Mtotal %f != Gtotal %f. " - "G=%"PRId64" M=%"PRId64" E=%"PRId64" D=%"PRId64 - " T=%"PRId64". " - "Wgg=%f Wgd=%f Wmg=%f Wme=%f Wmd=%f Wee=%f Wed=%f", - casename, Mtotal, Gtotal, - (G), (M), (E), - (D), (T), - Wgg, Wgd, Wmg, Wme, Wmd, Wee, Wed); - valid = 0; - } - } else if (3*E < T && 3*G < T) { - int64_t R = MIN(E, G); - int64_t S = MAX(E, G); - /* - * Case 2: Both Guards and Exits are scarce - * Balance D between E and G, depending upon - * D capacity and scarcity. Devote no extra - * bandwidth to middle nodes. - */ - if (R+D < S) { // Subcase a - double Rtotal, Stotal; - if (E < G) { - Rtotal = Etotal; - Stotal = Gtotal; - } else { - Rtotal = Gtotal; - Stotal = Etotal; - } - casename = "Case 2a"; - // Rtotal < Stotal - if (Rtotal > Stotal) { - log_warn(LD_DIR, - "Bw Weight Failure for %s: Rtotal %f > Stotal %f. " - "G=%"PRId64" M=%"PRId64" E=%"PRId64" D=%"PRId64 - " T=%"PRId64". " - "Wgg=%f Wgd=%f Wmg=%f Wme=%f Wmd=%f Wee=%f Wed=%f", - casename, Rtotal, Stotal, - (G), (M), (E), - (D), (T), - Wgg, Wgd, Wmg, Wme, Wmd, Wee, Wed); - valid = 0; - } - // Rtotal < T/3 - if (3*Rtotal > T) { - log_warn(LD_DIR, - "Bw Weight Failure for %s: 3*Rtotal %f > T " - "%"PRId64". G=%"PRId64" M=%"PRId64" E=%"PRId64 - " D=%"PRId64" T=%"PRId64". " - "Wgg=%f Wgd=%f Wmg=%f Wme=%f Wmd=%f Wee=%f Wed=%f", - casename, Rtotal*3, (T), - (G), (M), (E), - (D), (T), - Wgg, Wgd, Wmg, Wme, Wmd, Wee, Wed); - valid = 0; - } - // Stotal < T/3 - if (3*Stotal > T) { - log_warn(LD_DIR, - "Bw Weight Failure for %s: 3*Stotal %f > T " - "%"PRId64". G=%"PRId64" M=%"PRId64" E=%"PRId64 - " D=%"PRId64" T=%"PRId64". " - "Wgg=%f Wgd=%f Wmg=%f Wme=%f Wmd=%f Wee=%f Wed=%f", - casename, Stotal*3, (T), - (G), (M), (E), - (D), (T), - Wgg, Wgd, Wmg, Wme, Wmd, Wee, Wed); - valid = 0; - } - // Mtotal > T/3 - if (3*Mtotal < T) { - log_warn(LD_DIR, - "Bw Weight Failure for %s: 3*Mtotal %f < T " - "%"PRId64". " - "G=%"PRId64" M=%"PRId64" E=%"PRId64" D=%"PRId64 - " T=%"PRId64". " - "Wgg=%f Wgd=%f Wmg=%f Wme=%f Wmd=%f Wee=%f Wed=%f", - casename, Mtotal*3, (T), - (G), (M), (E), - (D), (T), - Wgg, Wgd, Wmg, Wme, Wmd, Wee, Wed); - valid = 0; - } - } else { // Subcase b: R+D > S - casename = "Case 2b"; - - /* Check the rare-M redirect case. */ - if (D != 0 && 3*M < T) { - casename = "Case 2b (balanced)"; - if (fabs(Etotal-Mtotal) > 0.01*MAX(Etotal,Mtotal)) { - log_warn(LD_DIR, - "Bw Weight Failure for %s: Etotal %f != Mtotal %f. " - "G=%"PRId64" M=%"PRId64" E=%"PRId64" D=%"PRId64 - " T=%"PRId64". " - "Wgg=%f Wgd=%f Wmg=%f Wme=%f Wmd=%f Wee=%f Wed=%f", - casename, Etotal, Mtotal, - (G), (M), (E), - (D), (T), - Wgg, Wgd, Wmg, Wme, Wmd, Wee, Wed); - valid = 0; - } - if (fabs(Etotal-Gtotal) > 0.01*MAX(Etotal,Gtotal)) { - log_warn(LD_DIR, - "Bw Weight Failure for %s: Etotal %f != Gtotal %f. " - "G=%"PRId64" M=%"PRId64" E=%"PRId64" D=%"PRId64 - " T=%"PRId64". " - "Wgg=%f Wgd=%f Wmg=%f Wme=%f Wmd=%f Wee=%f Wed=%f", - casename, Etotal, Gtotal, - (G), (M), (E), - (D), (T), - Wgg, Wgd, Wmg, Wme, Wmd, Wee, Wed); - valid = 0; - } - if (fabs(Gtotal-Mtotal) > 0.01*MAX(Gtotal,Mtotal)) { - log_warn(LD_DIR, - "Bw Weight Failure for %s: Mtotal %f != Gtotal %f. " - "G=%"PRId64" M=%"PRId64" E=%"PRId64" D=%"PRId64 - " T=%"PRId64". " - "Wgg=%f Wgd=%f Wmg=%f Wme=%f Wmd=%f Wee=%f Wed=%f", - casename, Mtotal, Gtotal, - (G), (M), (E), - (D), (T), - Wgg, Wgd, Wmg, Wme, Wmd, Wee, Wed); - valid = 0; - } - } else { - if (fabs(Etotal-Gtotal) > 0.01*MAX(Etotal,Gtotal)) { - log_warn(LD_DIR, - "Bw Weight Failure for %s: Etotal %f != Gtotal %f. " - "G=%"PRId64" M=%"PRId64" E=%"PRId64" D=%"PRId64 - " T=%"PRId64". " - "Wgg=%f Wgd=%f Wmg=%f Wme=%f Wmd=%f Wee=%f Wed=%f", - casename, Etotal, Gtotal, - (G), (M), (E), - (D), (T), - Wgg, Wgd, Wmg, Wme, Wmd, Wee, Wed); - valid = 0; - } - } - } - } else { // if (E < T/3 || G < T/3) { - int64_t S = MIN(E, G); - int64_t NS = MAX(E, G); - if (3*(S+D) < T) { // Subcase a: - double Stotal; - double NStotal; - if (G < E) { - casename = "Case 3a (G scarce)"; - Stotal = Gtotal; - NStotal = Etotal; - } else { // if (G >= E) { - casename = "Case 3a (E scarce)"; - NStotal = Gtotal; - Stotal = Etotal; - } - // Stotal < T/3 - if (3*Stotal > T) { - log_warn(LD_DIR, - "Bw Weight Failure for %s: 3*Stotal %f > T " - "%"PRId64". G=%"PRId64" M=%"PRId64" E=%"PRId64 - " D=%"PRId64" T=%"PRId64". " - "Wgg=%f Wgd=%f Wmg=%f Wme=%f Wmd=%f Wee=%f Wed=%f", - casename, Stotal*3, (T), - (G), (M), (E), - (D), (T), - Wgg, Wgd, Wmg, Wme, Wmd, Wee, Wed); - valid = 0; - } - if (NS >= M) { - if (fabs(NStotal-Mtotal) > 0.01*MAX(NStotal,Mtotal)) { - log_warn(LD_DIR, - "Bw Weight Failure for %s: NStotal %f != Mtotal %f. " - "G=%"PRId64" M=%"PRId64" E=%"PRId64" D=%"PRId64 - " T=%"PRId64". " - "Wgg=%f Wgd=%f Wmg=%f Wme=%f Wmd=%f Wee=%f Wed=%f", - casename, NStotal, Mtotal, - (G), (M), (E), - (D), (T), - Wgg, Wgd, Wmg, Wme, Wmd, Wee, Wed); - valid = 0; - } - } else { - // if NS < M, NStotal > T/3 because only one of G or E is scarce - if (3*NStotal < T) { - log_warn(LD_DIR, - "Bw Weight Failure for %s: 3*NStotal %f < T " - "%"PRId64". G=%"PRId64" M=%"PRId64 - " E=%"PRId64" D=%"PRId64" T=%"PRId64". " - "Wgg=%f Wgd=%f Wmg=%f Wme=%f Wmd=%f Wee=%f Wed=%f", - casename, NStotal*3, (T), - (G), (M), (E), - (D), (T), - Wgg, Wgd, Wmg, Wme, Wmd, Wee, Wed); - valid = 0; - } - } - } else { // Subcase b: S+D >= T/3 - casename = "Case 3b"; - if (fabs(Etotal-Mtotal) > 0.01*MAX(Etotal,Mtotal)) { - log_warn(LD_DIR, - "Bw Weight Failure for %s: Etotal %f != Mtotal %f. " - "G=%"PRId64" M=%"PRId64" E=%"PRId64" D=%"PRId64 - " T=%"PRId64". " - "Wgg=%f Wgd=%f Wmg=%f Wme=%f Wmd=%f Wee=%f Wed=%f", - casename, Etotal, Mtotal, - (G), (M), (E), - (D), (T), - Wgg, Wgd, Wmg, Wme, Wmd, Wee, Wed); - valid = 0; - } - if (fabs(Etotal-Gtotal) > 0.01*MAX(Etotal,Gtotal)) { - log_warn(LD_DIR, - "Bw Weight Failure for %s: Etotal %f != Gtotal %f. " - "G=%"PRId64" M=%"PRId64" E=%"PRId64" D=%"PRId64 - " T=%"PRId64". " - "Wgg=%f Wgd=%f Wmg=%f Wme=%f Wmd=%f Wee=%f Wed=%f", - casename, Etotal, Gtotal, - (G), (M), (E), - (D), (T), - Wgg, Wgd, Wmg, Wme, Wmd, Wee, Wed); - valid = 0; - } - if (fabs(Gtotal-Mtotal) > 0.01*MAX(Gtotal,Mtotal)) { - log_warn(LD_DIR, - "Bw Weight Failure for %s: Mtotal %f != Gtotal %f. " - "G=%"PRId64" M=%"PRId64" E=%"PRId64" D=%"PRId64 - " T=%"PRId64". " - "Wgg=%f Wgd=%f Wmg=%f Wme=%f Wmd=%f Wee=%f Wed=%f", - casename, Mtotal, Gtotal, - (G), (M), (E), - (D), (T), - Wgg, Wgd, Wmg, Wme, Wmd, Wee, Wed); - valid = 0; - } - } - } - - if (valid) - log_notice(LD_DIR, "Bandwidth-weight %s is verified and valid.", - casename); - - return valid; -} - -/** Check if a shared random value of type <b>srv_type</b> is in - * <b>tokens</b>. If there is, parse it and set it to <b>srv_out</b>. Return - * -1 on failure, 0 on success. The resulting srv is allocated on the heap and - * it's the responsibility of the caller to free it. */ -static int -extract_one_srv(smartlist_t *tokens, directory_keyword srv_type, - sr_srv_t **srv_out) -{ - int ret = -1; - directory_token_t *tok; - sr_srv_t *srv = NULL; - smartlist_t *chunks; - - tor_assert(tokens); - - chunks = smartlist_new(); - tok = find_opt_by_keyword(tokens, srv_type); - if (!tok) { - /* That's fine, no SRV is allowed. */ - ret = 0; - goto end; - } - for (int i = 0; i < tok->n_args; i++) { - smartlist_add(chunks, tok->args[i]); - } - srv = sr_parse_srv(chunks); - if (srv == NULL) { - log_warn(LD_DIR, "SR: Unparseable SRV %s", escaped(tok->object_body)); - goto end; - } - /* All is good. */ - *srv_out = srv; - ret = 0; - end: - smartlist_free(chunks); - return ret; -} - -/** Extract any shared random values found in <b>tokens</b> and place them in - * the networkstatus <b>ns</b>. */ -static void -extract_shared_random_srvs(networkstatus_t *ns, smartlist_t *tokens) -{ - const char *voter_identity; - networkstatus_voter_info_t *voter; - - tor_assert(ns); - tor_assert(tokens); - /* Can be only one of them else code flow. */ - tor_assert(ns->type == NS_TYPE_VOTE || ns->type == NS_TYPE_CONSENSUS); - - if (ns->type == NS_TYPE_VOTE) { - voter = smartlist_get(ns->voters, 0); - tor_assert(voter); - voter_identity = hex_str(voter->identity_digest, - sizeof(voter->identity_digest)); - } else { - /* Consensus has multiple voters so no specific voter. */ - voter_identity = "consensus"; - } - - /* We extract both, and on error everything is stopped because it means - * the vote is malformed for the shared random value(s). */ - if (extract_one_srv(tokens, K_PREVIOUS_SRV, &ns->sr_info.previous_srv) < 0) { - log_warn(LD_DIR, "SR: Unable to parse previous SRV from %s", - voter_identity); - /* Maybe we have a chance with the current SRV so let's try it anyway. */ - } - if (extract_one_srv(tokens, K_CURRENT_SRV, &ns->sr_info.current_srv) < 0) { - log_warn(LD_DIR, "SR: Unable to parse current SRV from %s", - voter_identity); - } -} - -/** Parse a v3 networkstatus vote, opinion, or consensus (depending on - * ns_type), from <b>s</b>, and return the result. Return NULL on failure. */ -networkstatus_t * -networkstatus_parse_vote_from_string(const char *s, const char **eos_out, - networkstatus_type_t ns_type) -{ - smartlist_t *tokens = smartlist_new(); - smartlist_t *rs_tokens = NULL, *footer_tokens = NULL; - networkstatus_voter_info_t *voter = NULL; - networkstatus_t *ns = NULL; - common_digests_t ns_digests; - uint8_t sha3_as_signed[DIGEST256_LEN]; - const char *cert, *end_of_header, *end_of_footer, *s_dup = s; - directory_token_t *tok; - struct in_addr in; - int i, inorder, n_signatures = 0; - memarea_t *area = NULL, *rs_area = NULL; - consensus_flavor_t flav = FLAV_NS; - char *last_kwd=NULL; - - tor_assert(s); - - if (eos_out) - *eos_out = NULL; - - if (router_get_networkstatus_v3_hashes(s, &ns_digests) || - router_get_networkstatus_v3_sha3_as_signed(sha3_as_signed, s)<0) { - log_warn(LD_DIR, "Unable to compute digest of network-status"); - goto err; - } - - area = memarea_new(); - end_of_header = find_start_of_next_routerstatus(s); - if (tokenize_string(area, s, end_of_header, tokens, - (ns_type == NS_TYPE_CONSENSUS) ? - networkstatus_consensus_token_table : - networkstatus_token_table, 0)) { - log_warn(LD_DIR, "Error tokenizing network-status header"); - goto err; - } - - ns = tor_malloc_zero(sizeof(networkstatus_t)); - memcpy(&ns->digests, &ns_digests, sizeof(ns_digests)); - memcpy(&ns->digest_sha3_as_signed, sha3_as_signed, sizeof(sha3_as_signed)); - - tok = find_by_keyword(tokens, K_NETWORK_STATUS_VERSION); - tor_assert(tok); - if (tok->n_args > 1) { - int flavor = networkstatus_parse_flavor_name(tok->args[1]); - if (flavor < 0) { - log_warn(LD_DIR, "Can't parse document with unknown flavor %s", - escaped(tok->args[1])); - goto err; - } - ns->flavor = flav = flavor; - } - if (flav != FLAV_NS && ns_type != NS_TYPE_CONSENSUS) { - log_warn(LD_DIR, "Flavor found on non-consensus networkstatus."); - goto err; - } - - if (ns_type != NS_TYPE_CONSENSUS) { - const char *end_of_cert = NULL; - if (!(cert = strstr(s, "\ndir-key-certificate-version"))) - goto err; - ++cert; - ns->cert = authority_cert_parse_from_string(cert, &end_of_cert); - if (!ns->cert || !end_of_cert || end_of_cert > end_of_header) - goto err; - } - - tok = find_by_keyword(tokens, K_VOTE_STATUS); - tor_assert(tok->n_args); - if (!strcmp(tok->args[0], "vote")) { - ns->type = NS_TYPE_VOTE; - } else if (!strcmp(tok->args[0], "consensus")) { - ns->type = NS_TYPE_CONSENSUS; - } else if (!strcmp(tok->args[0], "opinion")) { - ns->type = NS_TYPE_OPINION; - } else { - log_warn(LD_DIR, "Unrecognized vote status %s in network-status", - escaped(tok->args[0])); - goto err; - } - if (ns_type != ns->type) { - log_warn(LD_DIR, "Got the wrong kind of v3 networkstatus."); - goto err; - } - - if (ns->type == NS_TYPE_VOTE || ns->type == NS_TYPE_OPINION) { - tok = find_by_keyword(tokens, K_PUBLISHED); - if (parse_iso_time(tok->args[0], &ns->published)) - goto err; - - ns->supported_methods = smartlist_new(); - tok = find_opt_by_keyword(tokens, K_CONSENSUS_METHODS); - if (tok) { - for (i=0; i < tok->n_args; ++i) - smartlist_add_strdup(ns->supported_methods, tok->args[i]); - } else { - smartlist_add_strdup(ns->supported_methods, "1"); - } - } else { - tok = find_opt_by_keyword(tokens, K_CONSENSUS_METHOD); - if (tok) { - int num_ok; - ns->consensus_method = (int)tor_parse_long(tok->args[0], 10, 1, INT_MAX, - &num_ok, NULL); - if (!num_ok) - goto err; - } else { - ns->consensus_method = 1; - } - } - - if ((tok = find_opt_by_keyword(tokens, K_RECOMMENDED_CLIENT_PROTOCOLS))) - ns->recommended_client_protocols = tor_strdup(tok->args[0]); - if ((tok = find_opt_by_keyword(tokens, K_RECOMMENDED_RELAY_PROTOCOLS))) - ns->recommended_relay_protocols = tor_strdup(tok->args[0]); - if ((tok = find_opt_by_keyword(tokens, K_REQUIRED_CLIENT_PROTOCOLS))) - ns->required_client_protocols = tor_strdup(tok->args[0]); - if ((tok = find_opt_by_keyword(tokens, K_REQUIRED_RELAY_PROTOCOLS))) - ns->required_relay_protocols = tor_strdup(tok->args[0]); - - tok = find_by_keyword(tokens, K_VALID_AFTER); - if (parse_iso_time(tok->args[0], &ns->valid_after)) - goto err; - - tok = find_by_keyword(tokens, K_FRESH_UNTIL); - if (parse_iso_time(tok->args[0], &ns->fresh_until)) - goto err; - - tok = find_by_keyword(tokens, K_VALID_UNTIL); - if (parse_iso_time(tok->args[0], &ns->valid_until)) - goto err; - - tok = find_by_keyword(tokens, K_VOTING_DELAY); - tor_assert(tok->n_args >= 2); - { - int ok; - ns->vote_seconds = - (int) tor_parse_long(tok->args[0], 10, 0, INT_MAX, &ok, NULL); - if (!ok) - goto err; - ns->dist_seconds = - (int) tor_parse_long(tok->args[1], 10, 0, INT_MAX, &ok, NULL); - if (!ok) - goto err; - } - if (ns->valid_after + - (get_options()->TestingTorNetwork ? - MIN_VOTE_INTERVAL_TESTING : MIN_VOTE_INTERVAL) > ns->fresh_until) { - log_warn(LD_DIR, "Vote/consensus freshness interval is too short"); - goto err; - } - if (ns->valid_after + - (get_options()->TestingTorNetwork ? - MIN_VOTE_INTERVAL_TESTING : MIN_VOTE_INTERVAL)*2 > ns->valid_until) { - log_warn(LD_DIR, "Vote/consensus liveness interval is too short"); - goto err; - } - if (ns->vote_seconds < MIN_VOTE_SECONDS) { - log_warn(LD_DIR, "Vote seconds is too short"); - goto err; - } - if (ns->dist_seconds < MIN_DIST_SECONDS) { - log_warn(LD_DIR, "Dist seconds is too short"); - goto err; - } - - if ((tok = find_opt_by_keyword(tokens, K_CLIENT_VERSIONS))) { - ns->client_versions = tor_strdup(tok->args[0]); - } - if ((tok = find_opt_by_keyword(tokens, K_SERVER_VERSIONS))) { - ns->server_versions = tor_strdup(tok->args[0]); - } - - { - smartlist_t *package_lst = find_all_by_keyword(tokens, K_PACKAGE); - ns->package_lines = smartlist_new(); - if (package_lst) { - SMARTLIST_FOREACH(package_lst, directory_token_t *, t, - smartlist_add_strdup(ns->package_lines, t->args[0])); - } - smartlist_free(package_lst); - } - - tok = find_by_keyword(tokens, K_KNOWN_FLAGS); - ns->known_flags = smartlist_new(); - inorder = 1; - for (i = 0; i < tok->n_args; ++i) { - smartlist_add_strdup(ns->known_flags, tok->args[i]); - if (i>0 && strcmp(tok->args[i-1], tok->args[i])>= 0) { - log_warn(LD_DIR, "%s >= %s", tok->args[i-1], tok->args[i]); - inorder = 0; - } - } - if (!inorder) { - log_warn(LD_DIR, "known-flags not in order"); - goto err; - } - if (ns->type != NS_TYPE_CONSENSUS && - smartlist_len(ns->known_flags) > MAX_KNOWN_FLAGS_IN_VOTE) { - /* If we allowed more than 64 flags in votes, then parsing them would make - * us invoke undefined behavior whenever we used 1<<flagnum to do a - * bit-shift. This is only for votes and opinions: consensus users don't - * care about flags they don't recognize, and so don't build a bitfield - * for them. */ - log_warn(LD_DIR, "Too many known-flags in consensus vote or opinion"); - goto err; - } - - tok = find_opt_by_keyword(tokens, K_PARAMS); - if (tok) { - int any_dups = 0; - inorder = 1; - ns->net_params = smartlist_new(); - for (i = 0; i < tok->n_args; ++i) { - int ok=0; - char *eq = strchr(tok->args[i], '='); - size_t eq_pos; - if (!eq) { - log_warn(LD_DIR, "Bad element '%s' in params", escaped(tok->args[i])); - goto err; - } - eq_pos = eq-tok->args[i]; - tor_parse_long(eq+1, 10, INT32_MIN, INT32_MAX, &ok, NULL); - if (!ok) { - log_warn(LD_DIR, "Bad element '%s' in params", escaped(tok->args[i])); - goto err; - } - if (i > 0 && strcmp(tok->args[i-1], tok->args[i]) >= 0) { - log_warn(LD_DIR, "%s >= %s", tok->args[i-1], tok->args[i]); - inorder = 0; - } - if (last_kwd && eq_pos == strlen(last_kwd) && - fast_memeq(last_kwd, tok->args[i], eq_pos)) { - log_warn(LD_DIR, "Duplicate value for %s parameter", - escaped(tok->args[i])); - any_dups = 1; - } - tor_free(last_kwd); - last_kwd = tor_strndup(tok->args[i], eq_pos); - smartlist_add_strdup(ns->net_params, tok->args[i]); - } - if (!inorder) { - log_warn(LD_DIR, "params not in order"); - goto err; - } - if (any_dups) { - log_warn(LD_DIR, "Duplicate in parameters"); - goto err; - } - } - - ns->voters = smartlist_new(); - - SMARTLIST_FOREACH_BEGIN(tokens, directory_token_t *, _tok) { - tok = _tok; - if (tok->tp == K_DIR_SOURCE) { - tor_assert(tok->n_args >= 6); - - if (voter) - smartlist_add(ns->voters, voter); - voter = tor_malloc_zero(sizeof(networkstatus_voter_info_t)); - voter->sigs = smartlist_new(); - if (ns->type != NS_TYPE_CONSENSUS) - memcpy(voter->vote_digest, ns_digests.d[DIGEST_SHA1], DIGEST_LEN); - - voter->nickname = tor_strdup(tok->args[0]); - if (strlen(tok->args[1]) != HEX_DIGEST_LEN || - base16_decode(voter->identity_digest, sizeof(voter->identity_digest), - tok->args[1], HEX_DIGEST_LEN) - != sizeof(voter->identity_digest)) { - log_warn(LD_DIR, "Error decoding identity digest %s in " - "network-status document.", escaped(tok->args[1])); - goto err; - } - if (ns->type != NS_TYPE_CONSENSUS && - tor_memneq(ns->cert->cache_info.identity_digest, - voter->identity_digest, DIGEST_LEN)) { - log_warn(LD_DIR,"Mismatch between identities in certificate and vote"); - goto err; - } - if (ns->type != NS_TYPE_CONSENSUS) { - if (authority_cert_is_blacklisted(ns->cert)) { - log_warn(LD_DIR, "Rejecting vote signature made with blacklisted " - "signing key %s", - hex_str(ns->cert->signing_key_digest, DIGEST_LEN)); - goto err; - } - } - voter->address = tor_strdup(tok->args[2]); - if (!tor_inet_aton(tok->args[3], &in)) { - log_warn(LD_DIR, "Error decoding IP address %s in network-status.", - escaped(tok->args[3])); - goto err; - } - voter->addr = ntohl(in.s_addr); - int ok; - voter->dir_port = (uint16_t) - tor_parse_long(tok->args[4], 10, 0, 65535, &ok, NULL); - if (!ok) - goto err; - voter->or_port = (uint16_t) - tor_parse_long(tok->args[5], 10, 0, 65535, &ok, NULL); - if (!ok) - goto err; - } else if (tok->tp == K_CONTACT) { - if (!voter || voter->contact) { - log_warn(LD_DIR, "contact element is out of place."); - goto err; - } - voter->contact = tor_strdup(tok->args[0]); - } else if (tok->tp == K_VOTE_DIGEST) { - tor_assert(ns->type == NS_TYPE_CONSENSUS); - tor_assert(tok->n_args >= 1); - if (!voter || ! tor_digest_is_zero(voter->vote_digest)) { - log_warn(LD_DIR, "vote-digest element is out of place."); - goto err; - } - if (strlen(tok->args[0]) != HEX_DIGEST_LEN || - base16_decode(voter->vote_digest, sizeof(voter->vote_digest), - tok->args[0], HEX_DIGEST_LEN) - != sizeof(voter->vote_digest)) { - log_warn(LD_DIR, "Error decoding vote digest %s in " - "network-status consensus.", escaped(tok->args[0])); - goto err; - } - } - } SMARTLIST_FOREACH_END(_tok); - if (voter) { - smartlist_add(ns->voters, voter); - voter = NULL; - } - if (smartlist_len(ns->voters) == 0) { - log_warn(LD_DIR, "Missing dir-source elements in a networkstatus."); - goto err; - } else if (ns->type != NS_TYPE_CONSENSUS && smartlist_len(ns->voters) != 1) { - log_warn(LD_DIR, "Too many dir-source elements in a vote networkstatus."); - goto err; - } - - if (ns->type != NS_TYPE_CONSENSUS && - (tok = find_opt_by_keyword(tokens, K_LEGACY_DIR_KEY))) { - int bad = 1; - if (strlen(tok->args[0]) == HEX_DIGEST_LEN) { - networkstatus_voter_info_t *voter_0 = smartlist_get(ns->voters, 0); - if (base16_decode(voter_0->legacy_id_digest, DIGEST_LEN, - tok->args[0], HEX_DIGEST_LEN) != DIGEST_LEN) - bad = 1; - else - bad = 0; - } - if (bad) { - log_warn(LD_DIR, "Invalid legacy key digest %s on vote.", - escaped(tok->args[0])); - } - } - - /* If this is a vote document, check if information about the shared - randomness protocol is included, and extract it. */ - if (ns->type == NS_TYPE_VOTE) { - dirvote_parse_sr_commits(ns, tokens); - } - /* For both a vote and consensus, extract the shared random values. */ - if (ns->type == NS_TYPE_VOTE || ns->type == NS_TYPE_CONSENSUS) { - extract_shared_random_srvs(ns, tokens); - } - - /* Parse routerstatus lines. */ - rs_tokens = smartlist_new(); - rs_area = memarea_new(); - s = end_of_header; - ns->routerstatus_list = smartlist_new(); - - while (!strcmpstart(s, "r ")) { - if (ns->type != NS_TYPE_CONSENSUS) { - vote_routerstatus_t *rs = tor_malloc_zero(sizeof(vote_routerstatus_t)); - if (routerstatus_parse_entry_from_string(rs_area, &s, rs_tokens, ns, - rs, 0, 0)) { - smartlist_add(ns->routerstatus_list, rs); - } else { - vote_routerstatus_free(rs); - } - } else { - routerstatus_t *rs; - if ((rs = routerstatus_parse_entry_from_string(rs_area, &s, rs_tokens, - NULL, NULL, - ns->consensus_method, - flav))) { - /* Use exponential-backoff scheduling when downloading microdescs */ - smartlist_add(ns->routerstatus_list, rs); - } - } - } - for (i = 1; i < smartlist_len(ns->routerstatus_list); ++i) { - routerstatus_t *rs1, *rs2; - if (ns->type != NS_TYPE_CONSENSUS) { - vote_routerstatus_t *a = smartlist_get(ns->routerstatus_list, i-1); - vote_routerstatus_t *b = smartlist_get(ns->routerstatus_list, i); - rs1 = &a->status; rs2 = &b->status; - } else { - rs1 = smartlist_get(ns->routerstatus_list, i-1); - rs2 = smartlist_get(ns->routerstatus_list, i); - } - if (fast_memcmp(rs1->identity_digest, rs2->identity_digest, DIGEST_LEN) - >= 0) { - log_warn(LD_DIR, "Networkstatus entries not sorted by identity digest"); - goto err; - } - } - if (ns_type != NS_TYPE_CONSENSUS) { - digest256map_t *ed_id_map = digest256map_new(); - SMARTLIST_FOREACH_BEGIN(ns->routerstatus_list, vote_routerstatus_t *, - vrs) { - if (! vrs->has_ed25519_listing || - tor_mem_is_zero((const char *)vrs->ed25519_id, DIGEST256_LEN)) - continue; - if (digest256map_get(ed_id_map, vrs->ed25519_id) != NULL) { - log_warn(LD_DIR, "Vote networkstatus ed25519 identities were not " - "unique"); - digest256map_free(ed_id_map, NULL); - goto err; - } - digest256map_set(ed_id_map, vrs->ed25519_id, (void*)1); - } SMARTLIST_FOREACH_END(vrs); - digest256map_free(ed_id_map, NULL); - } - - /* Parse footer; check signature. */ - footer_tokens = smartlist_new(); - if ((end_of_footer = strstr(s, "\nnetwork-status-version "))) - ++end_of_footer; - else - end_of_footer = s + strlen(s); - if (tokenize_string(area,s, end_of_footer, footer_tokens, - networkstatus_vote_footer_token_table, 0)) { - log_warn(LD_DIR, "Error tokenizing network-status vote footer."); - goto err; - } - - { - int found_sig = 0; - SMARTLIST_FOREACH_BEGIN(footer_tokens, directory_token_t *, _tok) { - tok = _tok; - if (tok->tp == K_DIRECTORY_SIGNATURE) - found_sig = 1; - else if (found_sig) { - log_warn(LD_DIR, "Extraneous token after first directory-signature"); - goto err; - } - } SMARTLIST_FOREACH_END(_tok); - } - - if ((tok = find_opt_by_keyword(footer_tokens, K_DIRECTORY_FOOTER))) { - if (tok != smartlist_get(footer_tokens, 0)) { - log_warn(LD_DIR, "Misplaced directory-footer token"); - goto err; - } - } - - tok = find_opt_by_keyword(footer_tokens, K_BW_WEIGHTS); - if (tok) { - ns->weight_params = smartlist_new(); - for (i = 0; i < tok->n_args; ++i) { - int ok=0; - char *eq = strchr(tok->args[i], '='); - if (!eq) { - log_warn(LD_DIR, "Bad element '%s' in weight params", - escaped(tok->args[i])); - goto err; - } - tor_parse_long(eq+1, 10, INT32_MIN, INT32_MAX, &ok, NULL); - if (!ok) { - log_warn(LD_DIR, "Bad element '%s' in params", escaped(tok->args[i])); - goto err; - } - smartlist_add_strdup(ns->weight_params, tok->args[i]); - } - } - - SMARTLIST_FOREACH_BEGIN(footer_tokens, directory_token_t *, _tok) { - char declared_identity[DIGEST_LEN]; - networkstatus_voter_info_t *v; - document_signature_t *sig; - const char *id_hexdigest = NULL; - const char *sk_hexdigest = NULL; - digest_algorithm_t alg = DIGEST_SHA1; - tok = _tok; - if (tok->tp != K_DIRECTORY_SIGNATURE) - continue; - tor_assert(tok->n_args >= 2); - if (tok->n_args == 2) { - id_hexdigest = tok->args[0]; - sk_hexdigest = tok->args[1]; - } else { - const char *algname = tok->args[0]; - int a; - id_hexdigest = tok->args[1]; - sk_hexdigest = tok->args[2]; - a = crypto_digest_algorithm_parse_name(algname); - if (a<0) { - log_warn(LD_DIR, "Unknown digest algorithm %s; skipping", - escaped(algname)); - continue; - } - alg = a; - } - - if (!tok->object_type || - strcmp(tok->object_type, "SIGNATURE") || - tok->object_size < 128 || tok->object_size > 512) { - log_warn(LD_DIR, "Bad object type or length on directory-signature"); - goto err; - } - - if (strlen(id_hexdigest) != HEX_DIGEST_LEN || - base16_decode(declared_identity, sizeof(declared_identity), - id_hexdigest, HEX_DIGEST_LEN) - != sizeof(declared_identity)) { - log_warn(LD_DIR, "Error decoding declared identity %s in " - "network-status document.", escaped(id_hexdigest)); - goto err; - } - if (!(v = networkstatus_get_voter_by_id(ns, declared_identity))) { - log_warn(LD_DIR, "ID on signature on network-status document does " - "not match any declared directory source."); - goto err; - } - sig = tor_malloc_zero(sizeof(document_signature_t)); - memcpy(sig->identity_digest, v->identity_digest, DIGEST_LEN); - sig->alg = alg; - if (strlen(sk_hexdigest) != HEX_DIGEST_LEN || - base16_decode(sig->signing_key_digest, sizeof(sig->signing_key_digest), - sk_hexdigest, HEX_DIGEST_LEN) - != sizeof(sig->signing_key_digest)) { - log_warn(LD_DIR, "Error decoding declared signing key digest %s in " - "network-status document.", escaped(sk_hexdigest)); - tor_free(sig); - goto err; - } - - if (ns->type != NS_TYPE_CONSENSUS) { - if (tor_memneq(declared_identity, ns->cert->cache_info.identity_digest, - DIGEST_LEN)) { - log_warn(LD_DIR, "Digest mismatch between declared and actual on " - "network-status vote."); - tor_free(sig); - goto err; - } - } - - if (networkstatus_get_voter_sig_by_alg(v, sig->alg)) { - /* We already parsed a vote with this algorithm from this voter. Use the - first one. */ - log_fn(LOG_PROTOCOL_WARN, LD_DIR, "We received a networkstatus " - "that contains two signatures from the same voter with the same " - "algorithm. Ignoring the second signature."); - tor_free(sig); - continue; - } - - if (ns->type != NS_TYPE_CONSENSUS) { - if (check_signature_token(ns_digests.d[DIGEST_SHA1], DIGEST_LEN, - tok, ns->cert->signing_key, 0, - "network-status document")) { - tor_free(sig); - goto err; - } - sig->good_signature = 1; - } else { - if (tok->object_size >= INT_MAX || tok->object_size >= SIZE_T_CEILING) { - tor_free(sig); - goto err; - } - sig->signature = tor_memdup(tok->object_body, tok->object_size); - sig->signature_len = (int) tok->object_size; - } - smartlist_add(v->sigs, sig); - - ++n_signatures; - } SMARTLIST_FOREACH_END(_tok); - - if (! n_signatures) { - log_warn(LD_DIR, "No signatures on networkstatus document."); - goto err; - } else if (ns->type == NS_TYPE_VOTE && n_signatures != 1) { - log_warn(LD_DIR, "Received more than one signature on a " - "network-status vote."); - goto err; - } - - if (eos_out) - *eos_out = end_of_footer; - - goto done; - err: - dump_desc(s_dup, "v3 networkstatus"); - networkstatus_vote_free(ns); - ns = NULL; - done: - if (tokens) { - SMARTLIST_FOREACH(tokens, directory_token_t *, t, token_clear(t)); - smartlist_free(tokens); - } - if (voter) { - if (voter->sigs) { - SMARTLIST_FOREACH(voter->sigs, document_signature_t *, sig, - document_signature_free(sig)); - smartlist_free(voter->sigs); - } - tor_free(voter->nickname); - tor_free(voter->address); - tor_free(voter->contact); - tor_free(voter); - } - if (rs_tokens) { - SMARTLIST_FOREACH(rs_tokens, directory_token_t *, t, token_clear(t)); - smartlist_free(rs_tokens); - } - if (footer_tokens) { - SMARTLIST_FOREACH(footer_tokens, directory_token_t *, t, token_clear(t)); - smartlist_free(footer_tokens); - } - if (area) { - DUMP_AREA(area, "v3 networkstatus"); - memarea_drop_all(area); - } - if (rs_area) - memarea_drop_all(rs_area); - tor_free(last_kwd); - - return ns; -} - -/** Return the common_digests_t that holds the digests of the - * <b>flavor_name</b>-flavored networkstatus according to the detached - * signatures document <b>sigs</b>, allocating a new common_digests_t as - * needed. */ -static common_digests_t * -detached_get_digests(ns_detached_signatures_t *sigs, const char *flavor_name) -{ - common_digests_t *d = strmap_get(sigs->digests, flavor_name); - if (!d) { - d = tor_malloc_zero(sizeof(common_digests_t)); - strmap_set(sigs->digests, flavor_name, d); - } - return d; -} - -/** Return the list of signatures of the <b>flavor_name</b>-flavored - * networkstatus according to the detached signatures document <b>sigs</b>, - * allocating a new common_digests_t as needed. */ -static smartlist_t * -detached_get_signatures(ns_detached_signatures_t *sigs, - const char *flavor_name) -{ - smartlist_t *sl = strmap_get(sigs->signatures, flavor_name); - if (!sl) { - sl = smartlist_new(); - strmap_set(sigs->signatures, flavor_name, sl); - } - return sl; -} - -/** Parse a detached v3 networkstatus signature document between <b>s</b> and - * <b>eos</b> and return the result. Return -1 on failure. */ -ns_detached_signatures_t * -networkstatus_parse_detached_signatures(const char *s, const char *eos) -{ - /* XXXX there is too much duplicate shared between this function and - * networkstatus_parse_vote_from_string(). */ - directory_token_t *tok; - memarea_t *area = NULL; - common_digests_t *digests; - - smartlist_t *tokens = smartlist_new(); - ns_detached_signatures_t *sigs = - tor_malloc_zero(sizeof(ns_detached_signatures_t)); - sigs->digests = strmap_new(); - sigs->signatures = strmap_new(); - - if (!eos) - eos = s + strlen(s); - - area = memarea_new(); - if (tokenize_string(area,s, eos, tokens, - networkstatus_detached_signature_token_table, 0)) { - log_warn(LD_DIR, "Error tokenizing detached networkstatus signatures"); - goto err; - } - - /* Grab all the digest-like tokens. */ - SMARTLIST_FOREACH_BEGIN(tokens, directory_token_t *, _tok) { - const char *algname; - digest_algorithm_t alg; - const char *flavor; - const char *hexdigest; - size_t expected_length, digest_length; - - tok = _tok; - - if (tok->tp == K_CONSENSUS_DIGEST) { - algname = "sha1"; - alg = DIGEST_SHA1; - flavor = "ns"; - hexdigest = tok->args[0]; - } else if (tok->tp == K_ADDITIONAL_DIGEST) { - int a = crypto_digest_algorithm_parse_name(tok->args[1]); - if (a<0) { - log_warn(LD_DIR, "Unrecognized algorithm name %s", tok->args[0]); - continue; - } - alg = (digest_algorithm_t) a; - flavor = tok->args[0]; - algname = tok->args[1]; - hexdigest = tok->args[2]; - } else { - continue; - } - - digest_length = crypto_digest_algorithm_get_length(alg); - expected_length = digest_length * 2; /* hex encoding */ - - if (strlen(hexdigest) != expected_length) { - log_warn(LD_DIR, "Wrong length on consensus-digest in detached " - "networkstatus signatures"); - goto err; - } - digests = detached_get_digests(sigs, flavor); - tor_assert(digests); - if (!tor_mem_is_zero(digests->d[alg], digest_length)) { - log_warn(LD_DIR, "Multiple digests for %s with %s on detached " - "signatures document", flavor, algname); - continue; - } - if (base16_decode(digests->d[alg], digest_length, - hexdigest, strlen(hexdigest)) != (int) digest_length) { - log_warn(LD_DIR, "Bad encoding on consensus-digest in detached " - "networkstatus signatures"); - goto err; - } - } SMARTLIST_FOREACH_END(_tok); - - tok = find_by_keyword(tokens, K_VALID_AFTER); - if (parse_iso_time(tok->args[0], &sigs->valid_after)) { - log_warn(LD_DIR, "Bad valid-after in detached networkstatus signatures"); - goto err; - } - - tok = find_by_keyword(tokens, K_FRESH_UNTIL); - if (parse_iso_time(tok->args[0], &sigs->fresh_until)) { - log_warn(LD_DIR, "Bad fresh-until in detached networkstatus signatures"); - goto err; - } - - tok = find_by_keyword(tokens, K_VALID_UNTIL); - if (parse_iso_time(tok->args[0], &sigs->valid_until)) { - log_warn(LD_DIR, "Bad valid-until in detached networkstatus signatures"); - goto err; - } - - SMARTLIST_FOREACH_BEGIN(tokens, directory_token_t *, _tok) { - const char *id_hexdigest; - const char *sk_hexdigest; - const char *algname; - const char *flavor; - digest_algorithm_t alg; - - char id_digest[DIGEST_LEN]; - char sk_digest[DIGEST_LEN]; - smartlist_t *siglist; - document_signature_t *sig; - int is_duplicate; - - tok = _tok; - if (tok->tp == K_DIRECTORY_SIGNATURE) { - tor_assert(tok->n_args >= 2); - flavor = "ns"; - algname = "sha1"; - id_hexdigest = tok->args[0]; - sk_hexdigest = tok->args[1]; - } else if (tok->tp == K_ADDITIONAL_SIGNATURE) { - tor_assert(tok->n_args >= 4); - flavor = tok->args[0]; - algname = tok->args[1]; - id_hexdigest = tok->args[2]; - sk_hexdigest = tok->args[3]; - } else { - continue; - } - - { - int a = crypto_digest_algorithm_parse_name(algname); - if (a<0) { - log_warn(LD_DIR, "Unrecognized algorithm name %s", algname); - continue; - } - alg = (digest_algorithm_t) a; - } - - if (!tok->object_type || - strcmp(tok->object_type, "SIGNATURE") || - tok->object_size < 128 || tok->object_size > 512) { - log_warn(LD_DIR, "Bad object type or length on directory-signature"); - goto err; - } - - if (strlen(id_hexdigest) != HEX_DIGEST_LEN || - base16_decode(id_digest, sizeof(id_digest), - id_hexdigest, HEX_DIGEST_LEN) != sizeof(id_digest)) { - log_warn(LD_DIR, "Error decoding declared identity %s in " - "network-status vote.", escaped(id_hexdigest)); - goto err; - } - if (strlen(sk_hexdigest) != HEX_DIGEST_LEN || - base16_decode(sk_digest, sizeof(sk_digest), - sk_hexdigest, HEX_DIGEST_LEN) != sizeof(sk_digest)) { - log_warn(LD_DIR, "Error decoding declared signing key digest %s in " - "network-status vote.", escaped(sk_hexdigest)); - goto err; - } - - siglist = detached_get_signatures(sigs, flavor); - is_duplicate = 0; - SMARTLIST_FOREACH(siglist, document_signature_t *, dsig, { - if (dsig->alg == alg && - tor_memeq(id_digest, dsig->identity_digest, DIGEST_LEN) && - tor_memeq(sk_digest, dsig->signing_key_digest, DIGEST_LEN)) { - is_duplicate = 1; - } - }); - if (is_duplicate) { - log_warn(LD_DIR, "Two signatures with identical keys and algorithm " - "found."); - continue; - } - - sig = tor_malloc_zero(sizeof(document_signature_t)); - sig->alg = alg; - memcpy(sig->identity_digest, id_digest, DIGEST_LEN); - memcpy(sig->signing_key_digest, sk_digest, DIGEST_LEN); - if (tok->object_size >= INT_MAX || tok->object_size >= SIZE_T_CEILING) { - tor_free(sig); - goto err; - } - sig->signature = tor_memdup(tok->object_body, tok->object_size); - sig->signature_len = (int) tok->object_size; - - smartlist_add(siglist, sig); - } SMARTLIST_FOREACH_END(_tok); - - goto done; - err: - ns_detached_signatures_free(sigs); - sigs = NULL; - done: - SMARTLIST_FOREACH(tokens, directory_token_t *, t, token_clear(t)); - smartlist_free(tokens); - if (area) { - DUMP_AREA(area, "detached signatures"); - memarea_drop_all(area); - } - return sigs; -} - -/** Parse the addr policy in the string <b>s</b> and return it. If - * assume_action is nonnegative, then insert its action (ADDR_POLICY_ACCEPT or - * ADDR_POLICY_REJECT) for items that specify no action. - * - * Returns NULL on policy errors. - * - * Set *<b>malformed_list</b> to true if the entire policy list should be - * discarded. Otherwise, set it to false, and only this item should be ignored - * on error - the rest of the policy list can continue to be processed and - * used. - * - * The addr_policy_t returned by this function can have its address set to - * AF_UNSPEC for '*'. Use policy_expand_unspec() to turn this into a pair - * of AF_INET and AF_INET6 items. - */ -MOCK_IMPL(addr_policy_t *, -router_parse_addr_policy_item_from_string,(const char *s, int assume_action, - int *malformed_list)) -{ - directory_token_t *tok = NULL; - const char *cp, *eos; - /* Longest possible policy is - * "accept6 [ffff:ffff:..255]/128:10000-65535", - * which contains a max-length IPv6 address, plus 26 characters. - * But note that there can be an arbitrary amount of space between the - * accept and the address:mask/port element. - * We don't need to multiply TOR_ADDR_BUF_LEN by 2, as there is only one - * IPv6 address. But making the buffer shorter might cause valid long lines, - * which parsed in previous versions, to fail to parse in new versions. - * (These lines would have to have excessive amounts of whitespace.) */ - char line[TOR_ADDR_BUF_LEN*2 + 32]; - addr_policy_t *r; - memarea_t *area = NULL; - - tor_assert(malformed_list); - *malformed_list = 0; - - s = eat_whitespace(s); - /* We can only do assume_action on []-quoted IPv6, as "a" (accept) - * and ":" (port separator) are ambiguous */ - if ((*s == '*' || *s == '[' || TOR_ISDIGIT(*s)) && assume_action >= 0) { - if (tor_snprintf(line, sizeof(line), "%s %s", - assume_action == ADDR_POLICY_ACCEPT?"accept":"reject", s)<0) { - log_warn(LD_DIR, "Policy %s is too long.", escaped(s)); - return NULL; - } - cp = line; - tor_strlower(line); - } else { /* assume an already well-formed address policy line */ - cp = s; - } - - eos = cp + strlen(cp); - area = memarea_new(); - tok = get_next_token(area, &cp, eos, routerdesc_token_table); - if (tok->tp == ERR_) { - log_warn(LD_DIR, "Error reading address policy: %s", tok->error); - goto err; - } - if (tok->tp != K_ACCEPT && tok->tp != K_ACCEPT6 && - tok->tp != K_REJECT && tok->tp != K_REJECT6) { - log_warn(LD_DIR, "Expected 'accept' or 'reject'."); - goto err; - } - - /* Use the extended interpretation of accept/reject *, - * expanding it into an IPv4 wildcard and an IPv6 wildcard. - * Also permit *4 and *6 for IPv4 and IPv6 only wildcards. */ - r = router_parse_addr_policy(tok, TAPMP_EXTENDED_STAR); - if (!r) { - goto err; - } - - /* Ensure that accept6/reject6 fields are followed by IPv6 addresses. - * AF_UNSPEC addresses are only permitted on the accept/reject field type. - * Unlike descriptors, torrcs exit policy accept/reject can be followed by - * either an IPv4 or IPv6 address. */ - if ((tok->tp == K_ACCEPT6 || tok->tp == K_REJECT6) && - tor_addr_family(&r->addr) != AF_INET6) { - /* This is a non-fatal error, just ignore this one entry. */ - *malformed_list = 0; - log_warn(LD_DIR, "IPv4 address '%s' with accept6/reject6 field type in " - "exit policy. Ignoring, but continuing to parse rules. (Use " - "accept/reject with IPv4 addresses.)", - tok->n_args == 1 ? tok->args[0] : ""); - addr_policy_free(r); - r = NULL; - goto done; - } - - goto done; - err: - *malformed_list = 1; - r = NULL; - done: - token_clear(tok); - if (area) { - DUMP_AREA(area, "policy item"); - memarea_drop_all(area); - } - return r; -} - -/** Add an exit policy stored in the token <b>tok</b> to the router info in - * <b>router</b>. Return 0 on success, -1 on failure. */ -static int -router_add_exit_policy(routerinfo_t *router, directory_token_t *tok) -{ - addr_policy_t *newe; - /* Use the standard interpretation of accept/reject *, an IPv4 wildcard. */ - newe = router_parse_addr_policy(tok, 0); - if (!newe) - return -1; - if (! router->exit_policy) - router->exit_policy = smartlist_new(); - - /* Ensure that in descriptors, accept/reject fields are followed by - * IPv4 addresses, and accept6/reject6 fields are followed by - * IPv6 addresses. Unlike torrcs, descriptor exit policies do not permit - * accept/reject followed by IPv6. */ - if (((tok->tp == K_ACCEPT6 || tok->tp == K_REJECT6) && - tor_addr_family(&newe->addr) == AF_INET) - || - ((tok->tp == K_ACCEPT || tok->tp == K_REJECT) && - tor_addr_family(&newe->addr) == AF_INET6)) { - /* There's nothing the user can do about other relays' descriptors, - * so we don't provide usage advice here. */ - log_warn(LD_DIR, "Mismatch between field type and address type in exit " - "policy '%s'. Discarding entire router descriptor.", - tok->n_args == 1 ? tok->args[0] : ""); - addr_policy_free(newe); - return -1; - } - - smartlist_add(router->exit_policy, newe); - - return 0; -} - -/** Given a K_ACCEPT[6] or K_REJECT[6] token and a router, create and return - * a new exit_policy_t corresponding to the token. If TAPMP_EXTENDED_STAR - * is set in fmt_flags, K_ACCEPT6 and K_REJECT6 tokens followed by * - * expand to IPv6-only policies, otherwise they expand to IPv4 and IPv6 - * policies */ -static addr_policy_t * -router_parse_addr_policy(directory_token_t *tok, unsigned fmt_flags) -{ - addr_policy_t newe; - char *arg; - - tor_assert(tok->tp == K_REJECT || tok->tp == K_REJECT6 || - tok->tp == K_ACCEPT || tok->tp == K_ACCEPT6); - - if (tok->n_args != 1) - return NULL; - arg = tok->args[0]; - - if (!strcmpstart(arg,"private")) - return router_parse_addr_policy_private(tok); - - memset(&newe, 0, sizeof(newe)); - - if (tok->tp == K_REJECT || tok->tp == K_REJECT6) - newe.policy_type = ADDR_POLICY_REJECT; - else - newe.policy_type = ADDR_POLICY_ACCEPT; - - /* accept6/reject6 * produces an IPv6 wildcard address only. - * (accept/reject * produces rules for IPv4 and IPv6 wildcard addresses.) */ - if ((fmt_flags & TAPMP_EXTENDED_STAR) - && (tok->tp == K_ACCEPT6 || tok->tp == K_REJECT6)) { - fmt_flags |= TAPMP_STAR_IPV6_ONLY; - } - - if (tor_addr_parse_mask_ports(arg, fmt_flags, &newe.addr, &newe.maskbits, - &newe.prt_min, &newe.prt_max) < 0) { - log_warn(LD_DIR,"Couldn't parse line %s. Dropping", escaped(arg)); - return NULL; - } - - return addr_policy_get_canonical_entry(&newe); -} - -/** Parse an exit policy line of the format "accept[6]/reject[6] private:...". - * This didn't exist until Tor 0.1.1.15, so nobody should generate it in - * router descriptors until earlier versions are obsolete. - * - * accept/reject and accept6/reject6 private all produce rules for both - * IPv4 and IPv6 addresses. - */ -static addr_policy_t * -router_parse_addr_policy_private(directory_token_t *tok) -{ - const char *arg; - uint16_t port_min, port_max; - addr_policy_t result; - - arg = tok->args[0]; - if (strcmpstart(arg, "private")) - return NULL; - - arg += strlen("private"); - arg = (char*) eat_whitespace(arg); - if (!arg || *arg != ':') - return NULL; - - if (parse_port_range(arg+1, &port_min, &port_max)<0) - return NULL; - - memset(&result, 0, sizeof(result)); - if (tok->tp == K_REJECT || tok->tp == K_REJECT6) - result.policy_type = ADDR_POLICY_REJECT; - else - result.policy_type = ADDR_POLICY_ACCEPT; - result.is_private = 1; - result.prt_min = port_min; - result.prt_max = port_max; - - if (tok->tp == K_ACCEPT6 || tok->tp == K_REJECT6) { - log_warn(LD_GENERAL, - "'%s' expands into rules which apply to all private IPv4 and " - "IPv6 addresses. (Use accept/reject private:* for IPv4 and " - "IPv6.)", tok->n_args == 1 ? tok->args[0] : ""); - } - - return addr_policy_get_canonical_entry(&result); -} - -/** Log and exit if <b>t</b> is malformed */ -void -assert_addr_policy_ok(smartlist_t *lst) -{ - if (!lst) return; - SMARTLIST_FOREACH(lst, addr_policy_t *, t, { - tor_assert(t->policy_type == ADDR_POLICY_REJECT || - t->policy_type == ADDR_POLICY_ACCEPT); - tor_assert(t->prt_min <= t->prt_max); - }); -} - -/** Return a newly allocated smartlist of all accept or reject tokens in - * <b>s</b>. - */ -static smartlist_t * -find_all_exitpolicy(smartlist_t *s) -{ - smartlist_t *out = smartlist_new(); - SMARTLIST_FOREACH(s, directory_token_t *, t, - if (t->tp == K_ACCEPT || t->tp == K_ACCEPT6 || - t->tp == K_REJECT || t->tp == K_REJECT6) - smartlist_add(out,t)); - return out; -} - -/** Helper function for <b>router_get_hash_impl</b>: given <b>s</b>, - * <b>s_len</b>, <b>start_str</b>, <b>end_str</b>, and <b>end_c</b> with the - * same semantics as in that function, set *<b>start_out</b> (inclusive) and - * *<b>end_out</b> (exclusive) to the boundaries of the string to be hashed. - * - * Return 0 on success and -1 on failure. - */ -static int -router_get_hash_impl_helper(const char *s, size_t s_len, - const char *start_str, - const char *end_str, char end_c, - int log_severity, - const char **start_out, const char **end_out) -{ - const char *start, *end; - start = tor_memstr(s, s_len, start_str); - if (!start) { - log_fn(log_severity,LD_DIR, - "couldn't find start of hashed material \"%s\"",start_str); - return -1; - } - if (start != s && *(start-1) != '\n') { - log_fn(log_severity,LD_DIR, - "first occurrence of \"%s\" is not at the start of a line", - start_str); - return -1; - } - end = tor_memstr(start+strlen(start_str), - s_len - (start-s) - strlen(start_str), end_str); - if (!end) { - log_fn(log_severity,LD_DIR, - "couldn't find end of hashed material \"%s\"",end_str); - return -1; - } - end = memchr(end+strlen(end_str), end_c, s_len - (end-s) - strlen(end_str)); - if (!end) { - log_fn(log_severity,LD_DIR, - "couldn't find EOL"); - return -1; - } - ++end; - - *start_out = start; - *end_out = end; - return 0; -} - -/** Compute the digest of the substring of <b>s</b> taken from the first - * occurrence of <b>start_str</b> through the first instance of c after the - * first subsequent occurrence of <b>end_str</b>; store the 20-byte or 32-byte - * result in <b>digest</b>; return 0 on success. - * - * If no such substring exists, return -1. - */ -static int -router_get_hash_impl(const char *s, size_t s_len, char *digest, - const char *start_str, - const char *end_str, char end_c, - digest_algorithm_t alg) -{ - const char *start=NULL, *end=NULL; - if (router_get_hash_impl_helper(s,s_len,start_str,end_str,end_c,LOG_WARN, - &start,&end)<0) - return -1; - - return router_compute_hash_final(digest, start, end-start, alg); -} - -/** Compute the digest of the <b>len</b>-byte directory object at - * <b>start</b>, using <b>alg</b>. Store the result in <b>digest</b>, which - * must be long enough to hold it. */ -MOCK_IMPL(STATIC int, -router_compute_hash_final,(char *digest, - const char *start, size_t len, - digest_algorithm_t alg)) -{ - if (alg == DIGEST_SHA1) { - if (crypto_digest(digest, start, len) < 0) { - log_warn(LD_BUG,"couldn't compute digest"); - return -1; - } - } else { - if (crypto_digest256(digest, start, len, alg) < 0) { - log_warn(LD_BUG,"couldn't compute digest"); - return -1; - } - } - - return 0; -} - -/** As router_get_hash_impl, but compute all hashes. */ -static int -router_get_hashes_impl(const char *s, size_t s_len, common_digests_t *digests, - const char *start_str, - const char *end_str, char end_c) -{ - const char *start=NULL, *end=NULL; - if (router_get_hash_impl_helper(s,s_len,start_str,end_str,end_c,LOG_WARN, - &start,&end)<0) - return -1; - - if (crypto_common_digests(digests, start, end-start)) { - log_warn(LD_BUG,"couldn't compute digests"); - return -1; - } - - return 0; -} - -/** Assuming that s starts with a microdesc, return the start of the - * *NEXT* one. Return NULL on "not found." */ -static const char * -find_start_of_next_microdesc(const char *s, const char *eos) -{ - int started_with_annotations; - s = eat_whitespace_eos(s, eos); - if (!s) - return NULL; - -#define CHECK_LENGTH() STMT_BEGIN \ - if (s+32 > eos) \ - return NULL; \ - STMT_END - -#define NEXT_LINE() STMT_BEGIN \ - s = memchr(s, '\n', eos-s); \ - if (!s || s+1 >= eos) \ - return NULL; \ - s++; \ - STMT_END - - CHECK_LENGTH(); - - started_with_annotations = (*s == '@'); - - if (started_with_annotations) { - /* Start by advancing to the first non-annotation line. */ - while (*s == '@') - NEXT_LINE(); - } - CHECK_LENGTH(); - - /* Now we should be pointed at an onion-key line. If we are, then skip - * it. */ - if (!strcmpstart(s, "onion-key")) - NEXT_LINE(); - - /* Okay, now we're pointed at the first line of the microdescriptor which is - not an annotation or onion-key. The next line that _is_ an annotation or - onion-key is the start of the next microdescriptor. */ - while (s+32 < eos) { - if (*s == '@' || !strcmpstart(s, "onion-key")) - return s; - NEXT_LINE(); - } - return NULL; - -#undef CHECK_LENGTH -#undef NEXT_LINE -} - -/** Parse as many microdescriptors as are found from the string starting at - * <b>s</b> and ending at <b>eos</b>. If allow_annotations is set, read any - * annotations we recognize and ignore ones we don't. - * - * If <b>saved_location</b> isn't SAVED_IN_CACHE, make a local copy of each - * descriptor in the body field of each microdesc_t. - * - * Return all newly parsed microdescriptors in a newly allocated - * smartlist_t. If <b>invalid_disgests_out</b> is provided, add a SHA256 - * microdesc digest to it for every microdesc that we found to be badly - * formed. (This may cause duplicates) */ -smartlist_t * -microdescs_parse_from_string(const char *s, const char *eos, - int allow_annotations, - saved_location_t where, - smartlist_t *invalid_digests_out) -{ - smartlist_t *tokens; - smartlist_t *result; - microdesc_t *md = NULL; - memarea_t *area; - const char *start = s; - const char *start_of_next_microdesc; - int flags = allow_annotations ? TS_ANNOTATIONS_OK : 0; - const int copy_body = (where != SAVED_IN_CACHE); - - directory_token_t *tok; - - if (!eos) - eos = s + strlen(s); - - s = eat_whitespace_eos(s, eos); - area = memarea_new(); - result = smartlist_new(); - tokens = smartlist_new(); - - while (s < eos) { - int okay = 0; - - start_of_next_microdesc = find_start_of_next_microdesc(s, eos); - if (!start_of_next_microdesc) - start_of_next_microdesc = eos; - - md = tor_malloc_zero(sizeof(microdesc_t)); - { - const char *cp = tor_memstr(s, start_of_next_microdesc-s, - "onion-key"); - const int no_onion_key = (cp == NULL); - if (no_onion_key) { - cp = s; /* So that we have *some* junk to put in the body */ - } - - md->bodylen = start_of_next_microdesc - cp; - md->saved_location = where; - if (copy_body) - md->body = tor_memdup_nulterm(cp, md->bodylen); - else - md->body = (char*)cp; - md->off = cp - start; - crypto_digest256(md->digest, md->body, md->bodylen, DIGEST_SHA256); - if (no_onion_key) { - log_fn(LOG_PROTOCOL_WARN, LD_DIR, "Malformed or truncated descriptor"); - goto next; - } - } - - if (tokenize_string(area, s, start_of_next_microdesc, tokens, - microdesc_token_table, flags)) { - log_warn(LD_DIR, "Unparseable microdescriptor"); - goto next; - } - - if ((tok = find_opt_by_keyword(tokens, A_LAST_LISTED))) { - if (parse_iso_time(tok->args[0], &md->last_listed)) { - log_warn(LD_DIR, "Bad last-listed time in microdescriptor"); - goto next; - } - } - - tok = find_by_keyword(tokens, K_ONION_KEY); - if (!crypto_pk_public_exponent_ok(tok->key)) { - log_warn(LD_DIR, - "Relay's onion key had invalid exponent."); - goto next; - } - router_set_rsa_onion_pkey(tok->key, &md->onion_pkey, - &md->onion_pkey_len); - crypto_pk_free(tok->key); - - if ((tok = find_opt_by_keyword(tokens, K_ONION_KEY_NTOR))) { - curve25519_public_key_t k; - tor_assert(tok->n_args >= 1); - if (curve25519_public_from_base64(&k, tok->args[0]) < 0) { - log_warn(LD_DIR, "Bogus ntor-onion-key in microdesc"); - goto next; - } - md->onion_curve25519_pkey = - tor_memdup(&k, sizeof(curve25519_public_key_t)); - } - - smartlist_t *id_lines = find_all_by_keyword(tokens, K_ID); - if (id_lines) { - SMARTLIST_FOREACH_BEGIN(id_lines, directory_token_t *, t) { - tor_assert(t->n_args >= 2); - if (!strcmp(t->args[0], "ed25519")) { - if (md->ed25519_identity_pkey) { - log_warn(LD_DIR, "Extra ed25519 key in microdesc"); - smartlist_free(id_lines); - goto next; - } - ed25519_public_key_t k; - if (ed25519_public_from_base64(&k, t->args[1])<0) { - log_warn(LD_DIR, "Bogus ed25519 key in microdesc"); - smartlist_free(id_lines); - goto next; - } - md->ed25519_identity_pkey = tor_memdup(&k, sizeof(k)); - } - } SMARTLIST_FOREACH_END(t); - smartlist_free(id_lines); - } - - { - smartlist_t *a_lines = find_all_by_keyword(tokens, K_A); - if (a_lines) { - find_single_ipv6_orport(a_lines, &md->ipv6_addr, &md->ipv6_orport); - smartlist_free(a_lines); - } - } - - if ((tok = find_opt_by_keyword(tokens, K_FAMILY))) { - int i; - md->family = smartlist_new(); - for (i=0;i<tok->n_args;++i) { - if (!is_legal_nickname_or_hexdigest(tok->args[i])) { - log_warn(LD_DIR, "Illegal nickname %s in family line", - escaped(tok->args[i])); - goto next; - } - smartlist_add_strdup(md->family, tok->args[i]); - } - } - - if ((tok = find_opt_by_keyword(tokens, K_P))) { - md->exit_policy = parse_short_policy(tok->args[0]); - } - if ((tok = find_opt_by_keyword(tokens, K_P6))) { - md->ipv6_exit_policy = parse_short_policy(tok->args[0]); - } - - smartlist_add(result, md); - okay = 1; - - md = NULL; - next: - if (! okay && invalid_digests_out) { - smartlist_add(invalid_digests_out, - tor_memdup(md->digest, DIGEST256_LEN)); - } - microdesc_free(md); - md = NULL; - - SMARTLIST_FOREACH(tokens, directory_token_t *, t, token_clear(t)); - memarea_clear(area); - smartlist_clear(tokens); - s = start_of_next_microdesc; - } - - SMARTLIST_FOREACH(tokens, directory_token_t *, t, token_clear(t)); - memarea_drop_all(area); - smartlist_free(tokens); - - return result; -} - -/** Extract a Tor version from a <b>platform</b> line from a router - * descriptor, and place the result in <b>router_version</b>. - * - * Return 1 on success, -1 on parsing failure, and 0 if the - * platform line does not indicate some version of Tor. - * - * If <b>strict</b> is non-zero, finding any weird version components - * (like negative numbers) counts as a parsing failure. - */ -int -tor_version_parse_platform(const char *platform, - tor_version_t *router_version, - int strict) -{ - char tmp[128]; - char *s, *s2, *start; - - if (strcmpstart(platform,"Tor ")) /* nonstandard Tor; say 0. */ - return 0; - - start = (char *)eat_whitespace(platform+3); - if (!*start) return -1; - s = (char *)find_whitespace(start); /* also finds '\0', which is fine */ - s2 = (char*)eat_whitespace(s); - if (!strcmpstart(s2, "(r") || !strcmpstart(s2, "(git-")) - s = (char*)find_whitespace(s2); - - if ((size_t)(s-start+1) >= sizeof(tmp)) /* too big, no */ - return -1; - strlcpy(tmp, start, s-start+1); - - if (tor_version_parse(tmp, router_version)<0) { - log_info(LD_DIR,"Router version '%s' unparseable.",tmp); - return -1; - } - - if (strict) { - if (router_version->major < 0 || - router_version->minor < 0 || - router_version->micro < 0 || - router_version->patchlevel < 0 || - router_version->svn_revision < 0) { - return -1; - } - } - - return 1; -} - -/** Parse the Tor version of the platform string <b>platform</b>, - * and compare it to the version in <b>cutoff</b>. Return 1 if - * the router is at least as new as the cutoff, else return 0. - */ -int -tor_version_as_new_as(const char *platform, const char *cutoff) -{ - tor_version_t cutoff_version, router_version; - int r; - tor_assert(platform); - - if (tor_version_parse(cutoff, &cutoff_version)<0) { - log_warn(LD_BUG,"cutoff version '%s' unparseable.",cutoff); - return 0; - } - - r = tor_version_parse_platform(platform, &router_version, 0); - if (r == 0) { - /* nonstandard Tor; be safe and say yes */ - return 1; - } else if (r < 0) { - /* unparseable version; be safe and say yes. */ - return 1; - } - - /* Here's why we don't need to do any special handling for svn revisions: - * - If neither has an svn revision, we're fine. - * - If the router doesn't have an svn revision, we can't assume that it - * is "at least" any svn revision, so we need to return 0. - * - If the target version doesn't have an svn revision, any svn revision - * (or none at all) is good enough, so return 1. - * - If both target and router have an svn revision, we compare them. - */ - - return tor_version_compare(&router_version, &cutoff_version) >= 0; -} - -/** Parse a tor version from <b>s</b>, and store the result in <b>out</b>. - * Return 0 on success, -1 on failure. */ -int -tor_version_parse(const char *s, tor_version_t *out) -{ - char *eos=NULL; - const char *cp=NULL; - int ok = 1; - /* Format is: - * "Tor " ? NUM dot NUM [ dot NUM [ ( pre | rc | dot ) NUM ] ] [ - tag ] - */ - tor_assert(s); - tor_assert(out); - - memset(out, 0, sizeof(tor_version_t)); - out->status = VER_RELEASE; - if (!strcasecmpstart(s, "Tor ")) - s += 4; - - cp = s; - -#define NUMBER(m) \ - do { \ - if (!cp || *cp < '0' || *cp > '9') \ - return -1; \ - out->m = (int)tor_parse_uint64(cp, 10, 0, INT32_MAX, &ok, &eos); \ - if (!ok) \ - return -1; \ - if (!eos || eos == cp) \ - return -1; \ - cp = eos; \ - } while (0) - -#define DOT() \ - do { \ - if (*cp != '.') \ - return -1; \ - ++cp; \ - } while (0) - - NUMBER(major); - DOT(); - NUMBER(minor); - if (*cp == 0) - return 0; - else if (*cp == '-') - goto status_tag; - DOT(); - NUMBER(micro); - - /* Get status */ - if (*cp == 0) { - return 0; - } else if (*cp == '.') { - ++cp; - } else if (*cp == '-') { - goto status_tag; - } else if (0==strncmp(cp, "pre", 3)) { - out->status = VER_PRE; - cp += 3; - } else if (0==strncmp(cp, "rc", 2)) { - out->status = VER_RC; - cp += 2; - } else { - return -1; - } - - NUMBER(patchlevel); - - status_tag: - /* Get status tag. */ - if (*cp == '-' || *cp == '.') - ++cp; - eos = (char*) find_whitespace(cp); - if (eos-cp >= (int)sizeof(out->status_tag)) - strlcpy(out->status_tag, cp, sizeof(out->status_tag)); - else { - memcpy(out->status_tag, cp, eos-cp); - out->status_tag[eos-cp] = 0; - } - cp = eat_whitespace(eos); - - if (!strcmpstart(cp, "(r")) { - cp += 2; - out->svn_revision = (int) strtol(cp,&eos,10); - } else if (!strcmpstart(cp, "(git-")) { - char *close_paren = strchr(cp, ')'); - int hexlen; - char digest[DIGEST_LEN]; - if (! close_paren) - return -1; - cp += 5; - if (close_paren-cp > HEX_DIGEST_LEN) - return -1; - hexlen = (int)(close_paren-cp); - memwipe(digest, 0, sizeof(digest)); - if ( hexlen == 0 || (hexlen % 2) == 1) - return -1; - if (base16_decode(digest, hexlen/2, cp, hexlen) != hexlen/2) - return -1; - memcpy(out->git_tag, digest, hexlen/2); - out->git_tag_len = hexlen/2; - } - - return 0; -#undef NUMBER -#undef DOT -} - -/** Compare two tor versions; Return <0 if a < b; 0 if a ==b, >0 if a > - * b. */ -int -tor_version_compare(tor_version_t *a, tor_version_t *b) -{ - int i; - tor_assert(a); - tor_assert(b); - - /* We take this approach to comparison to ensure the same (bogus!) behavior - * on all inputs as we would have seen before bug #21278 was fixed. The - * only important difference here is that this method doesn't cause - * a signed integer underflow. - */ -#define CMP(field) do { \ - unsigned aval = (unsigned) a->field; \ - unsigned bval = (unsigned) b->field; \ - int result = (int) (aval - bval); \ - if (result < 0) \ - return -1; \ - else if (result > 0) \ - return 1; \ - } while (0) - - CMP(major); - CMP(minor); - CMP(micro); - CMP(status); - CMP(patchlevel); - if ((i = strcmp(a->status_tag, b->status_tag))) - return i; - CMP(svn_revision); - CMP(git_tag_len); - if (a->git_tag_len) - return fast_memcmp(a->git_tag, b->git_tag, a->git_tag_len); - else - return 0; - -#undef CMP -} - -/** Return true iff versions <b>a</b> and <b>b</b> belong to the same series. - */ -int -tor_version_same_series(tor_version_t *a, tor_version_t *b) -{ - tor_assert(a); - tor_assert(b); - return ((a->major == b->major) && - (a->minor == b->minor) && - (a->micro == b->micro)); -} - -/** Helper: Given pointers to two strings describing tor versions, return -1 - * if _a precedes _b, 1 if _b precedes _a, and 0 if they are equivalent. - * Used to sort a list of versions. */ -static int -compare_tor_version_str_ptr_(const void **_a, const void **_b) -{ - const char *a = *_a, *b = *_b; - int ca, cb; - tor_version_t va, vb; - ca = tor_version_parse(a, &va); - cb = tor_version_parse(b, &vb); - /* If they both parse, compare them. */ - if (!ca && !cb) - return tor_version_compare(&va,&vb); - /* If one parses, it comes first. */ - if (!ca && cb) - return -1; - if (ca && !cb) - return 1; - /* If neither parses, compare strings. Also, the directory server admin - ** needs to be smacked upside the head. But Tor is tolerant and gentle. */ - return strcmp(a,b); -} - -/** Sort a list of string-representations of versions in ascending order. */ -void -sort_version_list(smartlist_t *versions, int remove_duplicates) -{ - smartlist_sort(versions, compare_tor_version_str_ptr_); - - if (remove_duplicates) - smartlist_uniq(versions, compare_tor_version_str_ptr_, tor_free_); -} - -/** Parse and validate the ASCII-encoded v2 descriptor in <b>desc</b>, - * write the parsed descriptor to the newly allocated *<b>parsed_out</b>, the - * binary descriptor ID of length DIGEST_LEN to <b>desc_id_out</b>, the - * encrypted introduction points to the newly allocated - * *<b>intro_points_encrypted_out</b>, their encrypted size to - * *<b>intro_points_encrypted_size_out</b>, the size of the encoded descriptor - * to *<b>encoded_size_out</b>, and a pointer to the possibly next - * descriptor to *<b>next_out</b>; return 0 for success (including validation) - * and -1 for failure. - * - * If <b>as_hsdir</b> is 1, we're parsing this as an HSDir, and we should - * be strict about time formats. - */ -int -rend_parse_v2_service_descriptor(rend_service_descriptor_t **parsed_out, - char *desc_id_out, - char **intro_points_encrypted_out, - size_t *intro_points_encrypted_size_out, - size_t *encoded_size_out, - const char **next_out, const char *desc, - int as_hsdir) -{ - rend_service_descriptor_t *result = - tor_malloc_zero(sizeof(rend_service_descriptor_t)); - char desc_hash[DIGEST_LEN]; - const char *eos; - smartlist_t *tokens = smartlist_new(); - directory_token_t *tok; - char secret_id_part[DIGEST_LEN]; - int i, version, num_ok=1; - smartlist_t *versions; - char public_key_hash[DIGEST_LEN]; - char test_desc_id[DIGEST_LEN]; - memarea_t *area = NULL; - const int strict_time_fmt = as_hsdir; - - tor_assert(desc); - /* Check if desc starts correctly. */ - if (strcmpstart(desc, "rendezvous-service-descriptor ")) { - log_info(LD_REND, "Descriptor does not start correctly."); - goto err; - } - /* Compute descriptor hash for later validation. */ - if (router_get_hash_impl(desc, strlen(desc), desc_hash, - "rendezvous-service-descriptor ", - "\nsignature", '\n', DIGEST_SHA1) < 0) { - log_warn(LD_REND, "Couldn't compute descriptor hash."); - goto err; - } - /* Determine end of string. */ - eos = strstr(desc, "\nrendezvous-service-descriptor "); - if (!eos) - eos = desc + strlen(desc); - else - eos = eos + 1; - /* Check length. */ - if (eos-desc > REND_DESC_MAX_SIZE) { - /* XXXX+ If we are parsing this descriptor as a server, this - * should be a protocol warning. */ - log_warn(LD_REND, "Descriptor length is %d which exceeds " - "maximum rendezvous descriptor size of %d bytes.", - (int)(eos-desc), REND_DESC_MAX_SIZE); - goto err; - } - /* Tokenize descriptor. */ - area = memarea_new(); - if (tokenize_string(area, desc, eos, tokens, desc_token_table, 0)) { - log_warn(LD_REND, "Error tokenizing descriptor."); - goto err; - } - /* Set next to next descriptor, if available. */ - *next_out = eos; - /* Set length of encoded descriptor. */ - *encoded_size_out = eos - desc; - /* Check min allowed length of token list. */ - if (smartlist_len(tokens) < 7) { - log_warn(LD_REND, "Impossibly short descriptor."); - goto err; - } - /* Parse base32-encoded descriptor ID. */ - tok = find_by_keyword(tokens, R_RENDEZVOUS_SERVICE_DESCRIPTOR); - tor_assert(tok == smartlist_get(tokens, 0)); - tor_assert(tok->n_args == 1); - if (!rend_valid_descriptor_id(tok->args[0])) { - log_warn(LD_REND, "Invalid descriptor ID: '%s'", tok->args[0]); - goto err; - } - if (base32_decode(desc_id_out, DIGEST_LEN, - tok->args[0], REND_DESC_ID_V2_LEN_BASE32) < 0) { - log_warn(LD_REND, "Descriptor ID contains illegal characters: %s", - tok->args[0]); - goto err; - } - /* Parse descriptor version. */ - tok = find_by_keyword(tokens, R_VERSION); - tor_assert(tok->n_args == 1); - result->version = - (int) tor_parse_long(tok->args[0], 10, 0, INT_MAX, &num_ok, NULL); - if (result->version != 2 || !num_ok) { - /* If it's <2, it shouldn't be under this format. If the number - * is greater than 2, we bumped it because we broke backward - * compatibility. See how version numbers in our other formats - * work. */ - log_warn(LD_REND, "Unrecognized descriptor version: %s", - escaped(tok->args[0])); - goto err; - } - /* Parse public key. */ - tok = find_by_keyword(tokens, R_PERMANENT_KEY); - result->pk = tok->key; - tok->key = NULL; /* Prevent free */ - /* Parse secret ID part. */ - tok = find_by_keyword(tokens, R_SECRET_ID_PART); - tor_assert(tok->n_args == 1); - if (strlen(tok->args[0]) != REND_SECRET_ID_PART_LEN_BASE32 || - strspn(tok->args[0], BASE32_CHARS) != REND_SECRET_ID_PART_LEN_BASE32) { - log_warn(LD_REND, "Invalid secret ID part: '%s'", tok->args[0]); - goto err; - } - if (base32_decode(secret_id_part, DIGEST_LEN, tok->args[0], 32) < 0) { - log_warn(LD_REND, "Secret ID part contains illegal characters: %s", - tok->args[0]); - goto err; - } - /* Parse publication time -- up-to-date check is done when storing the - * descriptor. */ - tok = find_by_keyword(tokens, R_PUBLICATION_TIME); - tor_assert(tok->n_args == 1); - if (parse_iso_time_(tok->args[0], &result->timestamp, - strict_time_fmt, 0) < 0) { - log_warn(LD_REND, "Invalid publication time: '%s'", tok->args[0]); - goto err; - } - /* Parse protocol versions. */ - tok = find_by_keyword(tokens, R_PROTOCOL_VERSIONS); - tor_assert(tok->n_args == 1); - versions = smartlist_new(); - smartlist_split_string(versions, tok->args[0], ",", - SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0); - for (i = 0; i < smartlist_len(versions); i++) { - version = (int) tor_parse_long(smartlist_get(versions, i), - 10, 0, INT_MAX, &num_ok, NULL); - if (!num_ok) /* It's a string; let's ignore it. */ - continue; - if (version >= REND_PROTOCOL_VERSION_BITMASK_WIDTH) - /* Avoid undefined left-shift behaviour. */ - continue; - result->protocols |= 1 << version; - } - SMARTLIST_FOREACH(versions, char *, cp, tor_free(cp)); - smartlist_free(versions); - /* Parse encrypted introduction points. Don't verify. */ - tok = find_opt_by_keyword(tokens, R_INTRODUCTION_POINTS); - if (tok) { - if (strcmp(tok->object_type, "MESSAGE")) { - log_warn(LD_DIR, "Bad object type: introduction points should be of " - "type MESSAGE"); - goto err; - } - *intro_points_encrypted_out = tor_memdup(tok->object_body, - tok->object_size); - *intro_points_encrypted_size_out = tok->object_size; - } else { - *intro_points_encrypted_out = NULL; - *intro_points_encrypted_size_out = 0; - } - /* Parse and verify signature. */ - tok = find_by_keyword(tokens, R_SIGNATURE); - if (check_signature_token(desc_hash, DIGEST_LEN, tok, result->pk, 0, - "v2 rendezvous service descriptor") < 0) - goto err; - /* Verify that descriptor ID belongs to public key and secret ID part. */ - if (crypto_pk_get_digest(result->pk, public_key_hash) < 0) { - log_warn(LD_REND, "Unable to compute rend descriptor public key digest"); - goto err; - } - rend_get_descriptor_id_bytes(test_desc_id, public_key_hash, - secret_id_part); - if (tor_memneq(desc_id_out, test_desc_id, DIGEST_LEN)) { - log_warn(LD_REND, "Parsed descriptor ID does not match " - "computed descriptor ID."); - goto err; - } - goto done; - err: - rend_service_descriptor_free(result); - result = NULL; - done: - if (tokens) { - SMARTLIST_FOREACH(tokens, directory_token_t *, t, token_clear(t)); - smartlist_free(tokens); - } - if (area) - memarea_drop_all(area); - *parsed_out = result; - if (result) - return 0; - return -1; -} - -/** Decrypt the encrypted introduction points in <b>ipos_encrypted</b> of - * length <b>ipos_encrypted_size</b> using <b>descriptor_cookie</b> and - * write the result to a newly allocated string that is pointed to by - * <b>ipos_decrypted</b> and its length to <b>ipos_decrypted_size</b>. - * Return 0 if decryption was successful and -1 otherwise. */ -int -rend_decrypt_introduction_points(char **ipos_decrypted, - size_t *ipos_decrypted_size, - const char *descriptor_cookie, - const char *ipos_encrypted, - size_t ipos_encrypted_size) -{ - tor_assert(ipos_encrypted); - tor_assert(descriptor_cookie); - if (ipos_encrypted_size < 2) { - log_warn(LD_REND, "Size of encrypted introduction points is too " - "small."); - return -1; - } - if (ipos_encrypted[0] == (int)REND_BASIC_AUTH) { - char iv[CIPHER_IV_LEN], client_id[REND_BASIC_AUTH_CLIENT_ID_LEN], - session_key[CIPHER_KEY_LEN], *dec; - int declen, client_blocks; - size_t pos = 0, len, client_entries_len; - crypto_digest_t *digest; - crypto_cipher_t *cipher; - client_blocks = (int) ipos_encrypted[1]; - client_entries_len = client_blocks * REND_BASIC_AUTH_CLIENT_MULTIPLE * - REND_BASIC_AUTH_CLIENT_ENTRY_LEN; - if (ipos_encrypted_size < 2 + client_entries_len + CIPHER_IV_LEN + 1) { - log_warn(LD_REND, "Size of encrypted introduction points is too " - "small."); - return -1; - } - memcpy(iv, ipos_encrypted + 2 + client_entries_len, CIPHER_IV_LEN); - digest = crypto_digest_new(); - crypto_digest_add_bytes(digest, descriptor_cookie, REND_DESC_COOKIE_LEN); - crypto_digest_add_bytes(digest, iv, CIPHER_IV_LEN); - crypto_digest_get_digest(digest, client_id, - REND_BASIC_AUTH_CLIENT_ID_LEN); - crypto_digest_free(digest); - for (pos = 2; pos < 2 + client_entries_len; - pos += REND_BASIC_AUTH_CLIENT_ENTRY_LEN) { - if (tor_memeq(ipos_encrypted + pos, client_id, - REND_BASIC_AUTH_CLIENT_ID_LEN)) { - /* Attempt to decrypt introduction points. */ - cipher = crypto_cipher_new(descriptor_cookie); - if (crypto_cipher_decrypt(cipher, session_key, ipos_encrypted - + pos + REND_BASIC_AUTH_CLIENT_ID_LEN, - CIPHER_KEY_LEN) < 0) { - log_warn(LD_REND, "Could not decrypt session key for client."); - crypto_cipher_free(cipher); - return -1; - } - crypto_cipher_free(cipher); - - len = ipos_encrypted_size - 2 - client_entries_len - CIPHER_IV_LEN; - dec = tor_malloc_zero(len + 1); - declen = crypto_cipher_decrypt_with_iv(session_key, dec, len, - ipos_encrypted + 2 + client_entries_len, - ipos_encrypted_size - 2 - client_entries_len); - - if (declen < 0) { - log_warn(LD_REND, "Could not decrypt introduction point string."); - tor_free(dec); - return -1; - } - if (fast_memcmpstart(dec, declen, "introduction-point ")) { - log_warn(LD_REND, "Decrypted introduction points don't " - "look like we could parse them."); - tor_free(dec); - continue; - } - *ipos_decrypted = dec; - *ipos_decrypted_size = declen; - return 0; - } - } - log_warn(LD_REND, "Could not decrypt introduction points. Please " - "check your authorization for this service!"); - return -1; - } else if (ipos_encrypted[0] == (int)REND_STEALTH_AUTH) { - char *dec; - int declen; - if (ipos_encrypted_size < CIPHER_IV_LEN + 2) { - log_warn(LD_REND, "Size of encrypted introduction points is too " - "small."); - return -1; - } - dec = tor_malloc_zero(ipos_encrypted_size - CIPHER_IV_LEN - 1 + 1); - - declen = crypto_cipher_decrypt_with_iv(descriptor_cookie, dec, - ipos_encrypted_size - - CIPHER_IV_LEN - 1, - ipos_encrypted + 1, - ipos_encrypted_size - 1); - - if (declen < 0) { - log_warn(LD_REND, "Decrypting introduction points failed!"); - tor_free(dec); - return -1; - } - *ipos_decrypted = dec; - *ipos_decrypted_size = declen; - return 0; - } else { - log_warn(LD_REND, "Unknown authorization type number: %d", - ipos_encrypted[0]); - return -1; - } -} - -/** Parse the encoded introduction points in <b>intro_points_encoded</b> of - * length <b>intro_points_encoded_size</b> and write the result to the - * descriptor in <b>parsed</b>; return the number of successfully parsed - * introduction points or -1 in case of a failure. */ -int -rend_parse_introduction_points(rend_service_descriptor_t *parsed, - const char *intro_points_encoded, - size_t intro_points_encoded_size) -{ - const char *current_ipo, *end_of_intro_points; - smartlist_t *tokens = NULL; - directory_token_t *tok; - rend_intro_point_t *intro; - extend_info_t *info; - int result, num_ok=1; - memarea_t *area = NULL; - tor_assert(parsed); - /** Function may only be invoked once. */ - tor_assert(!parsed->intro_nodes); - if (!intro_points_encoded || intro_points_encoded_size == 0) { - log_warn(LD_REND, "Empty or zero size introduction point list"); - goto err; - } - /* Consider one intro point after the other. */ - current_ipo = intro_points_encoded; - end_of_intro_points = intro_points_encoded + intro_points_encoded_size; - tokens = smartlist_new(); - parsed->intro_nodes = smartlist_new(); - area = memarea_new(); - - while (!fast_memcmpstart(current_ipo, end_of_intro_points-current_ipo, - "introduction-point ")) { - /* Determine end of string. */ - const char *eos = tor_memstr(current_ipo, end_of_intro_points-current_ipo, - "\nintroduction-point "); - if (!eos) - eos = end_of_intro_points; - else - eos = eos+1; - tor_assert(eos <= intro_points_encoded+intro_points_encoded_size); - /* Free tokens and clear token list. */ - SMARTLIST_FOREACH(tokens, directory_token_t *, t, token_clear(t)); - smartlist_clear(tokens); - memarea_clear(area); - /* Tokenize string. */ - if (tokenize_string(area, current_ipo, eos, tokens, ipo_token_table, 0)) { - log_warn(LD_REND, "Error tokenizing introduction point"); - goto err; - } - /* Advance to next introduction point, if available. */ - current_ipo = eos; - /* Check minimum allowed length of introduction point. */ - if (smartlist_len(tokens) < 5) { - log_warn(LD_REND, "Impossibly short introduction point."); - goto err; - } - /* Allocate new intro point and extend info. */ - intro = tor_malloc_zero(sizeof(rend_intro_point_t)); - info = intro->extend_info = tor_malloc_zero(sizeof(extend_info_t)); - /* Parse identifier. */ - tok = find_by_keyword(tokens, R_IPO_IDENTIFIER); - if (base32_decode(info->identity_digest, DIGEST_LEN, - tok->args[0], REND_INTRO_POINT_ID_LEN_BASE32) < 0) { - log_warn(LD_REND, "Identity digest contains illegal characters: %s", - tok->args[0]); - rend_intro_point_free(intro); - goto err; - } - /* Write identifier to nickname. */ - info->nickname[0] = '$'; - base16_encode(info->nickname + 1, sizeof(info->nickname) - 1, - info->identity_digest, DIGEST_LEN); - /* Parse IP address. */ - tok = find_by_keyword(tokens, R_IPO_IP_ADDRESS); - if (tor_addr_parse(&info->addr, tok->args[0])<0) { - log_warn(LD_REND, "Could not parse introduction point address."); - rend_intro_point_free(intro); - goto err; - } - if (tor_addr_family(&info->addr) != AF_INET) { - log_warn(LD_REND, "Introduction point address was not ipv4."); - rend_intro_point_free(intro); - goto err; - } - - /* Parse onion port. */ - tok = find_by_keyword(tokens, R_IPO_ONION_PORT); - info->port = (uint16_t) tor_parse_long(tok->args[0],10,1,65535, - &num_ok,NULL); - if (!info->port || !num_ok) { - log_warn(LD_REND, "Introduction point onion port %s is invalid", - escaped(tok->args[0])); - rend_intro_point_free(intro); - goto err; - } - /* Parse onion key. */ - tok = find_by_keyword(tokens, R_IPO_ONION_KEY); - if (!crypto_pk_public_exponent_ok(tok->key)) { - log_warn(LD_REND, - "Introduction point's onion key had invalid exponent."); - rend_intro_point_free(intro); - goto err; - } - info->onion_key = tok->key; - tok->key = NULL; /* Prevent free */ - /* Parse service key. */ - tok = find_by_keyword(tokens, R_IPO_SERVICE_KEY); - if (!crypto_pk_public_exponent_ok(tok->key)) { - log_warn(LD_REND, - "Introduction point key had invalid exponent."); - rend_intro_point_free(intro); - goto err; - } - intro->intro_key = tok->key; - tok->key = NULL; /* Prevent free */ - /* Add extend info to list of introduction points. */ - smartlist_add(parsed->intro_nodes, intro); - } - result = smartlist_len(parsed->intro_nodes); - goto done; - - err: - result = -1; - - done: - /* Free tokens and clear token list. */ - if (tokens) { - SMARTLIST_FOREACH(tokens, directory_token_t *, t, token_clear(t)); - smartlist_free(tokens); - } - if (area) - memarea_drop_all(area); - - return result; -} - -/** Parse the content of a client_key file in <b>ckstr</b> and add - * rend_authorized_client_t's for each parsed client to - * <b>parsed_clients</b>. Return the number of parsed clients as result - * or -1 for failure. */ -int -rend_parse_client_keys(strmap_t *parsed_clients, const char *ckstr) -{ - int result = -1; - smartlist_t *tokens; - directory_token_t *tok; - const char *current_entry = NULL; - memarea_t *area = NULL; - char *err_msg = NULL; - if (!ckstr || strlen(ckstr) == 0) - return -1; - tokens = smartlist_new(); - /* Begin parsing with first entry, skipping comments or whitespace at the - * beginning. */ - area = memarea_new(); - current_entry = eat_whitespace(ckstr); - while (!strcmpstart(current_entry, "client-name ")) { - rend_authorized_client_t *parsed_entry; - /* Determine end of string. */ - const char *eos = strstr(current_entry, "\nclient-name "); - if (!eos) - eos = current_entry + strlen(current_entry); - else - eos = eos + 1; - /* Free tokens and clear token list. */ - SMARTLIST_FOREACH(tokens, directory_token_t *, t, token_clear(t)); - smartlist_clear(tokens); - memarea_clear(area); - /* Tokenize string. */ - if (tokenize_string(area, current_entry, eos, tokens, - client_keys_token_table, 0)) { - log_warn(LD_REND, "Error tokenizing client keys file."); - goto err; - } - /* Advance to next entry, if available. */ - current_entry = eos; - /* Check minimum allowed length of token list. */ - if (smartlist_len(tokens) < 2) { - log_warn(LD_REND, "Impossibly short client key entry."); - goto err; - } - /* Parse client name. */ - tok = find_by_keyword(tokens, C_CLIENT_NAME); - tor_assert(tok == smartlist_get(tokens, 0)); - tor_assert(tok->n_args == 1); - - if (!rend_valid_client_name(tok->args[0])) { - log_warn(LD_CONFIG, "Illegal client name: %s. (Length must be " - "between 1 and %d, and valid characters are " - "[A-Za-z0-9+-_].)", tok->args[0], REND_CLIENTNAME_MAX_LEN); - goto err; - } - /* Check if client name is duplicate. */ - if (strmap_get(parsed_clients, tok->args[0])) { - log_warn(LD_CONFIG, "HiddenServiceAuthorizeClient contains a " - "duplicate client name: '%s'. Ignoring.", tok->args[0]); - goto err; - } - parsed_entry = tor_malloc_zero(sizeof(rend_authorized_client_t)); - parsed_entry->client_name = tor_strdup(tok->args[0]); - strmap_set(parsed_clients, parsed_entry->client_name, parsed_entry); - /* Parse client key. */ - tok = find_opt_by_keyword(tokens, C_CLIENT_KEY); - if (tok) { - parsed_entry->client_key = tok->key; - tok->key = NULL; /* Prevent free */ - } - - /* Parse descriptor cookie. */ - tok = find_by_keyword(tokens, C_DESCRIPTOR_COOKIE); - tor_assert(tok->n_args == 1); - if (rend_auth_decode_cookie(tok->args[0], parsed_entry->descriptor_cookie, - NULL, &err_msg) < 0) { - tor_assert(err_msg); - log_warn(LD_REND, "%s", err_msg); - tor_free(err_msg); - goto err; - } - } - result = strmap_size(parsed_clients); - goto done; - err: - result = -1; - done: - /* Free tokens and clear token list. */ - SMARTLIST_FOREACH(tokens, directory_token_t *, t, token_clear(t)); - smartlist_free(tokens); - if (area) - memarea_drop_all(area); - return result; -} - -/** Called on startup; right now we just handle scanning the unparseable - * descriptor dumps, but hang anything else we might need to do in the - * future here as well. - */ -void -routerparse_init(void) -{ - /* - * Check both if the sandbox is active and whether it's configured; no - * point in loading all that if we won't be able to use it after the - * sandbox becomes active. - */ - if (!(sandbox_is_active() || get_options()->Sandbox)) { - dump_desc_init(); - } -} - -/** Clean up all data structures used by routerparse.c at exit */ -void -routerparse_free_all(void) -{ - dump_desc_fifo_cleanup(); -} diff --git a/src/feature/nodelist/routerparse.h b/src/feature/nodelist/routerparse.h deleted file mode 100644 index 87c2a75aa5..0000000000 --- a/src/feature/nodelist/routerparse.h +++ /dev/null @@ -1,161 +0,0 @@ -/* Copyright (c) 2001 Matej Pfajfar. - * Copyright (c) 2001-2004, Roger Dingledine. - * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson. - * Copyright (c) 2007-2018, The Tor Project, Inc. */ -/* See LICENSE for licensing information */ - -/** - * \file routerparse.h - * \brief Header file for routerparse.c. - **/ - -#ifndef TOR_ROUTERPARSE_H -#define TOR_ROUTERPARSE_H - -/** Possible statuses of a version of Tor, given opinions from the directory - * servers. */ -typedef enum version_status_t { - VS_RECOMMENDED=0, /**< This version is listed as recommended. */ - VS_OLD=1, /**< This version is older than any recommended version. */ - VS_NEW=2, /**< This version is newer than any recommended version. */ - VS_NEW_IN_SERIES=3, /**< This version is newer than any recommended version - * in its series, but later recommended versions exist. - */ - VS_UNRECOMMENDED=4, /**< This version is not recommended (general case). */ - VS_EMPTY=5, /**< The version list was empty; no agreed-on versions. */ - VS_UNKNOWN, /**< We have no idea. */ -} version_status_t; - -enum networkstatus_type_t; - -int router_get_router_hash(const char *s, size_t s_len, char *digest); -int router_get_dir_hash(const char *s, char *digest); -int router_get_networkstatus_v3_hashes(const char *s, - common_digests_t *digests); -int router_get_networkstatus_v3_signed_boundaries(const char *s, - const char **start_out, - const char **end_out); -int router_get_networkstatus_v3_sha3_as_signed(uint8_t *digest_out, - const char *s); -int router_get_extrainfo_hash(const char *s, size_t s_len, char *digest); -#define DIROBJ_MAX_SIG_LEN 256 -char *router_get_dirobj_signature(const char *digest, - size_t digest_len, - const crypto_pk_t *private_key); -int router_append_dirobj_signature(char *buf, size_t buf_len, - const char *digest, - size_t digest_len, - crypto_pk_t *private_key); -int router_parse_list_from_string(const char **s, const char *eos, - smartlist_t *dest, - saved_location_t saved_location, - int is_extrainfo, - int allow_annotations, - const char *prepend_annotations, - smartlist_t *invalid_digests_out); - -routerinfo_t *router_parse_entry_from_string(const char *s, const char *end, - int cache_copy, - int allow_annotations, - const char *prepend_annotations, - int *can_dl_again_out); -struct digest_ri_map_t; -extrainfo_t *extrainfo_parse_entry_from_string(const char *s, const char *end, - int cache_copy, struct digest_ri_map_t *routermap, - int *can_dl_again_out); -MOCK_DECL(addr_policy_t *, router_parse_addr_policy_item_from_string, - (const char *s, int assume_action, int *malformed_list)); -version_status_t tor_version_is_obsolete(const char *myversion, - const char *versionlist); -int tor_version_parse_platform(const char *platform, - tor_version_t *version_out, - int strict); -int tor_version_as_new_as(const char *platform, const char *cutoff); -int tor_version_parse(const char *s, tor_version_t *out); -int tor_version_compare(tor_version_t *a, tor_version_t *b); -int tor_version_same_series(tor_version_t *a, tor_version_t *b); -void sort_version_list(smartlist_t *lst, int remove_duplicates); -void assert_addr_policy_ok(smartlist_t *t); -void dump_distinct_digest_count(int severity); - -int compare_vote_routerstatus_entries(const void **_a, const void **_b); -int networkstatus_verify_bw_weights(networkstatus_t *ns, int); -networkstatus_t *networkstatus_parse_vote_from_string(const char *s, - const char **eos_out, - enum networkstatus_type_t ns_type); -ns_detached_signatures_t *networkstatus_parse_detached_signatures( - const char *s, const char *eos); - -smartlist_t *microdescs_parse_from_string(const char *s, const char *eos, - int allow_annotations, - saved_location_t where, - smartlist_t *invalid_digests_out); - -authority_cert_t *authority_cert_parse_from_string(const char *s, - const char **end_of_string); -int rend_parse_v2_service_descriptor(rend_service_descriptor_t **parsed_out, - char *desc_id_out, - char **intro_points_encrypted_out, - size_t *intro_points_encrypted_size_out, - size_t *encoded_size_out, - const char **next_out, const char *desc, - int as_hsdir); -int rend_decrypt_introduction_points(char **ipos_decrypted, - size_t *ipos_decrypted_size, - const char *descriptor_cookie, - const char *ipos_encrypted, - size_t ipos_encrypted_size); -int rend_parse_introduction_points(rend_service_descriptor_t *parsed, - const char *intro_points_encoded, - size_t intro_points_encoded_size); -int rend_parse_client_keys(strmap_t *parsed_clients, const char *str); - -void routerparse_init(void); -void routerparse_free_all(void); - -#ifdef ROUTERPARSE_PRIVATE -/* - * One entry in the list of dumped descriptors; filename dumped to, length, - * SHA-256 and timestamp. - */ - -typedef struct { - char *filename; - size_t len; - uint8_t digest_sha256[DIGEST256_LEN]; - time_t when; -} dumped_desc_t; - -EXTERN(uint64_t, len_descs_dumped) -EXTERN(smartlist_t *, descs_dumped) -STATIC int routerstatus_parse_guardfraction(const char *guardfraction_str, - networkstatus_t *vote, - vote_routerstatus_t *vote_rs, - routerstatus_t *rs); -MOCK_DECL(STATIC dumped_desc_t *, dump_desc_populate_one_file, - (const char *dirname, const char *f)); -STATIC void dump_desc_populate_fifo_from_directory(const char *dirname); -STATIC void dump_desc_fifo_cleanup(void); -struct memarea_t; -STATIC routerstatus_t *routerstatus_parse_entry_from_string( - struct memarea_t *area, - const char **s, smartlist_t *tokens, - networkstatus_t *vote, - vote_routerstatus_t *vote_rs, - int consensus_method, - consensus_flavor_t flav); -MOCK_DECL(STATIC void,dump_desc,(const char *desc, const char *type)); -MOCK_DECL(STATIC int, router_compute_hash_final,(char *digest, - const char *start, size_t len, - digest_algorithm_t alg)); -MOCK_DECL(STATIC int, signed_digest_equals, - (const uint8_t *d1, const uint8_t *d2, size_t len)); - -STATIC void summarize_protover_flags(protover_summary_flags_t *out, - const char *protocols, - const char *version); -#endif /* defined(ROUTERPARSE_PRIVATE) */ - -#define ED_DESC_SIGNATURE_PREFIX "Tor router descriptor signature v1" - -#endif /* !defined(TOR_ROUTERPARSE_H) */ diff --git a/src/feature/nodelist/routerset.c b/src/feature/nodelist/routerset.c index cb07a436d1..45863de6e0 100644 --- a/src/feature/nodelist/routerset.c +++ b/src/feature/nodelist/routerset.c @@ -30,9 +30,9 @@ n * Copyright (c) 2001-2004, Roger Dingledine. #include "core/or/or.h" #include "core/or/policies.h" #include "feature/client/bridges.h" +#include "feature/dirparse/policy_parse.h" #include "feature/nodelist/nickname.h" #include "feature/nodelist/nodelist.h" -#include "feature/nodelist/routerparse.h" #include "feature/nodelist/routerset.h" #include "lib/geoip/geoip.h" diff --git a/src/feature/relay/router.c b/src/feature/relay/router.c index fdaadb205b..4afcddc675 100644 --- a/src/feature/relay/router.c +++ b/src/feature/relay/router.c @@ -21,6 +21,9 @@ #include "feature/dircache/dirserv.h" #include "feature/dirclient/dirclient.h" #include "feature/dircommon/directory.h" +#include "feature/dirparse/authcert_parse.h" +#include "feature/dirparse/routerparse.h" +#include "feature/dirparse/signing.h" #include "feature/hibernate/hibernate.h" #include "feature/keymgt/loadkey.h" #include "feature/nodelist/authcert.h" @@ -29,7 +32,6 @@ #include "feature/nodelist/nickname.h" #include "feature/nodelist/nodelist.h" #include "feature/nodelist/routerlist.h" -#include "feature/nodelist/routerparse.h" #include "feature/nodelist/torcert.h" #include "feature/relay/dns.h" #include "feature/relay/router.h" diff --git a/src/feature/rend/rendcache.c b/src/feature/rend/rendcache.c index 7af5063ba5..848386b97d 100644 --- a/src/feature/rend/rendcache.c +++ b/src/feature/rend/rendcache.c @@ -12,8 +12,8 @@ #include "app/config/config.h" #include "feature/stats/rephist.h" #include "feature/nodelist/routerlist.h" -#include "feature/nodelist/routerparse.h" #include "feature/rend/rendcommon.h" +#include "feature/rend/rendparse.h" #include "core/or/extend_info_st.h" #include "feature/rend/rend_intro_point_st.h" diff --git a/src/feature/rend/rendcommon.c b/src/feature/rend/rendcommon.c index b48ba87cbc..15e4534fca 100644 --- a/src/feature/rend/rendcommon.c +++ b/src/feature/rend/rendcommon.c @@ -25,12 +25,13 @@ #include "feature/rend/rendclient.h" #include "feature/rend/rendcommon.h" #include "feature/rend/rendmid.h" +#include "feature/rend/rendparse.h" #include "feature/rend/rendservice.h" #include "feature/stats/rephist.h" #include "feature/hs_common/replaycache.h" #include "feature/relay/router.h" #include "feature/nodelist/routerlist.h" -#include "feature/nodelist/routerparse.h" +#include "feature/dirparse/signing.h" #include "core/or/cpath_build_state_st.h" #include "core/or/crypt_path_st.h" diff --git a/src/feature/rend/rendparse.c b/src/feature/rend/rendparse.c new file mode 100644 index 0000000000..e2378e340f --- /dev/null +++ b/src/feature/rend/rendparse.c @@ -0,0 +1,600 @@ +/* Copyright (c) 2001 Matej Pfajfar. + * Copyright (c) 2001-2004, Roger Dingledine. + * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson. + * Copyright (c) 2007-2018, The Tor Project, Inc. */ +/* See LICENSE for licensing information */ + +/** + * \file rendparse.c + * \brief Code to parse and validate v2 hidden service descriptors. + **/ + +#include "core/or/or.h" +#include "feature/dirparse/parsecommon.h" +#include "feature/dirparse/sigcommon.h" +#include "feature/rend/rendcommon.h" +#include "feature/rend/rendparse.h" +#include "lib/memarea/memarea.h" + +#include "core/or/extend_info_st.h" +#include "feature/rend/rend_authorized_client_st.h" +#include "feature/rend/rend_intro_point_st.h" +#include "feature/rend/rend_service_descriptor_st.h" + +/** List of tokens recognized in rendezvous service descriptors */ +static token_rule_t desc_token_table[] = { + T1_START("rendezvous-service-descriptor", R_RENDEZVOUS_SERVICE_DESCRIPTOR, + EQ(1), NO_OBJ), + T1("version", R_VERSION, EQ(1), NO_OBJ), + T1("permanent-key", R_PERMANENT_KEY, NO_ARGS, NEED_KEY_1024), + T1("secret-id-part", R_SECRET_ID_PART, EQ(1), NO_OBJ), + T1("publication-time", R_PUBLICATION_TIME, CONCAT_ARGS, NO_OBJ), + T1("protocol-versions", R_PROTOCOL_VERSIONS, EQ(1), NO_OBJ), + T01("introduction-points", R_INTRODUCTION_POINTS, NO_ARGS, NEED_OBJ), + T1_END("signature", R_SIGNATURE, NO_ARGS, NEED_OBJ), + END_OF_TABLE +}; + +/** List of tokens recognized in the (encrypted) list of introduction points of + * rendezvous service descriptors */ +static token_rule_t ipo_token_table[] = { + T1_START("introduction-point", R_IPO_IDENTIFIER, EQ(1), NO_OBJ), + T1("ip-address", R_IPO_IP_ADDRESS, EQ(1), NO_OBJ), + T1("onion-port", R_IPO_ONION_PORT, EQ(1), NO_OBJ), + T1("onion-key", R_IPO_ONION_KEY, NO_ARGS, NEED_KEY_1024), + T1("service-key", R_IPO_SERVICE_KEY, NO_ARGS, NEED_KEY_1024), + END_OF_TABLE +}; + +/** List of tokens recognized in the (possibly encrypted) list of introduction + * points of rendezvous service descriptors */ +static token_rule_t client_keys_token_table[] = { + T1_START("client-name", C_CLIENT_NAME, CONCAT_ARGS, NO_OBJ), + T1("descriptor-cookie", C_DESCRIPTOR_COOKIE, EQ(1), NO_OBJ), + T01("client-key", C_CLIENT_KEY, NO_ARGS, NEED_SKEY_1024), + END_OF_TABLE +}; + +/** Parse and validate the ASCII-encoded v2 descriptor in <b>desc</b>, + * write the parsed descriptor to the newly allocated *<b>parsed_out</b>, the + * binary descriptor ID of length DIGEST_LEN to <b>desc_id_out</b>, the + * encrypted introduction points to the newly allocated + * *<b>intro_points_encrypted_out</b>, their encrypted size to + * *<b>intro_points_encrypted_size_out</b>, the size of the encoded descriptor + * to *<b>encoded_size_out</b>, and a pointer to the possibly next + * descriptor to *<b>next_out</b>; return 0 for success (including validation) + * and -1 for failure. + * + * If <b>as_hsdir</b> is 1, we're parsing this as an HSDir, and we should + * be strict about time formats. + */ +int +rend_parse_v2_service_descriptor(rend_service_descriptor_t **parsed_out, + char *desc_id_out, + char **intro_points_encrypted_out, + size_t *intro_points_encrypted_size_out, + size_t *encoded_size_out, + const char **next_out, const char *desc, + int as_hsdir) +{ + rend_service_descriptor_t *result = + tor_malloc_zero(sizeof(rend_service_descriptor_t)); + char desc_hash[DIGEST_LEN]; + const char *eos; + smartlist_t *tokens = smartlist_new(); + directory_token_t *tok; + char secret_id_part[DIGEST_LEN]; + int i, version, num_ok=1; + smartlist_t *versions; + char public_key_hash[DIGEST_LEN]; + char test_desc_id[DIGEST_LEN]; + memarea_t *area = NULL; + const int strict_time_fmt = as_hsdir; + + tor_assert(desc); + /* Check if desc starts correctly. */ + if (strcmpstart(desc, "rendezvous-service-descriptor ")) { + log_info(LD_REND, "Descriptor does not start correctly."); + goto err; + } + /* Compute descriptor hash for later validation. */ + if (router_get_hash_impl(desc, strlen(desc), desc_hash, + "rendezvous-service-descriptor ", + "\nsignature", '\n', DIGEST_SHA1) < 0) { + log_warn(LD_REND, "Couldn't compute descriptor hash."); + goto err; + } + /* Determine end of string. */ + eos = strstr(desc, "\nrendezvous-service-descriptor "); + if (!eos) + eos = desc + strlen(desc); + else + eos = eos + 1; + /* Check length. */ + if (eos-desc > REND_DESC_MAX_SIZE) { + /* XXXX+ If we are parsing this descriptor as a server, this + * should be a protocol warning. */ + log_warn(LD_REND, "Descriptor length is %d which exceeds " + "maximum rendezvous descriptor size of %d bytes.", + (int)(eos-desc), REND_DESC_MAX_SIZE); + goto err; + } + /* Tokenize descriptor. */ + area = memarea_new(); + if (tokenize_string(area, desc, eos, tokens, desc_token_table, 0)) { + log_warn(LD_REND, "Error tokenizing descriptor."); + goto err; + } + /* Set next to next descriptor, if available. */ + *next_out = eos; + /* Set length of encoded descriptor. */ + *encoded_size_out = eos - desc; + /* Check min allowed length of token list. */ + if (smartlist_len(tokens) < 7) { + log_warn(LD_REND, "Impossibly short descriptor."); + goto err; + } + /* Parse base32-encoded descriptor ID. */ + tok = find_by_keyword(tokens, R_RENDEZVOUS_SERVICE_DESCRIPTOR); + tor_assert(tok == smartlist_get(tokens, 0)); + tor_assert(tok->n_args == 1); + if (!rend_valid_descriptor_id(tok->args[0])) { + log_warn(LD_REND, "Invalid descriptor ID: '%s'", tok->args[0]); + goto err; + } + if (base32_decode(desc_id_out, DIGEST_LEN, + tok->args[0], REND_DESC_ID_V2_LEN_BASE32) < 0) { + log_warn(LD_REND, "Descriptor ID contains illegal characters: %s", + tok->args[0]); + goto err; + } + /* Parse descriptor version. */ + tok = find_by_keyword(tokens, R_VERSION); + tor_assert(tok->n_args == 1); + result->version = + (int) tor_parse_long(tok->args[0], 10, 0, INT_MAX, &num_ok, NULL); + if (result->version != 2 || !num_ok) { + /* If it's <2, it shouldn't be under this format. If the number + * is greater than 2, we bumped it because we broke backward + * compatibility. See how version numbers in our other formats + * work. */ + log_warn(LD_REND, "Unrecognized descriptor version: %s", + escaped(tok->args[0])); + goto err; + } + /* Parse public key. */ + tok = find_by_keyword(tokens, R_PERMANENT_KEY); + result->pk = tok->key; + tok->key = NULL; /* Prevent free */ + /* Parse secret ID part. */ + tok = find_by_keyword(tokens, R_SECRET_ID_PART); + tor_assert(tok->n_args == 1); + if (strlen(tok->args[0]) != REND_SECRET_ID_PART_LEN_BASE32 || + strspn(tok->args[0], BASE32_CHARS) != REND_SECRET_ID_PART_LEN_BASE32) { + log_warn(LD_REND, "Invalid secret ID part: '%s'", tok->args[0]); + goto err; + } + if (base32_decode(secret_id_part, DIGEST_LEN, tok->args[0], 32) < 0) { + log_warn(LD_REND, "Secret ID part contains illegal characters: %s", + tok->args[0]); + goto err; + } + /* Parse publication time -- up-to-date check is done when storing the + * descriptor. */ + tok = find_by_keyword(tokens, R_PUBLICATION_TIME); + tor_assert(tok->n_args == 1); + if (parse_iso_time_(tok->args[0], &result->timestamp, + strict_time_fmt, 0) < 0) { + log_warn(LD_REND, "Invalid publication time: '%s'", tok->args[0]); + goto err; + } + /* Parse protocol versions. */ + tok = find_by_keyword(tokens, R_PROTOCOL_VERSIONS); + tor_assert(tok->n_args == 1); + versions = smartlist_new(); + smartlist_split_string(versions, tok->args[0], ",", + SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0); + for (i = 0; i < smartlist_len(versions); i++) { + version = (int) tor_parse_long(smartlist_get(versions, i), + 10, 0, INT_MAX, &num_ok, NULL); + if (!num_ok) /* It's a string; let's ignore it. */ + continue; + if (version >= REND_PROTOCOL_VERSION_BITMASK_WIDTH) + /* Avoid undefined left-shift behaviour. */ + continue; + result->protocols |= 1 << version; + } + SMARTLIST_FOREACH(versions, char *, cp, tor_free(cp)); + smartlist_free(versions); + /* Parse encrypted introduction points. Don't verify. */ + tok = find_opt_by_keyword(tokens, R_INTRODUCTION_POINTS); + if (tok) { + if (strcmp(tok->object_type, "MESSAGE")) { + log_warn(LD_DIR, "Bad object type: introduction points should be of " + "type MESSAGE"); + goto err; + } + *intro_points_encrypted_out = tor_memdup(tok->object_body, + tok->object_size); + *intro_points_encrypted_size_out = tok->object_size; + } else { + *intro_points_encrypted_out = NULL; + *intro_points_encrypted_size_out = 0; + } + /* Parse and verify signature. */ + tok = find_by_keyword(tokens, R_SIGNATURE); + if (check_signature_token(desc_hash, DIGEST_LEN, tok, result->pk, 0, + "v2 rendezvous service descriptor") < 0) + goto err; + /* Verify that descriptor ID belongs to public key and secret ID part. */ + if (crypto_pk_get_digest(result->pk, public_key_hash) < 0) { + log_warn(LD_REND, "Unable to compute rend descriptor public key digest"); + goto err; + } + rend_get_descriptor_id_bytes(test_desc_id, public_key_hash, + secret_id_part); + if (tor_memneq(desc_id_out, test_desc_id, DIGEST_LEN)) { + log_warn(LD_REND, "Parsed descriptor ID does not match " + "computed descriptor ID."); + goto err; + } + goto done; + err: + rend_service_descriptor_free(result); + result = NULL; + done: + if (tokens) { + SMARTLIST_FOREACH(tokens, directory_token_t *, t, token_clear(t)); + smartlist_free(tokens); + } + if (area) + memarea_drop_all(area); + *parsed_out = result; + if (result) + return 0; + return -1; +} + +/** Decrypt the encrypted introduction points in <b>ipos_encrypted</b> of + * length <b>ipos_encrypted_size</b> using <b>descriptor_cookie</b> and + * write the result to a newly allocated string that is pointed to by + * <b>ipos_decrypted</b> and its length to <b>ipos_decrypted_size</b>. + * Return 0 if decryption was successful and -1 otherwise. */ +int +rend_decrypt_introduction_points(char **ipos_decrypted, + size_t *ipos_decrypted_size, + const char *descriptor_cookie, + const char *ipos_encrypted, + size_t ipos_encrypted_size) +{ + tor_assert(ipos_encrypted); + tor_assert(descriptor_cookie); + if (ipos_encrypted_size < 2) { + log_warn(LD_REND, "Size of encrypted introduction points is too " + "small."); + return -1; + } + if (ipos_encrypted[0] == (int)REND_BASIC_AUTH) { + char iv[CIPHER_IV_LEN], client_id[REND_BASIC_AUTH_CLIENT_ID_LEN], + session_key[CIPHER_KEY_LEN], *dec; + int declen, client_blocks; + size_t pos = 0, len, client_entries_len; + crypto_digest_t *digest; + crypto_cipher_t *cipher; + client_blocks = (int) ipos_encrypted[1]; + client_entries_len = client_blocks * REND_BASIC_AUTH_CLIENT_MULTIPLE * + REND_BASIC_AUTH_CLIENT_ENTRY_LEN; + if (ipos_encrypted_size < 2 + client_entries_len + CIPHER_IV_LEN + 1) { + log_warn(LD_REND, "Size of encrypted introduction points is too " + "small."); + return -1; + } + memcpy(iv, ipos_encrypted + 2 + client_entries_len, CIPHER_IV_LEN); + digest = crypto_digest_new(); + crypto_digest_add_bytes(digest, descriptor_cookie, REND_DESC_COOKIE_LEN); + crypto_digest_add_bytes(digest, iv, CIPHER_IV_LEN); + crypto_digest_get_digest(digest, client_id, + REND_BASIC_AUTH_CLIENT_ID_LEN); + crypto_digest_free(digest); + for (pos = 2; pos < 2 + client_entries_len; + pos += REND_BASIC_AUTH_CLIENT_ENTRY_LEN) { + if (tor_memeq(ipos_encrypted + pos, client_id, + REND_BASIC_AUTH_CLIENT_ID_LEN)) { + /* Attempt to decrypt introduction points. */ + cipher = crypto_cipher_new(descriptor_cookie); + if (crypto_cipher_decrypt(cipher, session_key, ipos_encrypted + + pos + REND_BASIC_AUTH_CLIENT_ID_LEN, + CIPHER_KEY_LEN) < 0) { + log_warn(LD_REND, "Could not decrypt session key for client."); + crypto_cipher_free(cipher); + return -1; + } + crypto_cipher_free(cipher); + + len = ipos_encrypted_size - 2 - client_entries_len - CIPHER_IV_LEN; + dec = tor_malloc_zero(len + 1); + declen = crypto_cipher_decrypt_with_iv(session_key, dec, len, + ipos_encrypted + 2 + client_entries_len, + ipos_encrypted_size - 2 - client_entries_len); + + if (declen < 0) { + log_warn(LD_REND, "Could not decrypt introduction point string."); + tor_free(dec); + return -1; + } + if (fast_memcmpstart(dec, declen, "introduction-point ")) { + log_warn(LD_REND, "Decrypted introduction points don't " + "look like we could parse them."); + tor_free(dec); + continue; + } + *ipos_decrypted = dec; + *ipos_decrypted_size = declen; + return 0; + } + } + log_warn(LD_REND, "Could not decrypt introduction points. Please " + "check your authorization for this service!"); + return -1; + } else if (ipos_encrypted[0] == (int)REND_STEALTH_AUTH) { + char *dec; + int declen; + if (ipos_encrypted_size < CIPHER_IV_LEN + 2) { + log_warn(LD_REND, "Size of encrypted introduction points is too " + "small."); + return -1; + } + dec = tor_malloc_zero(ipos_encrypted_size - CIPHER_IV_LEN - 1 + 1); + + declen = crypto_cipher_decrypt_with_iv(descriptor_cookie, dec, + ipos_encrypted_size - + CIPHER_IV_LEN - 1, + ipos_encrypted + 1, + ipos_encrypted_size - 1); + + if (declen < 0) { + log_warn(LD_REND, "Decrypting introduction points failed!"); + tor_free(dec); + return -1; + } + *ipos_decrypted = dec; + *ipos_decrypted_size = declen; + return 0; + } else { + log_warn(LD_REND, "Unknown authorization type number: %d", + ipos_encrypted[0]); + return -1; + } +} + +/** Parse the encoded introduction points in <b>intro_points_encoded</b> of + * length <b>intro_points_encoded_size</b> and write the result to the + * descriptor in <b>parsed</b>; return the number of successfully parsed + * introduction points or -1 in case of a failure. */ +int +rend_parse_introduction_points(rend_service_descriptor_t *parsed, + const char *intro_points_encoded, + size_t intro_points_encoded_size) +{ + const char *current_ipo, *end_of_intro_points; + smartlist_t *tokens = NULL; + directory_token_t *tok; + rend_intro_point_t *intro; + extend_info_t *info; + int result, num_ok=1; + memarea_t *area = NULL; + tor_assert(parsed); + /** Function may only be invoked once. */ + tor_assert(!parsed->intro_nodes); + if (!intro_points_encoded || intro_points_encoded_size == 0) { + log_warn(LD_REND, "Empty or zero size introduction point list"); + goto err; + } + /* Consider one intro point after the other. */ + current_ipo = intro_points_encoded; + end_of_intro_points = intro_points_encoded + intro_points_encoded_size; + tokens = smartlist_new(); + parsed->intro_nodes = smartlist_new(); + area = memarea_new(); + + while (!fast_memcmpstart(current_ipo, end_of_intro_points-current_ipo, + "introduction-point ")) { + /* Determine end of string. */ + const char *eos = tor_memstr(current_ipo, end_of_intro_points-current_ipo, + "\nintroduction-point "); + if (!eos) + eos = end_of_intro_points; + else + eos = eos+1; + tor_assert(eos <= intro_points_encoded+intro_points_encoded_size); + /* Free tokens and clear token list. */ + SMARTLIST_FOREACH(tokens, directory_token_t *, t, token_clear(t)); + smartlist_clear(tokens); + memarea_clear(area); + /* Tokenize string. */ + if (tokenize_string(area, current_ipo, eos, tokens, ipo_token_table, 0)) { + log_warn(LD_REND, "Error tokenizing introduction point"); + goto err; + } + /* Advance to next introduction point, if available. */ + current_ipo = eos; + /* Check minimum allowed length of introduction point. */ + if (smartlist_len(tokens) < 5) { + log_warn(LD_REND, "Impossibly short introduction point."); + goto err; + } + /* Allocate new intro point and extend info. */ + intro = tor_malloc_zero(sizeof(rend_intro_point_t)); + info = intro->extend_info = tor_malloc_zero(sizeof(extend_info_t)); + /* Parse identifier. */ + tok = find_by_keyword(tokens, R_IPO_IDENTIFIER); + if (base32_decode(info->identity_digest, DIGEST_LEN, + tok->args[0], REND_INTRO_POINT_ID_LEN_BASE32) < 0) { + log_warn(LD_REND, "Identity digest contains illegal characters: %s", + tok->args[0]); + rend_intro_point_free(intro); + goto err; + } + /* Write identifier to nickname. */ + info->nickname[0] = '$'; + base16_encode(info->nickname + 1, sizeof(info->nickname) - 1, + info->identity_digest, DIGEST_LEN); + /* Parse IP address. */ + tok = find_by_keyword(tokens, R_IPO_IP_ADDRESS); + if (tor_addr_parse(&info->addr, tok->args[0])<0) { + log_warn(LD_REND, "Could not parse introduction point address."); + rend_intro_point_free(intro); + goto err; + } + if (tor_addr_family(&info->addr) != AF_INET) { + log_warn(LD_REND, "Introduction point address was not ipv4."); + rend_intro_point_free(intro); + goto err; + } + + /* Parse onion port. */ + tok = find_by_keyword(tokens, R_IPO_ONION_PORT); + info->port = (uint16_t) tor_parse_long(tok->args[0],10,1,65535, + &num_ok,NULL); + if (!info->port || !num_ok) { + log_warn(LD_REND, "Introduction point onion port %s is invalid", + escaped(tok->args[0])); + rend_intro_point_free(intro); + goto err; + } + /* Parse onion key. */ + tok = find_by_keyword(tokens, R_IPO_ONION_KEY); + if (!crypto_pk_public_exponent_ok(tok->key)) { + log_warn(LD_REND, + "Introduction point's onion key had invalid exponent."); + rend_intro_point_free(intro); + goto err; + } + info->onion_key = tok->key; + tok->key = NULL; /* Prevent free */ + /* Parse service key. */ + tok = find_by_keyword(tokens, R_IPO_SERVICE_KEY); + if (!crypto_pk_public_exponent_ok(tok->key)) { + log_warn(LD_REND, + "Introduction point key had invalid exponent."); + rend_intro_point_free(intro); + goto err; + } + intro->intro_key = tok->key; + tok->key = NULL; /* Prevent free */ + /* Add extend info to list of introduction points. */ + smartlist_add(parsed->intro_nodes, intro); + } + result = smartlist_len(parsed->intro_nodes); + goto done; + + err: + result = -1; + + done: + /* Free tokens and clear token list. */ + if (tokens) { + SMARTLIST_FOREACH(tokens, directory_token_t *, t, token_clear(t)); + smartlist_free(tokens); + } + if (area) + memarea_drop_all(area); + + return result; +} + +/** Parse the content of a client_key file in <b>ckstr</b> and add + * rend_authorized_client_t's for each parsed client to + * <b>parsed_clients</b>. Return the number of parsed clients as result + * or -1 for failure. */ +int +rend_parse_client_keys(strmap_t *parsed_clients, const char *ckstr) +{ + int result = -1; + smartlist_t *tokens; + directory_token_t *tok; + const char *current_entry = NULL; + memarea_t *area = NULL; + char *err_msg = NULL; + if (!ckstr || strlen(ckstr) == 0) + return -1; + tokens = smartlist_new(); + /* Begin parsing with first entry, skipping comments or whitespace at the + * beginning. */ + area = memarea_new(); + current_entry = eat_whitespace(ckstr); + while (!strcmpstart(current_entry, "client-name ")) { + rend_authorized_client_t *parsed_entry; + /* Determine end of string. */ + const char *eos = strstr(current_entry, "\nclient-name "); + if (!eos) + eos = current_entry + strlen(current_entry); + else + eos = eos + 1; + /* Free tokens and clear token list. */ + SMARTLIST_FOREACH(tokens, directory_token_t *, t, token_clear(t)); + smartlist_clear(tokens); + memarea_clear(area); + /* Tokenize string. */ + if (tokenize_string(area, current_entry, eos, tokens, + client_keys_token_table, 0)) { + log_warn(LD_REND, "Error tokenizing client keys file."); + goto err; + } + /* Advance to next entry, if available. */ + current_entry = eos; + /* Check minimum allowed length of token list. */ + if (smartlist_len(tokens) < 2) { + log_warn(LD_REND, "Impossibly short client key entry."); + goto err; + } + /* Parse client name. */ + tok = find_by_keyword(tokens, C_CLIENT_NAME); + tor_assert(tok == smartlist_get(tokens, 0)); + tor_assert(tok->n_args == 1); + + if (!rend_valid_client_name(tok->args[0])) { + log_warn(LD_CONFIG, "Illegal client name: %s. (Length must be " + "between 1 and %d, and valid characters are " + "[A-Za-z0-9+-_].)", tok->args[0], REND_CLIENTNAME_MAX_LEN); + goto err; + } + /* Check if client name is duplicate. */ + if (strmap_get(parsed_clients, tok->args[0])) { + log_warn(LD_CONFIG, "HiddenServiceAuthorizeClient contains a " + "duplicate client name: '%s'. Ignoring.", tok->args[0]); + goto err; + } + parsed_entry = tor_malloc_zero(sizeof(rend_authorized_client_t)); + parsed_entry->client_name = tor_strdup(tok->args[0]); + strmap_set(parsed_clients, parsed_entry->client_name, parsed_entry); + /* Parse client key. */ + tok = find_opt_by_keyword(tokens, C_CLIENT_KEY); + if (tok) { + parsed_entry->client_key = tok->key; + tok->key = NULL; /* Prevent free */ + } + + /* Parse descriptor cookie. */ + tok = find_by_keyword(tokens, C_DESCRIPTOR_COOKIE); + tor_assert(tok->n_args == 1); + if (rend_auth_decode_cookie(tok->args[0], parsed_entry->descriptor_cookie, + NULL, &err_msg) < 0) { + tor_assert(err_msg); + log_warn(LD_REND, "%s", err_msg); + tor_free(err_msg); + goto err; + } + } + result = strmap_size(parsed_clients); + goto done; + err: + result = -1; + done: + /* Free tokens and clear token list. */ + SMARTLIST_FOREACH(tokens, directory_token_t *, t, token_clear(t)); + smartlist_free(tokens); + if (area) + memarea_drop_all(area); + return result; +} diff --git a/src/feature/rend/rendparse.h b/src/feature/rend/rendparse.h new file mode 100644 index 0000000000..337d3e3b1f --- /dev/null +++ b/src/feature/rend/rendparse.h @@ -0,0 +1,32 @@ +/* Copyright (c) 2001 Matej Pfajfar. + * Copyright (c) 2001-2004, Roger Dingledine. + * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson. + * Copyright (c) 2007-2018, The Tor Project, Inc. */ +/* See LICENSE for licensing information */ + +/** + * \file rend_parse.h + * \brief Header file for rend_parse.c. + **/ + +#ifndef TOR_REND_PARSE_H +#define TOR_REND_PARSE_H + +int rend_parse_v2_service_descriptor(rend_service_descriptor_t **parsed_out, + char *desc_id_out, + char **intro_points_encrypted_out, + size_t *intro_points_encrypted_size_out, + size_t *encoded_size_out, + const char **next_out, const char *desc, + int as_hsdir); +int rend_decrypt_introduction_points(char **ipos_decrypted, + size_t *ipos_decrypted_size, + const char *descriptor_cookie, + const char *ipos_encrypted, + size_t ipos_encrypted_size); +int rend_parse_introduction_points(rend_service_descriptor_t *parsed, + const char *intro_points_encoded, + size_t intro_points_encoded_size); +int rend_parse_client_keys(strmap_t *parsed_clients, const char *str); + +#endif diff --git a/src/feature/rend/rendservice.c b/src/feature/rend/rendservice.c index 057ca2d0c7..bae9da3fe5 100644 --- a/src/feature/rend/rendservice.c +++ b/src/feature/rend/rendservice.c @@ -31,10 +31,10 @@ #include "feature/nodelist/nickname.h" #include "feature/nodelist/node_select.h" #include "feature/nodelist/nodelist.h" -#include "feature/nodelist/routerparse.h" #include "feature/nodelist/routerset.h" #include "feature/rend/rendclient.h" #include "feature/rend/rendcommon.h" +#include "feature/rend/rendparse.h" #include "feature/rend/rendservice.h" #include "feature/stats/predict_ports.h" #include "lib/crypt_ops/crypto_dh.h" diff --git a/src/test/fuzz/fuzz_consensus.c b/src/test/fuzz/fuzz_consensus.c index b170fd33d8..b56702a650 100644 --- a/src/test/fuzz/fuzz_consensus.c +++ b/src/test/fuzz/fuzz_consensus.c @@ -1,8 +1,10 @@ /* Copyright (c) 2016-2018, The Tor Project, Inc. */ /* See LICENSE for licensing information */ -#define ROUTERPARSE_PRIVATE +#define SIGCOMMON_PRIVATE #include "core/or/or.h" -#include "feature/nodelist/routerparse.h" +#include "feature/dirparse/ns_parse.h" +#include "feature/dirparse/sigcommon.h" +#include "feature/dirparse/unparseable.h" #include "feature/nodelist/networkstatus.h" #include "lib/crypt_ops/crypto_ed25519.h" #include "feature/nodelist/networkstatus_st.h" diff --git a/src/test/fuzz/fuzz_descriptor.c b/src/test/fuzz/fuzz_descriptor.c index 2babdce4bf..3420113717 100644 --- a/src/test/fuzz/fuzz_descriptor.c +++ b/src/test/fuzz/fuzz_descriptor.c @@ -1,8 +1,10 @@ /* Copyright (c) 2016-2018, The Tor Project, Inc. */ /* See LICENSE for licensing information */ -#define ROUTERPARSE_PRIVATE +#define SIGCOMMON_PRIVATE #include "core/or/or.h" -#include "feature/nodelist/routerparse.h" +#include "feature/dirparse/routerparse.h" +#include "feature/dirparse/sigcommon.h" +#include "feature/dirparse/unparseable.h" #include "feature/nodelist/routerlist.h" #include "feature/nodelist/torcert.h" #include "feature/keymgt/loadkey.h" diff --git a/src/test/fuzz/fuzz_extrainfo.c b/src/test/fuzz/fuzz_extrainfo.c index 6c88f80122..da0fe80838 100644 --- a/src/test/fuzz/fuzz_extrainfo.c +++ b/src/test/fuzz/fuzz_extrainfo.c @@ -1,8 +1,10 @@ /* Copyright (c) 2016-2018, The Tor Project, Inc. */ /* See LICENSE for licensing information */ -#define ROUTERPARSE_PRIVATE +#define SIGCOMMON_PRIVATE #include "core/or/or.h" -#include "feature/nodelist/routerparse.h" +#include "feature/dirparse/routerparse.h" +#include "feature/dirparse/sigcommon.h" +#include "feature/dirparse/unparseable.h" #include "feature/nodelist/routerlist.h" #include "feature/relay/routerkeys.h" #include "test/fuzz/fuzzing.h" diff --git a/src/test/fuzz/fuzz_hsdescv2.c b/src/test/fuzz/fuzz_hsdescv2.c index fd5da41635..667b58b3aa 100644 --- a/src/test/fuzz/fuzz_hsdescv2.c +++ b/src/test/fuzz/fuzz_hsdescv2.c @@ -1,9 +1,9 @@ /* Copyright (c) 2016-2018, The Tor Project, Inc. */ /* See LICENSE for licensing information */ -#define ROUTERPARSE_PRIVATE #include "core/or/or.h" -#include "feature/nodelist/routerparse.h" +#include "feature/dirparse/unparseable.h" #include "feature/rend/rendcommon.h" +#include "feature/rend/rendparse.h" #include "lib/crypt_ops/crypto_ed25519.h" #include "test/fuzz/fuzzing.h" diff --git a/src/test/fuzz/fuzz_hsdescv3.c b/src/test/fuzz/fuzz_hsdescv3.c index b332973b39..d5ddcc2e27 100644 --- a/src/test/fuzz/fuzz_hsdescv3.c +++ b/src/test/fuzz/fuzz_hsdescv3.c @@ -1,14 +1,13 @@ /* Copyright (c) 2017-2018, The Tor Project, Inc. */ /* See LICENSE for licensing information */ -#define ROUTERPARSE_PRIVATE #define HS_DESCRIPTOR_PRIVATE #include "core/or/or.h" #include "trunnel/ed25519_cert.h" /* Trunnel interface. */ #include "lib/crypt_ops/crypto_ed25519.h" #include "feature/hs/hs_descriptor.h" -#include "feature/nodelist/routerparse.h" +#include "feature/dirparse/unparseable.h" #include "test/fuzz/fuzzing.h" diff --git a/src/test/fuzz/fuzz_iptsv2.c b/src/test/fuzz/fuzz_iptsv2.c index a3082f4d0e..265677eebe 100644 --- a/src/test/fuzz/fuzz_iptsv2.c +++ b/src/test/fuzz/fuzz_iptsv2.c @@ -1,9 +1,10 @@ /* Copyright (c) 2016-2018, The Tor Project, Inc. */ /* See LICENSE for licensing information */ -#define ROUTERPARSE_PRIVATE + #include "core/or/or.h" -#include "feature/nodelist/routerparse.h" +#include "feature/dirparse/unparseable.h" #include "feature/rend/rendcommon.h" +#include "feature/rend/rendparse.h" #include "lib/crypt_ops/crypto_ed25519.h" #include "feature/rend/rend_service_descriptor_st.h" diff --git a/src/test/fuzz/fuzz_microdesc.c b/src/test/fuzz/fuzz_microdesc.c index fa9676372d..ab54cf2a34 100644 --- a/src/test/fuzz/fuzz_microdesc.c +++ b/src/test/fuzz/fuzz_microdesc.c @@ -1,8 +1,9 @@ /* Copyright (c) 2016-2018, The Tor Project, Inc. */ /* See LICENSE for licensing information */ -#define ROUTERPARSE_PRIVATE + #include "core/or/or.h" -#include "feature/nodelist/routerparse.h" +#include "feature/dirparse/microdesc_parse.h" +#include "feature/dirparse/unparseable.h" #include "feature/nodelist/microdesc.h" #include "lib/crypt_ops/crypto_ed25519.h" diff --git a/src/test/fuzz/fuzz_vrs.c b/src/test/fuzz/fuzz_vrs.c index 8c96851b1f..0b869aa5c0 100644 --- a/src/test/fuzz/fuzz_vrs.c +++ b/src/test/fuzz/fuzz_vrs.c @@ -1,9 +1,10 @@ /* Copyright (c) 2016-2018, The Tor Project, Inc. */ /* See LICENSE for licensing information */ -#define ROUTERPARSE_PRIVATE +#define NS_PARSE_PRIVATE #define NETWORKSTATUS_PRIVATE #include "core/or/or.h" -#include "feature/nodelist/routerparse.h" +#include "feature/dirparse/ns_parse.h" +#include "feature/dirparse/unparseable.h" #include "lib/memarea/memarea.h" #include "feature/nodelist/microdesc.h" #include "feature/nodelist/networkstatus.h" diff --git a/src/test/test.c b/src/test/test.c index fff87a2b56..70d91e3967 100644 --- a/src/test/test.c +++ b/src/test/test.c @@ -45,6 +45,7 @@ #include "core/or/connection_edge.h" #include "feature/rend/rendcommon.h" #include "feature/rend/rendcache.h" +#include "feature/rend/rendparse.h" #include "test/test.h" #include "core/mainloop/mainloop.h" #include "lib/memarea/memarea.h" @@ -54,7 +55,6 @@ #include "core/crypto/onion_tap.h" #include "core/or/policies.h" #include "feature/stats/rephist.h" -#include "feature/nodelist/routerparse.h" #include "app/config/statefile.h" #include "lib/crypt_ops/crypto_curve25519.h" diff --git a/src/test/test_consdiffmgr.c b/src/test/test_consdiffmgr.c index 6c0601b504..6c451da685 100644 --- a/src/test/test_consdiffmgr.c +++ b/src/test/test_consdiffmgr.c @@ -11,7 +11,7 @@ #include "core/mainloop/cpuworker.h" #include "lib/crypt_ops/crypto_rand.h" #include "feature/nodelist/networkstatus.h" -#include "feature/nodelist/routerparse.h" +#include "feature/dirparse/ns_parse.h" #include "lib/evloop/workqueue.h" #include "lib/compress/compress.h" #include "lib/encoding/confline.h" diff --git a/src/test/test_dir.c b/src/test/test_dir.c index aa1c706b1f..c18aa99fea 100644 --- a/src/test/test_dir.c +++ b/src/test/test_dir.c @@ -16,11 +16,12 @@ #define DLSTATUS_PRIVATE #define HIBERNATE_PRIVATE #define NETWORKSTATUS_PRIVATE +#define NS_PARSE_PRIVATE #define NODE_SELECT_PRIVATE #define RELAY_PRIVATE #define ROUTERLIST_PRIVATE -#define ROUTERPARSE_PRIVATE #define ROUTER_PRIVATE +#define UNPARSEABLE_PRIVATE #define VOTEFLAGS_PRIVATE #include "core/or/or.h" @@ -28,11 +29,13 @@ #include "app/config/confparse.h" #include "core/mainloop/connection.h" #include "core/or/relay.h" +#include "core/or/versions.h" #include "feature/client/bridges.h" #include "feature/client/entrynodes.h" #include "feature/control/control.h" #include "feature/dirauth/bwauth.h" #include "feature/dirauth/dirvote.h" +#include "feature/dirauth/dsigs_parse.h" #include "feature/dirauth/process_descs.h" #include "feature/dirauth/recommend_pkg.h" #include "feature/dirauth/shared_random_state.h" @@ -51,7 +54,10 @@ #include "feature/nodelist/nickname.h" #include "feature/nodelist/node_select.h" #include "feature/nodelist/routerlist.h" -#include "feature/nodelist/routerparse.h" +#include "feature/dirparse/authcert_parse.h" +#include "feature/dirparse/ns_parse.h" +#include "feature/dirparse/routerparse.h" +#include "feature/dirparse/unparseable.h" #include "feature/nodelist/routerset.h" #include "feature/nodelist/torcert.h" #include "feature/relay/router.h" diff --git a/src/test/test_dir_common.c b/src/test/test_dir_common.c index e65e2b0111..86d2838944 100644 --- a/src/test/test_dir_common.c +++ b/src/test/test_dir_common.c @@ -10,6 +10,8 @@ #include "feature/dirauth/dirvote.h" #include "feature/nodelist/nodelist.h" #include "feature/nodelist/routerlist.h" +#include "feature/dirparse/authcert_parse.h" +#include "feature/dirparse/ns_parse.h" #include "test/test_dir_common.h" #include "feature/dircommon/voting_schedule.h" diff --git a/src/test/test_dir_common.h b/src/test/test_dir_common.h index 1e90228edb..1e958a21ff 100644 --- a/src/test/test_dir_common.h +++ b/src/test/test_dir_common.h @@ -5,7 +5,6 @@ #include "core/or/or.h" #include "feature/nodelist/networkstatus.h" -#include "feature/nodelist/routerparse.h" #define TEST_DIR_ROUTER_ID_1 3 #define TEST_DIR_ROUTER_ID_2 5 diff --git a/src/test/test_dir_handle_get.c b/src/test/test_dir_handle_get.c index 623d9e9b9d..1d4a36d7fc 100644 --- a/src/test/test_dir_handle_get.c +++ b/src/test/test_dir_handle_get.c @@ -29,7 +29,7 @@ #include "test/test_helpers.h" #include "feature/nodelist/nodelist.h" #include "feature/client/entrynodes.h" -#include "feature/nodelist/routerparse.h" +#include "feature/dirparse/authcert_parse.h" #include "feature/nodelist/networkstatus.h" #include "core/proto/proto_http.h" #include "lib/geoip/geoip.h" diff --git a/src/test/test_entrynodes.c b/src/test/test_entrynodes.c index ebe9accf5a..b67c9fae53 100644 --- a/src/test/test_entrynodes.c +++ b/src/test/test_entrynodes.c @@ -26,7 +26,6 @@ #include "feature/nodelist/networkstatus.h" #include "core/or/policies.h" #include "feature/nodelist/routerlist.h" -#include "feature/nodelist/routerparse.h" #include "feature/nodelist/routerset.h" #include "app/config/statefile.h" diff --git a/src/test/test_guardfraction.c b/src/test/test_guardfraction.c index 7d4a959bb4..d6f4cd63f2 100644 --- a/src/test/test_guardfraction.c +++ b/src/test/test_guardfraction.c @@ -2,15 +2,15 @@ /* See LICENSE for licensing information */ #define GUARDFRACTION_PRIVATE -#define ROUTERPARSE_PRIVATE #define NETWORKSTATUS_PRIVATE +#define NS_PARSE_PRIVATE #include "orconfig.h" #include "core/or/or.h" #include "app/config/config.h" #include "feature/dirauth/guardfraction.h" #include "feature/client/entrynodes.h" -#include "feature/nodelist/routerparse.h" +#include "feature/dirparse/ns_parse.h" #include "feature/nodelist/networkstatus.h" #include "feature/nodelist/networkstatus_st.h" diff --git a/src/test/test_hs_service.c b/src/test/test_hs_service.c index 334bde3e7b..957bf6e103 100644 --- a/src/test/test_hs_service.c +++ b/src/test/test_hs_service.c @@ -21,7 +21,6 @@ #define STATEFILE_PRIVATE #define TOR_CHANNEL_INTERNAL_ #define HS_CLIENT_PRIVATE -#define ROUTERPARSE_PRIVATE #include "test/test.h" #include "test/test_helpers.h" @@ -31,33 +30,33 @@ #include "core/or/or.h" #include "app/config/config.h" +#include "app/config/statefile.h" +#include "core/crypto/hs_ntor.h" +#include "core/mainloop/connection.h" +#include "core/mainloop/mainloop.h" #include "core/or/circuitbuild.h" #include "core/or/circuitlist.h" #include "core/or/circuituse.h" -#include "core/mainloop/connection.h" #include "core/or/connection_edge.h" #include "core/or/edge_connection_st.h" -#include "lib/crypt_ops/crypto_rand.h" -#include "lib/fs/dir.h" -#include "feature/dirauth/dirvote.h" -#include "feature/nodelist/networkstatus.h" -#include "feature/nodelist/nodelist.h" #include "core/or/relay.h" -#include "feature/nodelist/routerparse.h" +#include "core/or/versions.h" +#include "feature/dirauth/dirvote.h" +#include "feature/dirauth/shared_random_state.h" +#include "feature/dircommon/voting_schedule.h" +#include "feature/hs/hs_circuit.h" +#include "feature/hs/hs_circuitmap.h" +#include "feature/hs/hs_client.h" #include "feature/hs/hs_common.h" #include "feature/hs/hs_config.h" #include "feature/hs/hs_ident.h" #include "feature/hs/hs_intropoint.h" -#include "core/crypto/hs_ntor.h" -#include "feature/hs/hs_circuit.h" -#include "feature/hs/hs_circuitmap.h" #include "feature/hs/hs_service.h" -#include "feature/hs/hs_client.h" -#include "core/mainloop/mainloop.h" +#include "feature/nodelist/networkstatus.h" +#include "feature/nodelist/nodelist.h" #include "feature/rend/rendservice.h" -#include "app/config/statefile.h" -#include "feature/dirauth/shared_random_state.h" -#include "feature/dircommon/voting_schedule.h" +#include "lib/crypt_ops/crypto_rand.h" +#include "lib/fs/dir.h" #include "core/or/cpath_build_state_st.h" #include "core/or/crypt_path_st.h" diff --git a/src/test/test_microdesc.c b/src/test/test_microdesc.c index ec4779ead1..8ede2690ec 100644 --- a/src/test/test_microdesc.c +++ b/src/test/test_microdesc.c @@ -4,13 +4,14 @@ #include "orconfig.h" #include "core/or/or.h" -#include "app/config/config.h" #define DIRVOTE_PRIVATE +#include "app/config/config.h" #include "feature/dirauth/dirvote.h" +#include "feature/dirparse/microdesc_parse.h" +#include "feature/dirparse/routerparse.h" #include "feature/nodelist/microdesc.h" #include "feature/nodelist/networkstatus.h" #include "feature/nodelist/routerlist.h" -#include "feature/nodelist/routerparse.h" #include "feature/nodelist/torcert.h" #include "feature/nodelist/microdesc_st.h" diff --git a/src/test/test_policy.c b/src/test/test_policy.c index 6a07e5b1f8..afe608f5f7 100644 --- a/src/test/test_policy.c +++ b/src/test/test_policy.c @@ -1,19 +1,20 @@ /* Copyright (c) 2013-2018, The Tor Project, Inc. */ /* See LICENSE for licensing information */ -#include "core/or/or.h" #define CONFIG_PRIVATE -#include "app/config/config.h" -#include "feature/relay/router.h" -#include "feature/nodelist/routerparse.h" #define POLICIES_PRIVATE + +#include "core/or/or.h" +#include "app/config/config.h" #include "core/or/policies.h" +#include "feature/dirparse/policy_parse.h" +#include "feature/relay/router.h" #include "lib/encoding/confline.h" #include "test/test.h" #include "core/or/addr_policy_st.h" -#include "feature/nodelist/node_st.h" #include "core/or/port_cfg_st.h" +#include "feature/nodelist/node_st.h" #include "feature/nodelist/routerinfo_st.h" #include "feature/nodelist/routerstatus_st.h" diff --git a/src/test/test_routerlist.c b/src/test/test_routerlist.c index 1086b98612..67af2fd484 100644 --- a/src/test/test_routerlist.c +++ b/src/test/test_routerlist.c @@ -33,7 +33,8 @@ #include "feature/nodelist/node_select.h" #include "feature/nodelist/routerlist.h" #include "feature/nodelist/routerset.h" -#include "feature/nodelist/routerparse.h" +#include "feature/dirparse/authcert_parse.h" +#include "feature/dirparse/ns_parse.h" #include "feature/dirauth/shared_random.h" #include "app/config/statefile.h" diff --git a/src/test/test_routerset.c b/src/test/test_routerset.c index fede419f0b..a08adff466 100644 --- a/src/test/test_routerset.c +++ b/src/test/test_routerset.c @@ -4,11 +4,11 @@ #define ROUTERSET_PRIVATE #include "core/or/or.h" -#include "lib/geoip/geoip.h" -#include "feature/nodelist/routerset.h" -#include "feature/nodelist/routerparse.h" #include "core/or/policies.h" +#include "feature/dirparse/policy_parse.h" #include "feature/nodelist/nodelist.h" +#include "feature/nodelist/routerset.h" +#include "lib/geoip/geoip.h" #include "core/or/addr_policy_st.h" #include "core/or/extend_info_st.h" diff --git a/src/test/test_shared_random.c b/src/test/test_shared_random.c index 725724aa56..8a7fb95cc1 100644 --- a/src/test/test_shared_random.c +++ b/src/test/test_shared_random.c @@ -19,7 +19,7 @@ #include "feature/relay/routerkeys.h" #include "feature/nodelist/authcert.h" #include "feature/nodelist/dirlist.h" -#include "feature/nodelist/routerparse.h" +#include "feature/dirparse/authcert_parse.h" #include "feature/hs_common/shared_random_client.h" #include "feature/dircommon/voting_schedule.h" |