tor-commits March 2017

tor-commits@lists.torproject.org

20 participants
1183 discussions

[tor/master] String-based API for consensus diffs.
by nickm＠torproject.org 16 Mar '17

16 Mar '17

commit 6a36e5ff3b7233e430ce8b1ec567d3235ff04999 Author: Nick Mathewson <nickm(a)torproject.org> Date: Tue Mar 7 13:45:32 2017 -0500 String-based API for consensus diffs. Also, add very strict split/join functions, and totally forbid nonempty files that end with somethig besides a newline. This change is necessary to ensure that diff/apply are actually reliable inverse operations. --- src/or/consdiff.c | 118 ++++++++++++++++++++++++++++++++++++++++++++++++++++-- src/or/consdiff.h | 26 +++++++----- 2 files changed, 130 insertions(+), 14 deletions(-) diff --git a/src/or/consdiff.c b/src/or/consdiff.c index 6fe8360..3266abd 100644 --- a/src/or/consdiff.c +++ b/src/or/consdiff.c @@ -39,9 +39,12 @@ static const char* ns_diff_version = "network-status-diff-version 1"; static const char* hash_token = "hash"; -STATIC int -consensus_compute_digest(const char *cons, - consensus_digest_t *digest_out) +static char *consensus_join_lines(const smartlist_t *inp); + +/** DOCDOC */ +MOCK_IMPL(STATIC int, +consensus_compute_digest,(const char *cons, + consensus_digest_t *digest_out)) { int r = crypto_digest256((char*)digest_out->sha3_256, cons, strlen(cons), DIGEST_SHA3_256); @@ -987,7 +990,7 @@ consdiff_apply_diff(const smartlist_t *cons1, goto error_cleanup; } - cons2_str = smartlist_join_strings(cons2, "\n", 1, NULL); + cons2_str = consensus_join_lines(cons2); consensus_digest_t cons2_digests; if (consensus_compute_digest(cons2_str, &cons2_digests) < 0) { @@ -1029,3 +1032,110 @@ consdiff_apply_diff(const smartlist_t *cons1, return cons2_str; } +/**DOCDOC*/ +static int +consensus_split_lines(smartlist_t *out, const char *s) +{ + /* XXXX If we used string slices, we could avoid a bunch of copies here. */ + while (*s) { + const char *eol = strchr(s, '\n'); + if (!eol) { + /* File doesn't end with newline. */ + return -1; + } + smartlist_add(out, tor_strndup(s, eol-s)); + s = eol+1; + } + return 0; +} + +/** DOCDOC */ +static char * +consensus_join_lines(const smartlist_t *inp) +{ + size_t n = 0; + SMARTLIST_FOREACH(inp, const char *, cp, n += strlen(cp) + 1); + n += 1; + char *result = tor_malloc(n); + char *out = result; + SMARTLIST_FOREACH_BEGIN(inp, const char *, cp) { + size_t len = strlen(cp); + memcpy(out, cp, len); + out += len; + *out++ = '\n'; + } SMARTLIST_FOREACH_END(cp); + *out++ = '\0'; + tor_assert(out == result+n); + return result; +} + +/**DOCDOC */ +char * +consensus_diff_generate(const char *cons1, + const char *cons2) +{ + consensus_digest_t d1, d2; + smartlist_t *lines1 = NULL, *lines2 = NULL, *result_lines = NULL; + int r1, r2; + char *result = NULL; + + r1 = consensus_compute_digest(cons1, &d1); + r2 = consensus_compute_digest(cons2, &d2); + if (BUG(r1 < 0 || r2 < 0)) + return NULL; // LCOV_EXCL_LINE + + lines1 = smartlist_new(); + lines2 = smartlist_new(); + if (consensus_split_lines(lines1, cons1) < 0) + goto done; + if (consensus_split_lines(lines2, cons2) < 0) + goto done; + + result_lines = consdiff_gen_diff(lines1, lines2, &d1, &d2); + + done: + SMARTLIST_FOREACH(lines1, char *, cp, tor_free(cp)); + smartlist_free(lines1); + SMARTLIST_FOREACH(lines2, char *, cp, tor_free(cp)); + smartlist_free(lines2); + + if (result_lines) { + result = consensus_join_lines(result_lines); + SMARTLIST_FOREACH(result_lines, char *, cp, tor_free(cp)); + smartlist_free(result_lines); + } + return result; +} + +/** DOCDOC */ +char * +consensus_diff_apply(const char *consensus, + const char *diff) +{ + consensus_digest_t d1; + smartlist_t *lines1 = NULL, *lines2 = NULL; + int r1; + char *result = NULL; + + r1 = consensus_compute_digest(consensus, &d1); + if (BUG(r1 < 0)) + return NULL; // LCOV_EXCL_LINE + + lines1 = smartlist_new(); + lines2 = smartlist_new(); + if (consensus_split_lines(lines1, consensus) < 0) + goto done; + if (consensus_split_lines(lines2, diff) < 0) + goto done; + + result = consdiff_apply_diff(lines1, lines2, &d1); + + done: + SMARTLIST_FOREACH(lines1, char *, cp, tor_free(cp)); + smartlist_free(lines1); + SMARTLIST_FOREACH(lines2, char *, cp, tor_free(cp)); + smartlist_free(lines2); + + return result; +} + diff --git a/src/or/consdiff.h b/src/or/consdiff.h index 42cd3af..eef3653 100644 --- a/src/or/consdiff.h +++ b/src/or/consdiff.h @@ -7,21 +7,27 @@ #include "or.h" +char *consensus_diff_generate(const char *cons1, + const char *cons2); +char *consensus_diff_apply(const char *consensus, + const char *diff); + +#ifdef CONSDIFF_PRIVATE typedef struct consensus_digest_t { uint8_t sha3_256[DIGEST256_LEN]; } consensus_digest_t; -smartlist_t *consdiff_gen_diff(const smartlist_t *cons1, - const smartlist_t *cons2, - const consensus_digest_t *digests1, - const consensus_digest_t *digests2); -char *consdiff_apply_diff(const smartlist_t *cons1, const smartlist_t *diff, - const consensus_digest_t *digests1); -int consdiff_get_digests(const smartlist_t *diff, - char *digest1_out, - char *digest2_out); +STATIC smartlist_t *consdiff_gen_diff(const smartlist_t *cons1, + const smartlist_t *cons2, + const consensus_digest_t *digests1, + const consensus_digest_t *digests2); +STATIC char *consdiff_apply_diff(const smartlist_t *cons1, + const smartlist_t *diff, + const consensus_digest_t *digests1); +STATIC int consdiff_get_digests(const smartlist_t *diff, + char *digest1_out, + char *digest2_out); -#ifdef CONSDIFF_PRIVATE /** Data structure to define a slice of a smarltist. */ typedef struct smartlist_slice_t { /**

1 0

[tor/master] Tweak&test log messages on apply_diff
by nickm＠torproject.org 16 Mar '17

16 Mar '17

commit c6046f4db8b182133ccc756529b508522be180c8 Author: Nick Mathewson <nickm(a)torproject.org> Date: Tue Mar 7 11:36:07 2017 -0500 Tweak&test log messages on apply_diff --- src/or/consdiff.c | 11 ++++++----- src/test/test_consdiff.c | 24 ++++++++++++++++++++++++ 2 files changed, 30 insertions(+), 5 deletions(-) diff --git a/src/or/consdiff.c b/src/or/consdiff.c index defa1cf..73ac797 100644 --- a/src/or/consdiff.c +++ b/src/or/consdiff.c @@ -879,7 +879,7 @@ consdiff_get_digests(smartlist_t *diff, if (smartlist_len(hash_words) != 3 || strcmp(smartlist_get(hash_words, 0), hash_token)) { log_info(LD_CONSDIFF, "The provided consensus diff does not include " - "the necessary sha256 digests."); + "the necessary digests."); goto error_cleanup; } @@ -893,7 +893,7 @@ consdiff_get_digests(smartlist_t *diff, if (strlen(cons1_hash_hex) != HEX_DIGEST256_LEN || strlen(cons2_hash_hex) != HEX_DIGEST256_LEN) { log_info(LD_CONSDIFF, "The provided consensus diff includes " - "base16-encoded sha256 digests of incorrect size."); + "base16-encoded digests of incorrect size."); goto error_cleanup; } @@ -909,7 +909,7 @@ consdiff_get_digests(smartlist_t *diff, base16_decode(cons2_hash, DIGEST256_LEN, cons2_hash_hex, HEX_DIGEST256_LEN) != DIGEST256_LEN) { log_info(LD_CONSDIFF, "The provided consensus diff includes " - "malformed sha256 digests."); + "malformed digests."); goto error_cleanup; } @@ -958,7 +958,7 @@ consdiff_apply_diff(smartlist_t *cons1, smartlist_t *diff, char hex_digest1[HEX_DIGEST256_LEN+1]; char e_hex_digest1[HEX_DIGEST256_LEN+1]; log_warn(LD_CONSDIFF, "Refusing to apply consensus diff because " - "the base consensus doesn't match its own digest as found in " + "the base consensus doesn't match the digest as found in " "the consensus diff header."); base16_encode(hex_digest1, HEX_DIGEST256_LEN+1, digests1->d[DIGEST_SHA256], DIGEST256_LEN); @@ -973,6 +973,7 @@ consdiff_apply_diff(smartlist_t *cons1, smartlist_t *diff, /* To avoid copying memory or iterating over all the elements, make a * read-only smartlist without the two header lines. */ + /* XXXX prop140 abstraction violation; never do this. */ smartlist_t *ed_diff = tor_malloc(sizeof(smartlist_t)); ed_diff->list = diff->list+2; ed_diff->num_used = diff->num_used-2; @@ -999,7 +1000,7 @@ consdiff_apply_diff(smartlist_t *cons1, smartlist_t *diff, if (fast_memneq(cons2_digests.d[DIGEST_SHA256], e_cons2_hash, DIGEST256_LEN)) { log_warn(LD_CONSDIFF, "Refusing to apply consensus diff because " - "the resulting consensus doesn't match its own digest as found in " + "the resulting consensus doesn't match the digest as found in " "the consensus diff header."); char hex_digest2[HEX_DIGEST256_LEN+1]; char e_hex_digest2[HEX_DIGEST256_LEN+1]; diff --git a/src/test/test_consdiff.c b/src/test/test_consdiff.c index 15f5575..00fba67 100644 --- a/src/test/test_consdiff.c +++ b/src/test/test_consdiff.c @@ -856,6 +856,7 @@ test_consdiff_apply_diff(void *arg) (void)arg; cons1 = smartlist_new(); diff = smartlist_new(); + setup_capture_of_logs(LOG_INFO); cons1_str = tor_strdup( "header\nnetwork-status-version foo\n" @@ -870,33 +871,44 @@ test_consdiff_apply_diff(void *arg) /* diff doesn't have enough lines. */ cons2 = consdiff_apply_diff(cons1, diff, &digests1); tt_ptr_op(NULL, OP_EQ, cons2); + expect_single_log_msg_containing("too short") /* first line doesn't match format-version string. */ smartlist_add(diff, (char*)"foo-bar"); smartlist_add(diff, (char*)"header-line"); + mock_clean_saved_logs(); cons2 = consdiff_apply_diff(cons1, diff, &digests1); tt_ptr_op(NULL, OP_EQ, cons2); + expect_single_log_msg_containing("format is not known") /* The first word of the second header line is not "hash". */ smartlist_clear(diff); smartlist_add(diff, (char*)"network-status-diff-version 1"); smartlist_add(diff, (char*)"word a b"); + smartlist_add(diff, (char*)"x"); + mock_clean_saved_logs(); cons2 = consdiff_apply_diff(cons1, diff, &digests1); tt_ptr_op(NULL, OP_EQ, cons2); + expect_single_log_msg_containing("does not include the necessary digests") /* Wrong number of words after "hash". */ smartlist_clear(diff); smartlist_add(diff, (char*)"network-status-diff-version 1"); smartlist_add(diff, (char*)"hash a b c"); + mock_clean_saved_logs(); cons2 = consdiff_apply_diff(cons1, diff, &digests1); tt_ptr_op(NULL, OP_EQ, cons2); + expect_single_log_msg_containing("does not include the necessary digests") /* base16 sha256 digests do not have the expected length. */ smartlist_clear(diff); smartlist_add(diff, (char*)"network-status-diff-version 1"); smartlist_add(diff, (char*)"hash aaa bbb"); + mock_clean_saved_logs(); cons2 = consdiff_apply_diff(cons1, diff, &digests1); tt_ptr_op(NULL, OP_EQ, cons2); + expect_single_log_msg_containing("includes base16-encoded digests of " + "incorrect size") /* base16 sha256 digests contain non-base16 characters. */ smartlist_clear(diff); @@ -904,8 +916,10 @@ test_consdiff_apply_diff(void *arg) smartlist_add(diff, (char*)"hash" " ????????????????????????????????????????????????????????????????" " ----------------------------------------------------------------"); + mock_clean_saved_logs(); cons2 = consdiff_apply_diff(cons1, diff, &digests1); tt_ptr_op(NULL, OP_EQ, cons2); + expect_single_log_msg_containing("includes malformed digests") /* Invalid ed diff. * As tested in apply_ed_diff, but check that apply_diff does return NULL if @@ -918,8 +932,11 @@ test_consdiff_apply_diff(void *arg) /* sha256 of cons2. */ " 635D34593020C08E5ECD865F9986E29D50028EFA62843766A8197AD228A7F6AA"); smartlist_add(diff, (char*)"foobar"); + mock_clean_saved_logs(); cons2 = consdiff_apply_diff(cons1, diff, &digests1); tt_ptr_op(NULL, OP_EQ, cons2); + expect_single_log_msg_containing("because an ed command was missing a line " + "number") /* Base consensus doesn't match its digest as found in the diff. */ smartlist_clear(diff); @@ -929,8 +946,11 @@ test_consdiff_apply_diff(void *arg) " 3333333333333333333333333333333333333333333333333333333333333333" /* sha256 of cons2. */ " 635D34593020C08E5ECD865F9986E29D50028EFA62843766A8197AD228A7F6AA"); + mock_clean_saved_logs(); cons2 = consdiff_apply_diff(cons1, diff, &digests1); tt_ptr_op(NULL, OP_EQ, cons2); + expect_log_msg_containing("base consensus doesn't match the digest " + "as found"); /* Resulting consensus doesn't match its digest as found in the diff. */ smartlist_clear(diff); @@ -940,8 +960,11 @@ test_consdiff_apply_diff(void *arg) " C2199B6827514F39ED9B3F2E2E73735C6C5468FD636240BB454C526220DE702A" /* bogus sha256. */ " 3333333333333333333333333333333333333333333333333333333333333333"); + mock_clean_saved_logs(); cons2 = consdiff_apply_diff(cons1, diff, &digests1); tt_ptr_op(NULL, OP_EQ, cons2); + expect_log_msg_containing("resulting consensus doesn't match the " + "digest as found") /* Very simple test, only to see that nothing errors. */ smartlist_clear(diff); @@ -988,6 +1011,7 @@ test_consdiff_apply_diff(void *arg) smartlist_clear(diff); done: + teardown_capture_of_logs(); tor_free(cons1_str); smartlist_free(cons1); smartlist_free(diff);

1 0

[tor/master] Use "const" in consdiff.[ch]
by nickm＠torproject.org 16 Mar '17

16 Mar '17

commit 69b3e11e5994234d985d5711be0b1642bdd38a75 Author: Nick Mathewson <nickm(a)torproject.org> Date: Tue Mar 7 13:11:38 2017 -0500 Use "const" in consdiff.[ch] --- src/or/consdiff.c | 34 +++++++++++++++++++--------------- src/or/consdiff.h | 32 +++++++++++++++++++------------- 2 files changed, 38 insertions(+), 28 deletions(-) diff --git a/src/or/consdiff.c b/src/or/consdiff.c index 296b43d..2b14395 100644 --- a/src/or/consdiff.c +++ b/src/or/consdiff.c @@ -54,7 +54,7 @@ consensus_compute_digest(const char *cons, * reach the end of the smartlist. */ STATIC smartlist_slice_t * -smartlist_slice(smartlist_t *list, int start, int end) +smartlist_slice(const smartlist_t *list, int start, int end) { int list_len = smartlist_len(list); tor_assert(start >= 0); @@ -79,7 +79,7 @@ smartlist_slice(smartlist_t *list, int start, int end) * one. */ STATIC int * -lcs_lengths(smartlist_slice_t *slice1, smartlist_slice_t *slice2, +lcs_lengths(const smartlist_slice_t *slice1, const smartlist_slice_t *slice2, int direction) { size_t a_size = sizeof(int) * (slice2->len+1); @@ -158,7 +158,7 @@ trim_slices(smartlist_slice_t *slice1, smartlist_slice_t *slice2) /** Like smartlist_string_pos, but limited to the bounds of the slice. */ STATIC int -smartlist_slice_string_pos(smartlist_slice_t *slice, const char *string) +smartlist_slice_string_pos(const smartlist_slice_t *slice, const char *string) { int end = slice->offset + slice->len; for (int i = slice->offset; i < end; ++i) { @@ -177,7 +177,7 @@ smartlist_slice_string_pos(smartlist_slice_t *slice, const char *string) */ STATIC void set_changed(bitarray_t *changed1, bitarray_t *changed2, - smartlist_slice_t *slice1, smartlist_slice_t *slice2) + const smartlist_slice_t *slice1, const smartlist_slice_t *slice2) { int toskip = -1; tor_assert(slice1->len == 0 || slice1->len == 1); @@ -205,8 +205,9 @@ set_changed(bitarray_t *changed1, bitarray_t *changed2, * subsequence. */ static int -optimal_column_to_split(smartlist_slice_t *top, smartlist_slice_t *bot, - smartlist_slice_t *slice2) +optimal_column_to_split(const smartlist_slice_t *top, + const smartlist_slice_t *bot, + const smartlist_slice_t *slice2) { int *lens_top = lcs_lengths(top, slice2, 1); int *lens_bot = lcs_lengths(bot, slice2, -1); @@ -238,7 +239,8 @@ optimal_column_to_split(smartlist_slice_t *top, smartlist_slice_t *bot, * finding the smallest diff possible. */ STATIC void -calc_changes(smartlist_slice_t *slice1, smartlist_slice_t *slice2, +calc_changes(smartlist_slice_t *slice1, + smartlist_slice_t *slice2, bitarray_t *changed1, bitarray_t *changed2) { trim_slices(slice1, slice2); @@ -347,7 +349,7 @@ is_valid_router_entry(const char *line) * don't want to skip the first line, in which case cur will be -1. */ STATIC int -next_router(smartlist_t *cons, int cur) +next_router(const smartlist_t *cons, int cur) { int len = smartlist_len(cons); tor_assert(cur >= -1 && cur < len); @@ -431,7 +433,7 @@ base64cmp(const char *hash1, const char *hash2) * calc_changes(cons1_sl, cons2_sl, changed1, changed2); */ STATIC smartlist_t * -gen_ed_diff(smartlist_t *cons1, smartlist_t *cons2) +gen_ed_diff(const smartlist_t *cons1, const smartlist_t *cons2) { int len1 = smartlist_len(cons1); int len2 = smartlist_len(cons2); @@ -657,7 +659,7 @@ gen_ed_diff(smartlist_t *cons1, smartlist_t *cons2) * formatted. */ STATIC smartlist_t * -apply_ed_diff(smartlist_t *cons1, smartlist_t *diff) +apply_ed_diff(const smartlist_t *cons1, const smartlist_t *diff) { int diff_len = smartlist_len(diff); int j = smartlist_len(cons1); @@ -798,8 +800,9 @@ apply_ed_diff(smartlist_t *cons1, smartlist_t *diff) * up to the caller to free their resources. */ smartlist_t * -consdiff_gen_diff(smartlist_t *cons1, smartlist_t *cons2, - consensus_digest_t *digests1, consensus_digest_t *digests2) +consdiff_gen_diff(const smartlist_t *cons1, const smartlist_t *cons2, + const consensus_digest_t *digests1, + const consensus_digest_t *digests2) { smartlist_t *ed_diff = gen_ed_diff(cons1, cons2); /* ed diff could not be generated - reason already logged by gen_ed_diff. */ @@ -863,7 +866,7 @@ consdiff_gen_diff(smartlist_t *cons1, smartlist_t *cons2, * length DIGEST256_LEN or larger if not NULL. */ int -consdiff_get_digests(smartlist_t *diff, +consdiff_get_digests(const smartlist_t *diff, char *digest1_out, char *digest2_out) { @@ -944,8 +947,9 @@ consdiff_get_digests(smartlist_t *diff, * any way, so it's up to the caller to free their resources. */ char * -consdiff_apply_diff(smartlist_t *cons1, smartlist_t *diff, - consensus_digest_t *digests1) +consdiff_apply_diff(const smartlist_t *cons1, + const smartlist_t *diff, + const consensus_digest_t *digests1) { smartlist_t *cons2 = NULL; char *cons2_str = NULL; diff --git a/src/or/consdiff.h b/src/or/consdiff.h index 1fffaed..3316ed6 100644 --- a/src/or/consdiff.h +++ b/src/or/consdiff.h @@ -11,11 +11,13 @@ typedef struct consensus_digest_t { uint8_t sha3_256[DIGEST256_LEN]; } consensus_digest_t; -smartlist_t *consdiff_gen_diff(smartlist_t *cons1, smartlist_t *cons2, - consensus_digest_t *digests1, consensus_digest_t *digests2); -char *consdiff_apply_diff(smartlist_t *cons1, smartlist_t *diff, - consensus_digest_t *digests1); -int consdiff_get_digests(smartlist_t *diff, +smartlist_t *consdiff_gen_diff(const smartlist_t *cons1, + const smartlist_t *cons2, + const consensus_digest_t *digests1, + const consensus_digest_t *digests2); +char *consdiff_apply_diff(const smartlist_t *cons1, const smartlist_t *diff, + const consensus_digest_t *digests1); +int consdiff_get_digests(const smartlist_t *diff, char *digest1_out, char *digest2_out); @@ -26,29 +28,33 @@ typedef struct smartlist_slice_t { * Smartlist that this slice is made from. * References the whole original smartlist that the slice was made out of. * */ - smartlist_t *list; + const smartlist_t *list; /** Starting position of the slice in the smartlist. */ int offset; /** Length of the slice, i.e. the number of elements it holds. */ int len; } smartlist_slice_t; -STATIC smartlist_t *gen_ed_diff(smartlist_t *cons1, smartlist_t *cons2); -STATIC smartlist_t *apply_ed_diff(smartlist_t *cons1, smartlist_t *diff); +STATIC smartlist_t *gen_ed_diff(const smartlist_t *cons1, + const smartlist_t *cons2); +STATIC smartlist_t *apply_ed_diff(const smartlist_t *cons1, + const smartlist_t *diff); STATIC void calc_changes(smartlist_slice_t *slice1, smartlist_slice_t *slice2, bitarray_t *changed1, bitarray_t *changed2); -STATIC smartlist_slice_t *smartlist_slice(smartlist_t *list, +STATIC smartlist_slice_t *smartlist_slice(const smartlist_t *list, int start, int end); -STATIC int next_router(smartlist_t *cons, int cur); -STATIC int *lcs_lengths(smartlist_slice_t *slice1, smartlist_slice_t *slice2, +STATIC int next_router(const smartlist_t *cons, int cur); +STATIC int *lcs_lengths(const smartlist_slice_t *slice1, + const smartlist_slice_t *slice2, int direction); STATIC void trim_slices(smartlist_slice_t *slice1, smartlist_slice_t *slice2); STATIC int base64cmp(const char *hash1, const char *hash2); STATIC const char *get_id_hash(const char *r_line); STATIC int is_valid_router_entry(const char *line); -STATIC int smartlist_slice_string_pos(smartlist_slice_t *slice, +STATIC int smartlist_slice_string_pos(const smartlist_slice_t *slice, const char *string); STATIC void set_changed(bitarray_t *changed1, bitarray_t *changed2, - smartlist_slice_t *slice1, smartlist_slice_t *slice2); + const smartlist_slice_t *slice1, + const smartlist_slice_t *slice2); STATIC int consensus_compute_digest(const char *cons, consensus_digest_t *digest_out); #endif

1 0

[tor/master] prop140: Use sha3-256, not sha2-256
by nickm＠torproject.org 16 Mar '17

16 Mar '17

commit 3647751c2ac093d3fffb6243813f622348bf756d Author: Nick Mathewson <nickm(a)torproject.org> Date: Tue Mar 7 13:02:00 2017 -0500 prop140: Use sha3-256, not sha2-256 This is a protocol update from recent prop140 changes. Also, per #21673, we need to check the entire document, including signatures. --- src/or/consdiff.c | 38 +++++++++++++++--------- src/or/consdiff.h | 10 +++++-- src/test/test_consdiff.c | 76 +++++++++++++++++++++++++----------------------- 3 files changed, 71 insertions(+), 53 deletions(-) diff --git a/src/or/consdiff.c b/src/or/consdiff.c index f8cf180..296b43d 100644 --- a/src/or/consdiff.c +++ b/src/or/consdiff.c @@ -39,6 +39,15 @@ static const char* ns_diff_version = "network-status-diff-version 1"; static const char* hash_token = "hash"; +STATIC int +consensus_compute_digest(const char *cons, + consensus_digest_t *digest_out) +{ + int r = crypto_digest256((char*)digest_out->sha3_256, + cons, strlen(cons), DIGEST_SHA3_256); + return r; +} + /** Create (allocate) a new slice from a smartlist. Assumes that the start * and the end indexes are within the bounds of the initial smartlist. The end * element is not part of the resulting slice. If end is -1, the slice is to @@ -790,7 +799,7 @@ apply_ed_diff(smartlist_t *cons1, smartlist_t *diff) */ smartlist_t * consdiff_gen_diff(smartlist_t *cons1, smartlist_t *cons2, - common_digests_t *digests1, common_digests_t *digests2) + consensus_digest_t *digests1, consensus_digest_t *digests2) { smartlist_t *ed_diff = gen_ed_diff(cons1, cons2); /* ed diff could not be generated - reason already logged by gen_ed_diff. */ @@ -824,9 +833,9 @@ consdiff_gen_diff(smartlist_t *cons1, smartlist_t *cons2, char cons1_hash_hex[HEX_DIGEST256_LEN+1]; char cons2_hash_hex[HEX_DIGEST256_LEN+1]; base16_encode(cons1_hash_hex, HEX_DIGEST256_LEN+1, - digests1->d[DIGEST_SHA256], DIGEST256_LEN); + (const char*)digests1->sha3_256, DIGEST256_LEN); base16_encode(cons2_hash_hex, HEX_DIGEST256_LEN+1, - digests2->d[DIGEST_SHA256], DIGEST256_LEN); + (const char*)digests2->sha3_256, DIGEST256_LEN); /* Create the resulting consensus diff. */ smartlist_t *result = smartlist_new(); @@ -874,7 +883,7 @@ consdiff_get_digests(smartlist_t *diff, goto error_cleanup; } - /* Grab the SHA256 base16 hashes. */ + /* Grab the base16 digests. */ hash_words = smartlist_new(); smartlist_split_string(hash_words, smartlist_get(diff, 1), " ", 0, 0); @@ -889,7 +898,7 @@ consdiff_get_digests(smartlist_t *diff, /* Expected hashes as found in the consensus diff header. They must be of * length HEX_DIGEST256_LEN, normally 64 hexadecimal characters. * If any of the decodings fail, error to make sure that the hashes are - * proper base16-encoded SHA256 digests. + * proper base16-encoded digests. */ cons1_hash_hex = smartlist_get(hash_words, 1); cons2_hash_hex = smartlist_get(hash_words, 2); @@ -936,7 +945,7 @@ consdiff_get_digests(smartlist_t *diff, */ char * consdiff_apply_diff(smartlist_t *cons1, smartlist_t *diff, - common_digests_t *digests1) + consensus_digest_t *digests1) { smartlist_t *cons2 = NULL; char *cons2_str = NULL; @@ -948,7 +957,7 @@ consdiff_apply_diff(smartlist_t *cons1, smartlist_t *diff, } /* See that the consensus that was given to us matches its hash. */ - if (fast_memneq(digests1->d[DIGEST_SHA256], e_cons1_hash, + if (fast_memneq(digests1->sha3_256, e_cons1_hash, DIGEST256_LEN)) { char hex_digest1[HEX_DIGEST256_LEN+1]; char e_hex_digest1[HEX_DIGEST256_LEN+1]; @@ -956,9 +965,9 @@ consdiff_apply_diff(smartlist_t *cons1, smartlist_t *diff, "the base consensus doesn't match the digest as found in " "the consensus diff header."); base16_encode(hex_digest1, HEX_DIGEST256_LEN+1, - digests1->d[DIGEST_SHA256], DIGEST256_LEN); + (const char *)digests1->sha3_256, DIGEST256_LEN); base16_encode(e_hex_digest1, HEX_DIGEST256_LEN+1, - e_cons1_hash, DIGEST256_LEN); + e_cons1_hash, DIGEST256_LEN); log_warn(LD_CONSDIFF, "Expected: %s; found: %s", hex_digest1, e_hex_digest1); goto error_cleanup; @@ -983,16 +992,17 @@ consdiff_apply_diff(smartlist_t *cons1, smartlist_t *diff, cons2_str = smartlist_join_strings(cons2, "\n", 1, NULL); - common_digests_t cons2_digests; - if (router_get_networkstatus_v3_hashes(cons2_str, - &cons2_digests)<0) { + consensus_digest_t cons2_digests; + if (consensus_compute_digest(cons2_str, &cons2_digests) < 0) { + /* LCOV_EXCL_START -- digest can't fail */ log_warn(LD_CONSDIFF, "Could not compute digests of the consensus " "resulting from applying a consensus diff."); goto error_cleanup; + /* LCOV_EXCL_STOP */ } /* See that the resulting consensus matches its hash. */ - if (fast_memneq(cons2_digests.d[DIGEST_SHA256], e_cons2_hash, + if (fast_memneq(cons2_digests.sha3_256, e_cons2_hash, DIGEST256_LEN)) { log_warn(LD_CONSDIFF, "Refusing to apply consensus diff because " "the resulting consensus doesn't match the digest as found in " @@ -1000,7 +1010,7 @@ consdiff_apply_diff(smartlist_t *cons1, smartlist_t *diff, char hex_digest2[HEX_DIGEST256_LEN+1]; char e_hex_digest2[HEX_DIGEST256_LEN+1]; base16_encode(hex_digest2, HEX_DIGEST256_LEN+1, - cons2_digests.d[DIGEST_SHA256], DIGEST256_LEN); + (const char *)cons2_digests.sha3_256, DIGEST256_LEN); base16_encode(e_hex_digest2, HEX_DIGEST256_LEN+1, e_cons2_hash, DIGEST256_LEN); log_warn(LD_CONSDIFF, "Expected: %s; found: %s", diff --git a/src/or/consdiff.h b/src/or/consdiff.h index 0f4a25a..1fffaed 100644 --- a/src/or/consdiff.h +++ b/src/or/consdiff.h @@ -7,10 +7,14 @@ #include "or.h" +typedef struct consensus_digest_t { + uint8_t sha3_256[DIGEST256_LEN]; +} consensus_digest_t; + smartlist_t *consdiff_gen_diff(smartlist_t *cons1, smartlist_t *cons2, - common_digests_t *digests1, common_digests_t *digests2); + consensus_digest_t *digests1, consensus_digest_t *digests2); char *consdiff_apply_diff(smartlist_t *cons1, smartlist_t *diff, - common_digests_t *digests1); + consensus_digest_t *digests1); int consdiff_get_digests(smartlist_t *diff, char *digest1_out, char *digest2_out); @@ -45,6 +49,8 @@ STATIC int smartlist_slice_string_pos(smartlist_slice_t *slice, const char *string); STATIC void set_changed(bitarray_t *changed1, bitarray_t *changed2, smartlist_slice_t *slice1, smartlist_slice_t *slice2); +STATIC int consensus_compute_digest(const char *cons, + consensus_digest_t *digest_out); #endif #endif diff --git a/src/test/test_consdiff.c b/src/test/test_consdiff.c index bbe3532..2afebfe 100644 --- a/src/test/test_consdiff.c +++ b/src/test/test_consdiff.c @@ -8,7 +8,6 @@ #include "test.h" #include "consdiff.h" -#include "routerparse.h" #include "log_test_helpers.h" static void @@ -808,7 +807,7 @@ test_consdiff_gen_diff(void *arg) { char *cons1_str=NULL, *cons2_str=NULL; smartlist_t *cons1=NULL, *cons2=NULL, *diff=NULL; - common_digests_t digests1, digests2; + consensus_digest_t digests1, digests2; (void)arg; cons1 = smartlist_new(); cons2 = smartlist_new(); @@ -817,22 +816,22 @@ test_consdiff_gen_diff(void *arg) * Already tested in gen_ed_diff, but see that a NULL ed diff also makes * gen_diff return NULL. */ cons1_str = tor_strdup( - "header\nnetwork-status-version foo\n" + "network-status-version foo\n" "r name bbbbbbbbbbbbbbbbb etc\nfoo\n" "r name aaaaaaaaaaaaaaaaa etc\nbar\n" "directory-signature foo bar\nbar\n" ); cons2_str = tor_strdup( - "header\nnetwork-status-version foo\n" + "network-status-version foo\n" "r name aaaaaaaaaaaaaaaaa etc\nfoo\n" "r name ccccccccccccccccc etc\nbar\n" "directory-signature foo bar\nbar\n" ); tt_int_op(0, OP_EQ, - router_get_networkstatus_v3_hashes(cons1_str, &digests1)); + consensus_compute_digest(cons1_str, &digests1)); tt_int_op(0, OP_EQ, - router_get_networkstatus_v3_hashes(cons2_str, &digests2)); + consensus_compute_digest(cons2_str, &digests2)); tor_split_lines(cons1, cons1_str, (int)strlen(cons1_str)); tor_split_lines(cons2, cons2_str, (int)strlen(cons2_str)); @@ -843,13 +842,13 @@ test_consdiff_gen_diff(void *arg) /* Check that the headers are done properly. */ tor_free(cons1_str); cons1_str = tor_strdup( - "header\nnetwork-status-version foo\n" + "network-status-version foo\n" "r name ccccccccccccccccc etc\nfoo\n" "r name eeeeeeeeeeeeeeeee etc\nbar\n" "directory-signature foo bar\nbar\n" ); tt_int_op(0, OP_EQ, - router_get_networkstatus_v3_hashes(cons1_str, &digests1)); + consensus_compute_digest(cons1_str, &digests1)); smartlist_clear(cons1); tor_split_lines(cons1, cons1_str, (int)strlen(cons1_str)); diff = consdiff_gen_diff(cons1, cons2, &digests1, &digests2); @@ -857,11 +856,11 @@ test_consdiff_gen_diff(void *arg) tt_int_op(7, OP_EQ, smartlist_len(diff)); tt_str_op("network-status-diff-version 1", OP_EQ, smartlist_get(diff, 0)); tt_str_op("hash " - "C2199B6827514F39ED9B3F2E2E73735C6C5468FD636240BB454C526220DE702A " - "B193E5FBFE5C009AEDE56F9218E6421A1AE5C19F43E091786A73F43F60409B60", + "06646D6CF563A41869D3B02E73254372AE3140046C5E7D83C9F71E54976AF9B4 " + "7AFECEFA4599BA33D603653E3D2368F648DF4AC4723929B0F7CF39281596B0C1", OP_EQ, smartlist_get(diff, 1)); - tt_str_op("4,5d", OP_EQ, smartlist_get(diff, 2)); - tt_str_op("2a", OP_EQ, smartlist_get(diff, 3)); + tt_str_op("3,4d", OP_EQ, smartlist_get(diff, 2)); + tt_str_op("1a", OP_EQ, smartlist_get(diff, 3)); tt_str_op("r name aaaaaaaaaaaaaaaaa etc", OP_EQ, smartlist_get(diff, 4)); tt_str_op("foo", OP_EQ, smartlist_get(diff, 5)); tt_str_op(".", OP_EQ, smartlist_get(diff, 6)); @@ -882,20 +881,20 @@ test_consdiff_apply_diff(void *arg) { smartlist_t *cons1=NULL, *diff=NULL; char *cons1_str=NULL, *cons2 = NULL; - common_digests_t digests1; + consensus_digest_t digests1; (void)arg; cons1 = smartlist_new(); diff = smartlist_new(); setup_capture_of_logs(LOG_INFO); cons1_str = tor_strdup( - "header\nnetwork-status-version foo\n" + "network-status-version foo\n" "r name ccccccccccccccccc etc\nfoo\n" "r name eeeeeeeeeeeeeeeee etc\nbar\n" "directory-signature foo bar\nbar\n" ); tt_int_op(0, OP_EQ, - router_get_networkstatus_v3_hashes(cons1_str, &digests1)); + consensus_compute_digest(cons1_str, &digests1)); tor_split_lines(cons1, cons1_str, (int)strlen(cons1_str)); /* diff doesn't have enough lines. */ @@ -930,7 +929,7 @@ test_consdiff_apply_diff(void *arg) tt_ptr_op(NULL, OP_EQ, cons2); expect_single_log_msg_containing("does not include the necessary digests") - /* base16 sha256 digests do not have the expected length. */ + /* base16 digests do not have the expected length. */ smartlist_clear(diff); smartlist_add(diff, (char*)"network-status-diff-version 1"); smartlist_add(diff, (char*)"hash aaa bbb"); @@ -940,7 +939,7 @@ test_consdiff_apply_diff(void *arg) expect_single_log_msg_containing("includes base16-encoded digests of " "incorrect size") - /* base16 sha256 digests contain non-base16 characters. */ + /* base16 digests contain non-base16 characters. */ smartlist_clear(diff); smartlist_add(diff, (char*)"network-status-diff-version 1"); smartlist_add(diff, (char*)"hash" @@ -957,8 +956,8 @@ test_consdiff_apply_diff(void *arg) smartlist_clear(diff); smartlist_add(diff, (char*)"network-status-diff-version 1"); smartlist_add(diff, (char*)"hash" - /* sha256 of cons1. */ - " C2199B6827514F39ED9B3F2E2E73735C6C5468FD636240BB454C526220DE702A" + /* sha3 of cons1. */ + " 06646D6CF563A41869D3B02E73254372AE3140046C5E7D83C9F71E54976AF9B4" /* sha256 of cons2. */ " 635D34593020C08E5ECD865F9986E29D50028EFA62843766A8197AD228A7F6AA"); smartlist_add(diff, (char*)"foobar"); @@ -986,9 +985,9 @@ test_consdiff_apply_diff(void *arg) smartlist_clear(diff); smartlist_add(diff, (char*)"network-status-diff-version 1"); smartlist_add(diff, (char*)"hash" - /* sha256 of cons1. */ - " C2199B6827514F39ED9B3F2E2E73735C6C5468FD636240BB454C526220DE702A" - /* bogus sha256. */ + /* sha3 of cons1. */ + " 06646D6CF563A41869D3B02E73254372AE3140046C5E7D83C9F71E54976AF9B4" + /* bogus sha3. */ " 3333333333333333333333333333333333333333333333333333333333333333"); mock_clean_saved_logs(); cons2 = consdiff_apply_diff(cons1, diff, &digests1); @@ -996,13 +995,15 @@ test_consdiff_apply_diff(void *arg) expect_log_msg_containing("resulting consensus doesn't match the " "digest as found"); +#if 0 + /* XXXX No longer possible, since we aren't using the other algorithm. */ /* Resulting consensus digest cannot be computed */ smartlist_clear(diff); smartlist_add(diff, (char*)"network-status-diff-version 1"); smartlist_add(diff, (char*)"hash" - /* sha256 of cons1. */ - " C2199B6827514F39ED9B3F2E2E73735C6C5468FD636240BB454C526220DE702A" - /* bogus sha256. */ + /* sha3 of cons1. */ + " 06646D6CF563A41869D3B02E73254372AE3140046C5E7D83C9F71E54976AF9B4" + /* bogus sha3. */ " 3333333333333333333333333333333333333333333333333333333333333333"); smartlist_add(diff, (char*)"1,2d"); // remove starting line mock_clean_saved_logs(); @@ -1010,22 +1011,23 @@ test_consdiff_apply_diff(void *arg) tt_ptr_op(NULL, OP_EQ, cons2); expect_log_msg_containing("Could not compute digests of the consensus " "resulting from applying a consensus diff."); +#endif /* Very simple test, only to see that nothing errors. */ smartlist_clear(diff); smartlist_add(diff, (char*)"network-status-diff-version 1"); smartlist_add(diff, (char*)"hash" - /* sha256 of cons1. */ - " C2199B6827514F39ED9B3F2E2E73735C6C5468FD636240BB454C526220DE702A" - /* sha256 of cons2. */ - " 635D34593020C08E5ECD865F9986E29D50028EFA62843766A8197AD228A7F6AA"); - smartlist_add(diff, (char*)"4c"); + /* sha3 of cons1. */ + " 06646D6CF563A41869D3B02E73254372AE3140046C5E7D83C9F71E54976AF9B4" + /* sha3 of cons2. */ + " 90A418881B2FCAB3D9E60EE02E4D666D56CFA38F8A3B7AA3E0ADBA530DDA9353"); + smartlist_add(diff, (char*)"3c"); smartlist_add(diff, (char*)"sample"); smartlist_add(diff, (char*)"."); cons2 = consdiff_apply_diff(cons1, diff, &digests1); tt_ptr_op(NULL, OP_NE, cons2); tt_str_op( - "header\nnetwork-status-version foo\n" + "network-status-version foo\n" "r name ccccccccccccccccc etc\nsample\n" "r name eeeeeeeeeeeeeeeee etc\nbar\n" "directory-signature foo bar\nbar\n", OP_EQ, @@ -1036,17 +1038,17 @@ test_consdiff_apply_diff(void *arg) smartlist_clear(diff); smartlist_add(diff, (char*)"network-status-diff-version 1"); smartlist_add(diff, (char*)"hash" - /* sha256 of cons1. */ - " c2199b6827514f39ed9b3f2e2e73735c6c5468fd636240bb454c526220de702a" - /* sha256 of cons2. */ - " 635d34593020c08e5ecd865f9986e29d50028efa62843766a8197ad228a7f6aa"); - smartlist_add(diff, (char*)"4c"); + /* sha3 of cons1. */ + " 06646d6cf563a41869d3b02e73254372ae3140046c5e7d83c9f71e54976af9b4" + /* sha3 of cons2. */ + " 90a418881b2fcab3d9e60ee02e4d666d56cfa38f8a3b7aa3e0adba530dda9353"); + smartlist_add(diff, (char*)"3c"); smartlist_add(diff, (char*)"sample"); smartlist_add(diff, (char*)"."); cons2 = consdiff_apply_diff(cons1, diff, &digests1); tt_ptr_op(NULL, OP_NE, cons2); tt_str_op( - "header\nnetwork-status-version foo\n" + "network-status-version foo\n" "r name ccccccccccccccccc etc\nsample\n" "r name eeeeeeeeeeeeeeeee etc\nbar\n" "directory-signature foo bar\nbar\n", OP_EQ,

1 0

[tor/master] Remove digest[12]_hex
by nickm＠torproject.org 16 Mar '17

16 Mar '17

commit f193b666cd50ff04e48c8efeeeb13920438cf88b Author: Nick Mathewson <nickm(a)torproject.org> Date: Tue Mar 7 11:42:24 2017 -0500 Remove digest[12]_hex --- src/or/consdiff.c | 27 +++++++++------------------ src/or/consdiff.h | 4 ++-- 2 files changed, 11 insertions(+), 20 deletions(-) diff --git a/src/or/consdiff.c b/src/or/consdiff.c index 73ac797..a3006ce 100644 --- a/src/or/consdiff.c +++ b/src/or/consdiff.c @@ -846,14 +846,13 @@ consdiff_gen_diff(smartlist_t *cons1, smartlist_t *cons2, } /** Fetch the digest of the base consensus in the consensus diff, encoded in - * base16 as found in the diff itself. digest1 and digest2 must be of length - * DIGEST256_LEN or larger if not NULL. digest1_hex and digest2_hex must be of - * length HEX_DIGEST256_LEN or larger if not NULL. + * base16 as found in the diff itself. digest1_out and digest2_out must be of + * length DIGEST256_LEN or larger if not NULL. */ int consdiff_get_digests(smartlist_t *diff, - char *digest1, char *digest1_hex, - char *digest2, char *digest2_hex) + char *digest1_out, + char *digest2_out) { smartlist_t *hash_words = NULL; const char *format; @@ -897,13 +896,6 @@ consdiff_get_digests(smartlist_t *diff, goto error_cleanup; } - if (digest1_hex) { - strlcpy(digest1_hex, cons1_hash_hex, HEX_DIGEST256_LEN+1); - } - if (digest2_hex) { - strlcpy(digest2_hex, cons2_hash_hex, HEX_DIGEST256_LEN+1); - } - if (base16_decode(cons1_hash, DIGEST256_LEN, cons1_hash_hex, HEX_DIGEST256_LEN) != DIGEST256_LEN || base16_decode(cons2_hash, DIGEST256_LEN, @@ -913,11 +905,11 @@ consdiff_get_digests(smartlist_t *diff, goto error_cleanup; } - if (digest1) { - memcpy(digest1, cons1_hash, DIGEST256_LEN); + if (digest1_out) { + memcpy(digest1_out, cons1_hash, DIGEST256_LEN); } - if (digest2) { - memcpy(digest2, cons2_hash, DIGEST256_LEN); + if (digest2_out) { + memcpy(digest2_out, cons2_hash, DIGEST256_LEN); } SMARTLIST_FOREACH(hash_words, char *, cp, tor_free(cp)); @@ -947,8 +939,7 @@ consdiff_apply_diff(smartlist_t *cons1, smartlist_t *diff, char e_cons1_hash[DIGEST256_LEN]; char e_cons2_hash[DIGEST256_LEN]; - if (consdiff_get_digests(diff, - e_cons1_hash, NULL, e_cons2_hash, NULL) != 0) { + if (consdiff_get_digests(diff, e_cons1_hash, e_cons2_hash) != 0) { goto error_cleanup; } diff --git a/src/or/consdiff.h b/src/or/consdiff.h index 7d49419..0f4a25a 100644 --- a/src/or/consdiff.h +++ b/src/or/consdiff.h @@ -12,8 +12,8 @@ smartlist_t *consdiff_gen_diff(smartlist_t *cons1, smartlist_t *cons2, char *consdiff_apply_diff(smartlist_t *cons1, smartlist_t *diff, common_digests_t *digests1); int consdiff_get_digests(smartlist_t *diff, - char *digest1, char *digest1_hex, - char *digest2, char *digest2_hex); + char *digest1_out, + char *digest2_out); #ifdef CONSDIFF_PRIVATE /** Data structure to define a slice of a smarltist. */

1 0

[tor/master] Make consensus diff sha3 operations mockable.
by nickm＠torproject.org 16 Mar '17

16 Mar '17

commit 653c6d129efc93899ffb447d99ecee98dd7ab373 Author: Nick Mathewson <nickm(a)torproject.org> Date: Tue Mar 7 14:12:53 2017 -0500 Make consensus diff sha3 operations mockable. (We'll want this for fuzzing) --- src/or/consdiff.c | 16 ++++++++++++---- src/or/consdiff.h | 9 +++++++-- 2 files changed, 19 insertions(+), 6 deletions(-) diff --git a/src/or/consdiff.c b/src/or/consdiff.c index 3266abd..16933de 100644 --- a/src/or/consdiff.c +++ b/src/or/consdiff.c @@ -51,6 +51,14 @@ consensus_compute_digest,(const char *cons, return r; } +/** DOCDOC */ +MOCK_IMPL(STATIC int, +consensus_digest_eq,(const uint8_t *d1, + const uint8_t *d2)) +{ + return fast_memeq(d1, d2, DIGEST256_LEN); +} + /** Create (allocate) a new slice from a smartlist. Assumes that the start * and the end indexes are within the bounds of the initial smartlist. The end * element is not part of the resulting slice. If end is -1, the slice is to @@ -965,8 +973,8 @@ consdiff_apply_diff(const smartlist_t *cons1, } /* See that the consensus that was given to us matches its hash. */ - if (fast_memneq(digests1->sha3_256, e_cons1_hash, - DIGEST256_LEN)) { + if (!consensus_digest_eq(digests1->sha3_256, + (const uint8_t*)e_cons1_hash)) { char hex_digest1[HEX_DIGEST256_LEN+1]; char e_hex_digest1[HEX_DIGEST256_LEN+1]; log_warn(LD_CONSDIFF, "Refusing to apply consensus diff because " @@ -1002,8 +1010,8 @@ consdiff_apply_diff(const smartlist_t *cons1, } /* See that the resulting consensus matches its hash. */ - if (fast_memneq(cons2_digests.sha3_256, e_cons2_hash, - DIGEST256_LEN)) { + if (!consensus_digest_eq(cons2_digests.sha3_256, + (const uint8_t*)e_cons2_hash)) { log_warn(LD_CONSDIFF, "Refusing to apply consensus diff because " "the resulting consensus doesn't match the digest as found in " "the consensus diff header."); diff --git a/src/or/consdiff.h b/src/or/consdiff.h index eef3653..7797067 100644 --- a/src/or/consdiff.h +++ b/src/or/consdiff.h @@ -62,8 +62,13 @@ STATIC int smartlist_slice_string_pos(const smartlist_slice_t *slice, STATIC void set_changed(bitarray_t *changed1, bitarray_t *changed2, const smartlist_slice_t *slice1, const smartlist_slice_t *slice2); -STATIC int consensus_compute_digest(const char *cons, - consensus_digest_t *digest_out); + +MOCK_DECL(STATIC int, + consensus_compute_digest,(const char *cons, + consensus_digest_t *digest_out)); +MOCK_DECL(STATIC int, + consensus_digest_eq,(const uint8_t *d1, + const uint8_t *d2)); #endif #endif

1 0

[tor/master] Add a couple more cases to reach 100% coverage.
by nickm＠torproject.org 16 Mar '17

16 Mar '17

commit d6594bfa8c56a6a6896c8ca8761e39f0c3dd59a2 Author: Nick Mathewson <nickm(a)torproject.org> Date: Tue Mar 7 12:30:13 2017 -0500 Add a couple more cases to reach 100% coverage. --- src/test/test_consdiff.c | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/src/test/test_consdiff.c b/src/test/test_consdiff.c index b511d94..bbe3532 100644 --- a/src/test/test_consdiff.c +++ b/src/test/test_consdiff.c @@ -449,6 +449,25 @@ test_consdiff_gen_ed_diff(void *arg) "because the target consensus doesn't have its router entries sorted " "properly."); + /* Same as the two above, but with the reversed thing immediately after a + match. (The code handles this differently) */ + smartlist_del(cons1, 0); + smartlist_add(cons1, (char*)"r name aaaaaaaaaaaaaaaaaaaaaaaaaaa etc"); + + mock_clean_saved_logs(); + diff = gen_ed_diff(cons1, cons2); + tt_ptr_op(NULL, OP_EQ, diff); + expect_single_log_msg_containing("Refusing to generate consensus diff " + "because the base consensus doesn't have its router entries sorted " + "properly."); + + mock_clean_saved_logs(); + diff = gen_ed_diff(cons2, cons1); + tt_ptr_op(NULL, OP_EQ, diff); + expect_single_log_msg_containing("Refusing to generate consensus diff " + "because the target consensus doesn't have its router entries sorted " + "properly."); + /* Identity hashes are repeated, return NULL. */ smartlist_clear(cons1);

1 0

[tor/master] Fix an unreachable memory leak.
by nickm＠torproject.org 16 Mar '17

16 Mar '17

commit e1418c09fc2609c4c43b0eebb6b6676139573a02 Author: Nick Mathewson <nickm(a)torproject.org> Date: Tue Mar 7 11:47:19 2017 -0500 Fix an unreachable memory leak. Also add a missing newline. --- src/or/consdiff.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/or/consdiff.c b/src/or/consdiff.c index a3006ce..f8cf180 100644 --- a/src/or/consdiff.c +++ b/src/or/consdiff.c @@ -832,14 +832,18 @@ consdiff_gen_diff(smartlist_t *cons1, smartlist_t *cons2, smartlist_t *result = smartlist_new(); smartlist_add_asprintf(result, "%s", ns_diff_version); smartlist_add_asprintf(result, "%s %s %s", hash_token, - cons1_hash_hex, cons2_hash_hex); smartlist_add_all(result, ed_diff); + cons1_hash_hex, cons2_hash_hex); + smartlist_add_all(result, ed_diff); smartlist_free(ed_diff); return result; error_cleanup: if (ed_diff) { + /* LCOV_EXCL_START -- ed_diff is NULL except in unreachable cases above */ + SMARTLIST_FOREACH(ed_diff, char *, cp, tor_free(cp)); smartlist_free(ed_diff); + /* LCOV_EXCL_STOP */ } return NULL;

1 0

[tor/master] Add fuzzers for consensus diff backend code
by nickm＠torproject.org 16 Mar '17

16 Mar '17

commit dd92579b63fa012bcbe081ab66ff40d6a036b765 Author: Nick Mathewson <nickm(a)torproject.org> Date: Tue Mar 7 15:07:27 2017 -0500 Add fuzzers for consensus diff backend code This takes two fuzzers: one which generates a diff and makes sure it works, and one which applies a diff. So far, they won't crash, but there's a bug in my string-manipulation code someplace that I'm having to work around, related to the case where you have a blank line at the end of a file, or where you diff a file with itself. --- src/test/fuzz/fuzz_diff.c | 67 +++++++++++++++++++++++++++++++++++++++++ src/test/fuzz/fuzz_diff_apply.c | 65 +++++++++++++++++++++++++++++++++++++++ src/test/fuzz/include.am | 47 ++++++++++++++++++++++++++++- 3 files changed, 178 insertions(+), 1 deletion(-) diff --git a/src/test/fuzz/fuzz_diff.c b/src/test/fuzz/fuzz_diff.c new file mode 100644 index 0000000..c241f63 --- /dev/null +++ b/src/test/fuzz/fuzz_diff.c @@ -0,0 +1,67 @@ +/* Copyright (c) 2016, The Tor Project, Inc. */ +/* See LICENSE for licensing information */ + +#define CONSDIFF_PRIVATE + +#include "orconfig.h" +#include "or.h" +#include "consdiff.h" + +#include "fuzzing.h" + +static int +mock_consensus_compute_digest_(const char *c, consensus_digest_t *d) +{ + (void)c; + memset(d->sha3_256, 3, sizeof(d->sha3_256)); + return 0; +} + +int +fuzz_init(void) +{ + MOCK(consensus_compute_digest, mock_consensus_compute_digest_); + return 0; +} + +int +fuzz_cleanup(void) +{ + UNMOCK(consensus_compute_digest); + return 0; +} + +int +fuzz_main(const uint8_t *stdin_buf, size_t data_size) +{ +#define SEP "=====\n" +#define SEPLEN strlen(SEP) + const uint8_t *separator = tor_memmem(stdin_buf, data_size, SEP, SEPLEN); + if (! separator) + return 0; + size_t c1_len = separator - stdin_buf; + char *c1 = tor_memdup_nulterm(stdin_buf, c1_len); + size_t c2_len = data_size - c1_len - SEPLEN; + char *c2 = tor_memdup_nulterm(separator + SEPLEN, c2_len); + + char *c3 = consensus_diff_generate(c1, c2); + + if (c3) { + char *c4 = consensus_diff_apply(c1, c3); + tor_assert(c4); + if (strcmp(c2, c4)) { + printf("%s\n", escaped(c1)); + printf("%s\n", escaped(c2)); + printf("%s\n", escaped(c3)); + printf("%s\n", escaped(c4)); + } + tor_assert(! strcmp(c2, c4)); + tor_free(c3); + tor_free(c4); + } + tor_free(c1); + tor_free(c2); + + return 0; +} + diff --git a/src/test/fuzz/fuzz_diff_apply.c b/src/test/fuzz/fuzz_diff_apply.c new file mode 100644 index 0000000..8d7bf75 --- /dev/null +++ b/src/test/fuzz/fuzz_diff_apply.c @@ -0,0 +1,65 @@ +/* Copyright (c) 2016, The Tor Project, Inc. */ +/* See LICENSE for licensing information */ + +#define CONSDIFF_PRIVATE + +#include "orconfig.h" +#include "or.h" +#include "consdiff.h" + +#include "fuzzing.h" + +static int +mock_consensus_compute_digest_(const char *c, consensus_digest_t *d) +{ + (void)c; + memset(d->sha3_256, 3, sizeof(d->sha3_256)); + return 0; +} + +static int +mock_consensus_digest_eq_(const uint8_t *a, const uint8_t *b) +{ + (void)a; + (void)b; + return 1; +} + +int +fuzz_init(void) +{ + MOCK(consensus_compute_digest, mock_consensus_compute_digest_); + MOCK(consensus_digest_eq, mock_consensus_digest_eq_); + return 0; +} + +int +fuzz_cleanup(void) +{ + UNMOCK(consensus_compute_digest); + UNMOCK(consensus_digest_eq); + return 0; +} + +int +fuzz_main(const uint8_t *stdin_buf, size_t data_size) +{ +#define SEP "=====\n" +#define SEPLEN strlen(SEP) + const uint8_t *separator = tor_memmem(stdin_buf, data_size, SEP, SEPLEN); + if (! separator) + return 0; + size_t c1_len = separator - stdin_buf; + char *c1 = tor_memdup_nulterm(stdin_buf, c1_len); + size_t c2_len = data_size - c1_len - SEPLEN; + char *c2 = tor_memdup_nulterm(separator + SEPLEN, c2_len); + + char *c3 = consensus_diff_apply(c1, c2); + + tor_free(c1); + tor_free(c2); + tor_free(c3); + + return 0; +} + diff --git a/src/test/fuzz/include.am b/src/test/fuzz/include.am index 8067108..97afd18 100644 --- a/src/test/fuzz/include.am +++ b/src/test/fuzz/include.am @@ -48,6 +48,22 @@ src_test_fuzz_fuzz_descriptor_CFLAGS = $(FUZZING_CFLAGS) src_test_fuzz_fuzz_descriptor_LDFLAGS = $(FUZZING_LDFLAG) src_test_fuzz_fuzz_descriptor_LDADD = $(FUZZING_LIBS) +src_test_fuzz_fuzz_diff_SOURCES = \ + src/test/fuzz/fuzzing_common.c \ + src/test/fuzz/fuzz_diff.c +src_test_fuzz_fuzz_diff_CPPFLAGS = $(FUZZING_CPPFLAGS) +src_test_fuzz_fuzz_diff_CFLAGS = $(FUZZING_CFLAGS) +src_test_fuzz_fuzz_diff_LDFLAGS = $(FUZZING_LDFLAG) +src_test_fuzz_fuzz_diff_LDADD = $(FUZZING_LIBS) + +src_test_fuzz_fuzz_diff_apply_SOURCES = \ + src/test/fuzz/fuzzing_common.c \ + src/test/fuzz/fuzz_diff_apply.c +src_test_fuzz_fuzz_diff_apply_CPPFLAGS = $(FUZZING_CPPFLAGS) +src_test_fuzz_fuzz_diff_apply_CFLAGS = $(FUZZING_CFLAGS) +src_test_fuzz_fuzz_diff_apply_LDFLAGS = $(FUZZING_LDFLAG) +src_test_fuzz_fuzz_diff_apply_LDADD = $(FUZZING_LIBS) + src_test_fuzz_fuzz_http_SOURCES = \ src/test/fuzz/fuzzing_common.c \ src/test/fuzz/fuzz_http.c @@ -99,6 +115,8 @@ src_test_fuzz_fuzz_vrs_LDADD = $(FUZZING_LIBS) FUZZERS = \ src/test/fuzz/fuzz-consensus \ src/test/fuzz/fuzz-descriptor \ + src/test/fuzz/fuzz-diff \ + src/test/fuzz/fuzz-diff-apply \ src/test/fuzz/fuzz-extrainfo \ src/test/fuzz/fuzz-http \ src/test/fuzz/fuzz-hsdescv2 \ @@ -106,7 +124,6 @@ FUZZERS = \ src/test/fuzz/fuzz-microdesc \ src/test/fuzz/fuzz-vrs - LIBFUZZER = /home/nickm/build/libfuzz/libFuzzer.a LIBFUZZER_CPPFLAGS = $(FUZZING_CPPFLAGS) -DLLVM_FUZZ LIBFUZZER_CFLAGS = $(FUZZING_CFLAGS) @@ -128,6 +145,20 @@ src_test_fuzz_lf_fuzz_descriptor_CFLAGS = $(LIBFUZZER_CFLAGS) src_test_fuzz_lf_fuzz_descriptor_LDFLAGS = $(LIBFUZZER_LDFLAG) src_test_fuzz_lf_fuzz_descriptor_LDADD = $(LIBFUZZER_LIBS) +src_test_fuzz_lf_fuzz_diff_SOURCES = \ + $(src_test_fuzz_fuzz_diff_SOURCES) +src_test_fuzz_lf_fuzz_diff_CPPFLAGS = $(LIBFUZZER_CPPFLAGS) +src_test_fuzz_lf_fuzz_diff_CFLAGS = $(LIBFUZZER_CFLAGS) +src_test_fuzz_lf_fuzz_diff_LDFLAGS = $(LIBFUZZER_LDFLAG) +src_test_fuzz_lf_fuzz_diff_LDADD = $(LIBFUZZER_LIBS) + +src_test_fuzz_lf_fuzz_diff_apply_SOURCES = \ + $(src_test_fuzz_fuzz_diff_apply_SOURCES) +src_test_fuzz_lf_fuzz_diff_apply_CPPFLAGS = $(LIBFUZZER_CPPFLAGS) +src_test_fuzz_lf_fuzz_diff_apply_CFLAGS = $(LIBFUZZER_CFLAGS) +src_test_fuzz_lf_fuzz_diff_apply_LDFLAGS = $(LIBFUZZER_LDFLAG) +src_test_fuzz_lf_fuzz_diff_apply_LDADD = $(LIBFUZZER_LIBS) + src_test_fuzz_lf_fuzz_extrainfo_SOURCES = \ $(src_test_fuzz_fuzz_extrainfo_SOURCES) src_test_fuzz_lf_fuzz_extrainfo_CPPFLAGS = $(LIBFUZZER_CPPFLAGS) @@ -172,6 +203,8 @@ src_test_fuzz_lf_fuzz_vrs_LDADD = $(LIBFUZZER_LIBS) LIBFUZZER_FUZZERS = \ src/test/fuzz/lf-fuzz-consensus \ + src/test/fuzz/lf-fuzz-diff \ + src/test/fuzz/lf-fuzz-diff-apply \ src/test/fuzz/lf-fuzz-descriptor \ src/test/fuzz/lf-fuzz-extrainfo \ src/test/fuzz/lf-fuzz-http \ @@ -198,6 +231,16 @@ src_test_fuzz_liboss_fuzz_descriptor_a_SOURCES = \ src_test_fuzz_liboss_fuzz_descriptor_a_CPPFLAGS = $(LIBOSS_FUZZ_CPPFLAGS) src_test_fuzz_liboss_fuzz_descriptor_a_CFLAGS = $(LIBOSS_FUZZ_CFLAGS) +src_test_fuzz_liboss_fuzz_diff_a_SOURCES = \ + $(src_test_fuzz_fuzz_diff_SOURCES) +src_test_fuzz_liboss_fuzz_diff_a_CPPFLAGS = $(LIBOSS_FUZZ_CPPFLAGS) +src_test_fuzz_liboss_fuzz_diff_a_CFLAGS = $(LIBOSS_FUZZ_CFLAGS) + +src_test_fuzz_liboss_fuzz_diff_apply_a_SOURCES = \ + $(src_test_fuzz_fuzz_diff_apply_SOURCES) +src_test_fuzz_liboss_fuzz_diff_apply_a_CPPFLAGS = $(LIBOSS_FUZZ_CPPFLAGS) +src_test_fuzz_liboss_fuzz_diff_apply_a_CFLAGS = $(LIBOSS_FUZZ_CFLAGS) + src_test_fuzz_liboss_fuzz_extrainfo_a_SOURCES = \ $(src_test_fuzz_fuzz_extrainfo_SOURCES) src_test_fuzz_liboss_fuzz_extrainfo_a_CPPFLAGS = $(LIBOSS_FUZZ_CPPFLAGS) @@ -231,6 +274,8 @@ src_test_fuzz_liboss_fuzz_vrs_a_CFLAGS = $(LIBOSS_FUZZ_CFLAGS) OSS_FUZZ_FUZZERS = \ src/test/fuzz/liboss-fuzz-consensus.a \ src/test/fuzz/liboss-fuzz-descriptor.a \ + src/test/fuzz/liboss-fuzz-diff.a \ + src/test/fuzz/liboss-fuzz-diff-apply.a \ src/test/fuzz/liboss-fuzz-extrainfo.a \ src/test/fuzz/liboss-fuzz-http.a \ src/test/fuzz/liboss-fuzz-hsdescv2.a \

1 0

[tor/master] Use a better for X outside of base64_compare_table.
by nickm＠torproject.org 16 Mar '17

16 Mar '17

commit e84276124b4503240bce6511a6427e4a3e8327e5 Author: Nick Mathewson <nickm(a)torproject.org> Date: Wed Mar 15 16:41:29 2017 -0400 Use a better for X outside of base64_compare_table. --- src/or/consdiff.c | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/src/or/consdiff.c b/src/or/consdiff.c index 1009519..0376247 100644 --- a/src/or/consdiff.c +++ b/src/or/consdiff.c @@ -333,9 +333,10 @@ calc_changes(smartlist_slice_t *slice1, } /* This table is from crypto.c. The SP and PAD defines are different. */ -#define X 255 -#define SP X -#define PAD X +#define NOT_VALID_BASE64 255 +#define X NOT_VALID_BASE64 +#define SP NOT_VALID_BASE64 +#define PAD NOT_VALID_BASE64 static const uint8_t base64_compare_table[256] = { X, X, X, X, X, X, X, X, X, SP, SP, SP, X, SP, X, X, X, X, X, X, X, X, X, X, X, X, X, X, X, X, X, X, @@ -378,7 +379,8 @@ get_id_hash(const cdline_t *line, cdline_t *hash_out) /* Stop when the first non-base64 character is found. Use unsigned chars to * avoid negative indexes causing crashes. */ - while (base64_compare_table[*((unsigned char*)hash_end)] != X && + while (base64_compare_table[*((unsigned char*)hash_end)] + != NOT_VALID_BASE64 && hash_end < line->s + line->len) { hash_end++; } @@ -458,15 +460,15 @@ base64cmp(const cdline_t *hash1, const cdline_t *hash2) while (1) { uint8_t av = base64_compare_table[*a]; uint8_t bv = base64_compare_table[*b]; - if (av == X) { - if (bv == X) { + if (av == NOT_VALID_BASE64) { + if (bv == NOT_VALID_BASE64) { /* Both ended with exactly the same characters. */ return 0; } else { /* hash2 goes on longer than hash1 and thus hash1 is lower. */ return -1; } - } else if (bv == X) { + } else if (bv == NOT_VALID_BASE64) { /* hash1 goes on longer than hash2 and thus hash1 is greater. */ return 1; } else if (av < bv) {

1 0

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

tor-commits March 2017