tor-commits February 2022

tor-commits@lists.torproject.org

14 participants
1453 discussions

[tor/main] cc: Export sendme_inc validation into public function
by dgoulet＠torproject.org 22 Feb '22

22 Feb '22

commit 02f4e7b42e2158039a138c9cb68211304a754a1d Author: David Goulet <dgoulet(a)torproject.org> Date: Thu Feb 3 22:43:58 2022 +0000 cc: Export sendme_inc validation into public function This is needed for client validation of server descriptor value, before launching a rend/intro. --- src/core/or/congestion_control_common.c | 24 ++++++++++++++++++++++++ src/core/or/congestion_control_common.h | 1 + 2 files changed, 25 insertions(+) diff --git a/src/core/or/congestion_control_common.c b/src/core/or/congestion_control_common.c index e999f435ed..6d4f34cff8 100644 --- a/src/core/or/congestion_control_common.c +++ b/src/core/or/congestion_control_common.c @@ -1312,6 +1312,30 @@ congestion_control_build_ext_response(const circuit_params_t *our_params, return (int)ret; } +/** Return true iff the given sendme increment is within the acceptable + * margins. */ +bool +congestion_control_validate_sendme_increment(uint8_t sendme_inc) +{ + /* We will only accept this response (and this circuit) if sendme_inc + * is within a factor of 2 of our consensus value. We should not need + * to change cc_sendme_inc much, and if we do, we can spread out those + * changes over smaller increments once every 4 hours. Exits that + * violate this range should just not be used. */ +#define MAX_SENDME_INC_NEGOTIATE_FACTOR 2 + + if (sendme_inc == 0) + return false; + + if (sendme_inc > + MAX_SENDME_INC_NEGOTIATE_FACTOR * congestion_control_sendme_inc() || + sendme_inc < + congestion_control_sendme_inc() / MAX_SENDME_INC_NEGOTIATE_FACTOR) { + return false; + } + return true; +} + /** Return 1 if CC is enabled which also will set the SENDME increment into our * params_out. Return 0 if CC is disabled. Else, return -1 on error. */ int diff --git a/src/core/or/congestion_control_common.h b/src/core/or/congestion_control_common.h index 21291983e0..936cb5887c 100644 --- a/src/core/or/congestion_control_common.h +++ b/src/core/or/congestion_control_common.h @@ -59,6 +59,7 @@ int congestion_control_build_ext_response(const circuit_params_t *our_params, int congestion_control_parse_ext_response(const uint8_t *msg, const size_t msg_len, circuit_params_t *params_out); +bool congestion_control_validate_sendme_increment(uint8_t sendme_inc); /* Ugh, C.. these are private. Use the getter instead, when * external to the congestion control code. */

1 0

[tor/main] hs: Setup congestion control on client rends
by dgoulet＠torproject.org 22 Feb '22

22 Feb '22

commit c79df44d2221211590ea0b33b555d559b2d467fa Author: David Goulet <dgoulet(a)torproject.org> Date: Thu Feb 3 19:37:30 2022 +0000 hs: Setup congestion control on client rends Signed-off-by: David Goulet <dgoulet(a)torproject.org> --- src/feature/hs/hs_client.c | 39 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) diff --git a/src/feature/hs/hs_client.c b/src/feature/hs/hs_client.c index 206a42dc0c..69b071e197 100644 --- a/src/feature/hs/hs_client.c +++ b/src/feature/hs/hs_client.c @@ -11,12 +11,15 @@ #include "core/or/or.h" #include "app/config/config.h" #include "core/crypto/hs_ntor.h" +#include "core/crypto/onion_crypto.h" #include "core/mainloop/connection.h" #include "core/or/circuitbuild.h" #include "core/or/circuitlist.h" #include "core/or/circuituse.h" #include "core/or/connection_edge.h" +#include "core/or/congestion_control_common.h" #include "core/or/extendinfo.h" +#include "core/or/protover.h" #include "core/or/reasons.h" #include "feature/client/circpathbias.h" #include "feature/dirclient/dirclient.h" @@ -756,6 +759,39 @@ client_intro_circ_has_opened(origin_circuit_t *circ) connection_ap_attach_pending(1); } +/** Setup the congestion control parameters on the given rendezvous circuit. + * This looks at the service descriptor flow control line (if any). */ +static void +setup_rendezvous_circ_congestion_control(origin_circuit_t *circ) +{ + circuit_params_t circ_params = {0}; + + tor_assert(circ); + + /* Setup congestion control parameters on the circuit. */ + const hs_descriptor_t *desc = + hs_cache_lookup_as_client(&circ->hs_ident->identity_pk); + if (BUG(desc == NULL)) { + /* This should really never happened but in case, scream and stop. */ + return; + } + + /* Check if the service lists support for congestion control in its + * descriptor. If not, we don't setup congestion control. */ + if (!desc->encrypted_data.flow_control_pv || + !protocol_list_supports_protocol(desc->encrypted_data.flow_control_pv, + PRT_FLOWCTRL, PROTOVER_FLOWCTRL_CC)) { + return; + } + + /* Take values from the consensus. */ + circ_params.cc_enabled = congestion_control_enabled(); + if (circ_params.cc_enabled) { + circ_params.sendme_inc_cells = desc->encrypted_data.sendme_inc; + TO_CIRCUIT(circ)->ccontrol = congestion_control_new(&circ_params); + } +} + /** Called when a rendezvous circuit has opened. */ static void client_rendezvous_circ_has_opened(origin_circuit_t *circ) @@ -785,6 +821,9 @@ client_rendezvous_circ_has_opened(origin_circuit_t *circ) log_info(LD_REND, "Rendezvous circuit has opened to %s.", safe_str_client(extend_info_describe(rp_ei))); + /* Setup congestion control parameters on the circuit. */ + setup_rendezvous_circ_congestion_control(circ); + /* Ignore returned value, nothing we can really do. On failure, the circuit * will be marked for close. */ hs_circ_send_establish_rendezvous(circ);

1 0

[tor/main] hs: Republish onion descriptor on sendme_inc change
by dgoulet＠torproject.org 22 Feb '22

22 Feb '22

commit 0eaf0e8a31979621f8a2cfb1671cc4f02fe92b87 Author: David Goulet <dgoulet(a)torproject.org> Date: Thu Feb 3 19:04:34 2022 +0000 hs: Republish onion descriptor on sendme_inc change Republishing is necessary to ensure that clients connect using the correct sendme_inc upon any change. Additionally, introduction points must be re-chosen, so that cached descriptors with old values are not usable. We do not expect to change sendme_inc, unless cell size or TLS record size changes, so this should be rare. Signed-off-by: David Goulet <dgoulet(a)torproject.org> --- src/feature/hs/hs_service.c | 29 +++++++++++++++++++++++++++++ src/feature/hs/hs_service.h | 1 + src/feature/nodelist/networkstatus.c | 1 + 3 files changed, 31 insertions(+) diff --git a/src/feature/hs/hs_service.c b/src/feature/hs/hs_service.c index bf99ad69bd..ff34e5dc44 100644 --- a/src/feature/hs/hs_service.c +++ b/src/feature/hs/hs_service.c @@ -16,6 +16,7 @@ #include "core/or/circuitbuild.h" #include "core/or/circuitlist.h" #include "core/or/circuituse.h" +#include "core/or/congestion_control_common.h" #include "core/or/extendinfo.h" #include "core/or/relay.h" #include "feature/client/circpathbias.h" @@ -3690,6 +3691,34 @@ hs_service_map_has_changed(void) rescan_periodic_events(get_options()); } +/** Called when a new consensus has arrived and has been set globally. The new + * consensus is pointed by ns. */ +void +hs_service_new_consensus_params(const networkstatus_t *ns) +{ + tor_assert(ns); + + /* This value is the new value from the consensus. */ + uint8_t current_sendme_inc = congestion_control_sendme_inc(); + + if (!hs_service_map) + return; + + /* Check each service and look if their descriptor contains a different + * sendme increment. If so, nuke all intro points by forcing an expiration + * which will lead to rebuild and reupload with the new value. */ + FOR_EACH_SERVICE_BEGIN(service) { + FOR_EACH_DESCRIPTOR_BEGIN(service, desc) { + if (desc->desc && + desc->desc->encrypted_data.sendme_inc != current_sendme_inc) { + /* Passing the maximum time_t will force expiration of all intro points + * and thus will lead to a rebuild of the descriptor. */ + cleanup_intro_points(service, LONG_MAX); + } + } FOR_EACH_DESCRIPTOR_END; + } FOR_EACH_SERVICE_END; +} + /** Upload an encoded descriptor in encoded_desc of the given version. This * descriptor is for the service identity_pk and blinded_pk used to setup the * directory connection identifier. It is uploaded to the directory hsdir_rs diff --git a/src/feature/hs/hs_service.h b/src/feature/hs/hs_service.h index c48f470245..95461289ce 100644 --- a/src/feature/hs/hs_service.h +++ b/src/feature/hs/hs_service.h @@ -355,6 +355,7 @@ smartlist_t *hs_service_get_metrics_stores(void); void hs_service_map_has_changed(void); void hs_service_dir_info_changed(void); +void hs_service_new_consensus_params(const networkstatus_t *ns); void hs_service_run_scheduled_events(time_t now); void hs_service_circuit_has_opened(origin_circuit_t *circ); int hs_service_receive_intro_established(origin_circuit_t *circ, diff --git a/src/feature/nodelist/networkstatus.c b/src/feature/nodelist/networkstatus.c index 77e2b547f5..41fd312295 100644 --- a/src/feature/nodelist/networkstatus.c +++ b/src/feature/nodelist/networkstatus.c @@ -1704,6 +1704,7 @@ notify_after_networkstatus_changes(void) router_new_consensus_params(c); congestion_control_new_consensus_params(c); flow_control_new_consensus_params(c); + hs_service_new_consensus_params(c); /* Maintenance of our L2 guard list */ maintain_layer2_guards();

1 0

[tor/main] Implement core of ntor3 negotiation.
by dgoulet＠torproject.org 22 Feb '22

22 Feb '22

commit bd2e9a44097ff85934bc1c34f4fce2017a7a92c8 Author: Nick Mathewson <nickm(a)torproject.org> Date: Tue Sep 14 15:01:45 2021 -0400 Implement core of ntor3 negotiation. There are a lot of TODOs about what to send, whom to send it to, and etc. --- src/core/crypto/onion_crypto.c | 136 ++++++++++++++++++++++++++++++++++++++ src/core/crypto/onion_crypto.h | 3 + src/core/or/circuitbuild.c | 26 +++++++- src/core/or/circuitbuild.h | 4 ++ src/core/or/crypt_path_st.h | 3 + src/core/or/extend_info_st.h | 3 + src/core/or/extendinfo.c | 12 ++++ src/core/or/extendinfo.h | 1 + src/core/or/or.h | 3 +- src/feature/relay/relay_metrics.c | 2 + 10 files changed, 191 insertions(+), 2 deletions(-) diff --git a/src/core/crypto/onion_crypto.c b/src/core/crypto/onion_crypto.c index f93c2c8c58..b0808b80a8 100644 --- a/src/core/crypto/onion_crypto.c +++ b/src/core/crypto/onion_crypto.c @@ -35,14 +35,25 @@ #include "core/crypto/onion_crypto.h" #include "core/crypto/onion_fast.h" #include "core/crypto/onion_ntor.h" +#include "core/crypto/onion_ntor_v3.h" #include "core/crypto/onion_tap.h" #include "feature/relay/router.h" #include "lib/crypt_ops/crypto_dh.h" #include "lib/crypt_ops/crypto_util.h" +#include "feature/relay/routerkeys.h" + +#include "core/or/circuitbuild.h" #include "core/or/crypt_path_st.h" #include "core/or/extend_info_st.h" +/* TODO: Add this to the specification! */ +const uint8_t NTOR3_CIRC_VERIFICATION[] = "circuit extend"; +const size_t NTOR3_CIRC_VERIFICATION_LEN = 14; + +#define NTOR3_VERIFICATION_ARGS \ + NTOR3_CIRC_VERIFICATION, NTOR3_CIRC_VERIFICATION_LEN + /** Return a new server_onion_keys_t object with all of the keys * and other info we might need to do onion handshakes. (We make a copy of * our keys for each cpuworker to avoid race conditions with the main thread, @@ -52,6 +63,7 @@ server_onion_keys_new(void) { server_onion_keys_t *keys = tor_malloc_zero(sizeof(server_onion_keys_t)); memcpy(keys->my_identity, router_get_my_id_digest(), DIGEST_LEN); + ed25519_pubkey_copy(&keys->my_ed_identity, get_master_identity_key()); dup_onion_keys(&keys->onion_key, &keys->last_onion_key); keys->curve25519_key_map = construct_ntor_key_map(); keys->junk_keypair = tor_malloc_zero(sizeof(curve25519_keypair_t)); @@ -91,6 +103,9 @@ onion_handshake_state_release(onion_handshake_state_t *state) ntor_handshake_state_free(state->u.ntor); state->u.ntor = NULL; break; + case ONION_HANDSHAKE_TYPE_NTOR_V3: + ntor3_handshake_state_free(state->u.ntor3); + break; default: /* LCOV_EXCL_START * This state should not even exist. */ @@ -149,6 +164,37 @@ onion_skin_create(int type, r = NTOR_ONIONSKIN_LEN; break; + case ONION_HANDSHAKE_TYPE_NTOR_V3: + if (!extend_info_supports_ntor_v3(node)) + return -1; + if (ed25519_public_key_is_zero(&node->ed_identity)) + return -1; + size_t msg_len = 0; + uint8_t *msg = NULL; + if (client_circ_negotiation_message(node, &msg, &msg_len) < 0) + return -1; + uint8_t *onion_skin = NULL; + size_t onion_skin_len = 0; + int status = onion_skin_ntor3_create( + &node->ed_identity, + &node->curve25519_onion_key, + NTOR3_VERIFICATION_ARGS, + msg, msg_len, /* client message */ + &state_out->u.ntor3, + &onion_skin, &onion_skin_len); + tor_free(msg); + if (status < 0) { + return -1; + } + if (onion_skin_len > onion_skin_out_maxlen) { + tor_free(onion_skin); + return -1; + } + memcpy(onion_skin_out, onion_skin, onion_skin_len); + tor_free(onion_skin); + r = (int) onion_skin_len; + break; + default: /* LCOV_EXCL_START * We should never try to create an impossible handshake type. */ @@ -238,6 +284,64 @@ onion_skin_server_handshake(int type, r = NTOR_REPLY_LEN; } break; + case ONION_HANDSHAKE_TYPE_NTOR_V3: { + size_t keys_tmp_len = keys_out_len + DIGEST_LEN; + tor_assert(keys_tmp_len <= MAX_KEYS_TMP_LEN); + uint8_t keys_tmp[MAX_KEYS_TMP_LEN]; + uint8_t *client_msg = NULL; + size_t client_msg_len = 0; + ntor3_server_handshake_state_t *state = NULL; + + if (onion_skin_ntor3_server_handshake_part1( + keys->curve25519_key_map, + keys->junk_keypair, + &keys->my_ed_identity, + onion_skin, onionskin_len, + NTOR3_VERIFICATION_ARGS, + &client_msg, &client_msg_len, + &state) < 0) { + return -1; + } + + uint8_t reply_msg[1] = { 0 }; + size_t reply_msg_len = 1; + { + /* TODO, Okay, we have a message from the client trying to negotiate + * parameters. We need to decide whether the client's request is + * okay, what we're going to say in response, and what circuit + * parameters we've just negotiated + */ + + tor_free(client_msg); + } + + uint8_t *server_handshake = NULL; + size_t server_handshake_len = 0; + if (onion_skin_ntor3_server_handshake_part2( + state, + NTOR3_VERIFICATION_ARGS, + reply_msg, reply_msg_len, + &server_handshake, &server_handshake_len, + keys_tmp, keys_tmp_len) < 0) { + // XXX TODO free some stuff + return -1; + } + + if (server_handshake_len > reply_out_maxlen) { + // XXX TODO free that stuff + return -1; + } + + memcpy(keys_out, keys_tmp, keys_out_len); + memcpy(rend_nonce_out, keys_tmp+keys_out_len, DIGEST_LEN); + memcpy(reply_out, server_handshake, server_handshake_len); + memwipe(keys_tmp, 0, keys_tmp_len); + memwipe(server_handshake, 0, server_handshake_len); + tor_free(server_handshake); + + r = (int) server_handshake_len; + } + break; default: /* LCOV_EXCL_START * We should have rejected this far before this point */ @@ -321,6 +425,38 @@ onion_skin_client_handshake(int type, tor_free(keys_tmp); } return 0; + case ONION_HANDSHAKE_TYPE_NTOR_V3: { + size_t keys_tmp_len = keys_out_len + DIGEST_LEN; + uint8_t *keys_tmp = tor_malloc(keys_tmp_len); + uint8_t *server_msg = NULL; + size_t server_msg_len = 0; + int r = onion_ntor3_client_handshake( + handshake_state->u.ntor3, + reply, reply_len, + NTOR3_VERIFICATION_ARGS, + keys_tmp, keys_tmp_len, + &server_msg, &server_msg_len); + if (r < 0) { + tor_free(keys_tmp); + tor_free(server_msg); + return -1; + } + + // XXXX handle the server message! + { + // XXXX TODO: see what the server said, make sure it's okay, see what + // parameters it gave us, make sure we like them, and put them into + // `params_out` + } + tor_free(server_msg); + + memcpy(keys_out, keys_tmp, keys_out_len); + memcpy(rend_authenticator_out, keys_tmp + keys_out_len, DIGEST_LEN); + memwipe(keys_tmp, 0, keys_tmp_len); + tor_free(keys_tmp); + + return 0; + } default: log_warn(LD_BUG, "called with unknown handshake state type %d", type); tor_fragile_assert(); diff --git a/src/core/crypto/onion_crypto.h b/src/core/crypto/onion_crypto.h index af8dd1f03f..45e8eeca0c 100644 --- a/src/core/crypto/onion_crypto.h +++ b/src/core/crypto/onion_crypto.h @@ -12,8 +12,11 @@ #ifndef TOR_ONION_CRYPTO_H #define TOR_ONION_CRYPTO_H +#include "lib/crypt_ops/crypto_ed25519.h" + typedef struct server_onion_keys_t { uint8_t my_identity[DIGEST_LEN]; + ed25519_public_key_t my_ed_identity; crypto_pk_t *onion_key; crypto_pk_t *last_onion_key; struct di_digest256_map_t *curve25519_key_map; diff --git a/src/core/or/circuitbuild.c b/src/core/or/circuitbuild.c index f67fe196e5..ffb2c00493 100644 --- a/src/core/or/circuitbuild.c +++ b/src/core/or/circuitbuild.c @@ -841,7 +841,10 @@ circuit_pick_create_handshake(uint8_t *cell_type_out, * using the TAP handshake, and CREATE2 otherwise. */ if (extend_info_supports_ntor(ei)) { *cell_type_out = CELL_CREATE2; - *handshake_type_out = ONION_HANDSHAKE_TYPE_NTOR; + if (ei->supports_ntor3_and_param_negotiation) + *handshake_type_out = ONION_HANDSHAKE_TYPE_NTOR_V3; + else + *handshake_type_out = ONION_HANDSHAKE_TYPE_NTOR; } else { /* XXXX030 Remove support for deciding to use TAP and EXTEND. */ *cell_type_out = CELL_CREATE; @@ -2579,3 +2582,24 @@ circuit_upgrade_circuits_from_guard_wait(void) smartlist_free(to_upgrade); } + +/** + * Try to generate a circuit-negotiation message for communication with a + * given relay. Assumes we are using ntor v3, or some later version that + * supports parameter negotiatoin. + * + * On success, return 0 and pass back a message in the `out` parameters. + * Otherwise, return -1. + **/ +int +client_circ_negotiation_message(const extend_info_t *ei, + uint8_t **msg_out, + size_t *msg_len_out) +{ + tor_assert(ei && msg_out && msg_len_out); + if (! ei->supports_ntor3_and_param_negotiation) + return -1; + + /* TODO: fill in the client message that gets sent. */ + tor_assert_unreached(); +} diff --git a/src/core/or/circuitbuild.h b/src/core/or/circuitbuild.h index 278cdfae1c..a66c611132 100644 --- a/src/core/or/circuitbuild.h +++ b/src/core/or/circuitbuild.h @@ -64,6 +64,10 @@ circuit_deliver_create_cell,(circuit_t *circ, const struct create_cell_t *create_cell, int relayed)); +int client_circ_negotiation_message(const extend_info_t *ei, + uint8_t **msg_out, + size_t *msg_len_out); + #ifdef CIRCUITBUILD_PRIVATE STATIC circid_t get_unique_circ_id_by_chan(channel_t *chan); STATIC int new_route_len(uint8_t purpose, extend_info_t *exit_ei, diff --git a/src/core/or/crypt_path_st.h b/src/core/or/crypt_path_st.h index ddc85eec14..fdc6b6fbb2 100644 --- a/src/core/or/crypt_path_st.h +++ b/src/core/or/crypt_path_st.h @@ -21,11 +21,14 @@ struct fast_handshake_state_t; struct ntor_handshake_state_t; struct crypto_dh_t; struct onion_handshake_state_t { + /** One of `ONION_HANDSHAKE_TYPE_*`. Determines which member of the union + * is accessible. */ uint16_t tag; union { struct fast_handshake_state_t *fast; struct crypto_dh_t *tap; struct ntor_handshake_state_t *ntor; + struct ntor3_handshake_state_t *ntor3; } u; }; diff --git a/src/core/or/extend_info_st.h b/src/core/or/extend_info_st.h index 868417f392..1666b168ad 100644 --- a/src/core/or/extend_info_st.h +++ b/src/core/or/extend_info_st.h @@ -38,6 +38,9 @@ struct extend_info_t { crypto_pk_t *onion_key; /** Ntor onion key for this hop. */ curve25519_public_key_t curve25519_onion_key; + /** True if this hop supports NtorV3 _and_ negotiation of at least one + * relevant circuit parameter (currently only congestion control). */ + bool supports_ntor3_and_param_negotiation; }; #endif /* !defined(EXTEND_INFO_ST_H) */ diff --git a/src/core/or/extendinfo.c b/src/core/or/extendinfo.c index 6bcef181be..f33e887e7d 100644 --- a/src/core/or/extendinfo.c +++ b/src/core/or/extendinfo.c @@ -56,6 +56,9 @@ extend_info_new(const char *nickname, if (addr) { extend_info_add_orport(info, addr, port); } + + info->supports_ntor3_and_param_negotiation = false; // TODO: set this. + return info; } @@ -210,6 +213,15 @@ extend_info_supports_ntor(const extend_info_t* ei) CURVE25519_PUBKEY_LEN); } +/** Return true if we can use the Ntor v3 handshake with `ei` */ +int +extend_info_supports_ntor_v3(const extend_info_t *ei) +{ + tor_assert(ei); + return extend_info_supports_ntor(ei) && + ei->supports_ntor3_and_param_negotiation; +} + /* Does ei have an onion key which it would prefer to use? * Currently, we prefer ntor keys*/ int diff --git a/src/core/or/extendinfo.h b/src/core/or/extendinfo.h index 9c07205709..ffe8317431 100644 --- a/src/core/or/extendinfo.h +++ b/src/core/or/extendinfo.h @@ -26,6 +26,7 @@ void extend_info_free_(extend_info_t *info); int extend_info_addr_is_allowed(const tor_addr_t *addr); int extend_info_supports_tap(const extend_info_t* ei); int extend_info_supports_ntor(const extend_info_t* ei); +int extend_info_supports_ntor_v3(const extend_info_t *ei); int extend_info_has_preferred_onion_key(const extend_info_t* ei); bool extend_info_has_orport(const extend_info_t *ei, const tor_addr_t *addr, uint16_t port); diff --git a/src/core/or/or.h b/src/core/or/or.h index 392a848ee7..3911797563 100644 --- a/src/core/or/or.h +++ b/src/core/or/or.h @@ -790,7 +790,8 @@ typedef enum { #define ONION_HANDSHAKE_TYPE_TAP 0x0000 #define ONION_HANDSHAKE_TYPE_FAST 0x0001 #define ONION_HANDSHAKE_TYPE_NTOR 0x0002 -#define MAX_ONION_HANDSHAKE_TYPE 0x0002 +#define ONION_HANDSHAKE_TYPE_NTOR_V3 0x0003 /* TODO: Add to spec */ +#define MAX_ONION_HANDSHAKE_TYPE 0x0003 typedef struct onion_handshake_state_t onion_handshake_state_t; typedef struct relay_crypto_t relay_crypto_t; diff --git a/src/feature/relay/relay_metrics.c b/src/feature/relay/relay_metrics.c index fc8eb10d1b..908cfdb0d9 100644 --- a/src/feature/relay/relay_metrics.c +++ b/src/feature/relay/relay_metrics.c @@ -104,6 +104,8 @@ handshake_type_to_str(const uint16_t type) return "fast"; case ONION_HANDSHAKE_TYPE_NTOR: return "ntor"; + case ONION_HANDSHAKE_TYPE_NTOR_V3: + return "ntor_v3"; default: // LCOV_EXCL_START tor_assert_unreached();

1 0

[tor/main] hs: Decode flow-control line
by dgoulet＠torproject.org 22 Feb '22

22 Feb '22

commit 89f5eeefb83231c6eb7b8a857b173a9f962f3c0d Author: David Goulet <dgoulet(a)torproject.org> Date: Thu Feb 3 20:06:36 2022 +0000 hs: Decode flow-control line This puts the flow control version (unparsed) in the descriptor. The client doesn't use it yet. Signed-off-by: David Goulet <dgoulet(a)torproject.org> --- src/feature/hs/hs_descriptor.c | 18 ++++++++++++++++++ src/feature/hs/hs_descriptor.h | 4 ++++ src/test/hs_test_helpers.c | 6 ++++++ src/test/test_protover.c | 25 +++++++++++++++++++++++-- 4 files changed, 51 insertions(+), 2 deletions(-) diff --git a/src/feature/hs/hs_descriptor.c b/src/feature/hs/hs_descriptor.c index 80273c27b1..523ededf8c 100644 --- a/src/feature/hs/hs_descriptor.c +++ b/src/feature/hs/hs_descriptor.c @@ -2347,6 +2347,23 @@ desc_decode_encrypted_v3(const hs_descriptor_t *desc, desc_encrypted_out->single_onion_service = 1; } + /* Get flow control if any. */ + tok = find_opt_by_keyword(tokens, R3_FLOW_CONTROL); + if (tok) { + int ok; + + tor_asprintf(&desc_encrypted_out->flow_control_pv, "FlowCtrl=%s", + tok->args[0]); + uint8_t sendme_inc = + (uint8_t) tor_parse_uint64(tok->args[1], 10, 0, UINT8_MAX, &ok, NULL); + if (!ok || !congestion_control_validate_sendme_increment(sendme_inc)) { + log_warn(LD_REND, "Service descriptor flow control sendme " + "value is invalid"); + goto err; + } + desc_encrypted_out->sendme_inc = sendme_inc; + } + /* Initialize the descriptor's introduction point list before we start * decoding. Having 0 intro point is valid. Then decode them all. */ desc_encrypted_out->intro_points = smartlist_new(); @@ -2757,6 +2774,7 @@ hs_desc_encrypted_data_free_contents(hs_desc_encrypted_data_t *desc) hs_desc_intro_point_free(ip)); smartlist_free(desc->intro_points); } + tor_free(desc->flow_control_pv); memwipe(desc, 0, sizeof(*desc)); } diff --git a/src/feature/hs/hs_descriptor.h b/src/feature/hs/hs_descriptor.h index d959431369..8f5ee6a2f1 100644 --- a/src/feature/hs/hs_descriptor.h +++ b/src/feature/hs/hs_descriptor.h @@ -167,6 +167,10 @@ typedef struct hs_desc_encrypted_data_t { /** Is this descriptor a single onion service? */ unsigned int single_onion_service : 1; + /** Flow control protocol version line. */ + char *flow_control_pv; + uint8_t sendme_inc; + /** A list of intro points. Contains hs_desc_intro_point_t objects. */ smartlist_t *intro_points; } hs_desc_encrypted_data_t; diff --git a/src/test/hs_test_helpers.c b/src/test/hs_test_helpers.c index 2af4f71d72..20b225ba4a 100644 --- a/src/test/hs_test_helpers.c +++ b/src/test/hs_test_helpers.c @@ -4,6 +4,7 @@ #define HS_CLIENT_PRIVATE #include "core/or/or.h" +#include "core/or/versions.h" #include "lib/crypt_ops/crypto_ed25519.h" #include "test/test.h" #include "feature/nodelist/torcert.h" @@ -186,6 +187,7 @@ hs_helper_build_hs_desc_impl(unsigned int no_ip, desc->encrypted_data.create2_ntor = 1; desc->encrypted_data.intro_auth_types = smartlist_new(); desc->encrypted_data.single_onion_service = 1; + desc->encrypted_data.flow_control_pv = tor_strdup("FlowCtrl=1-2"); smartlist_add(desc->encrypted_data.intro_auth_types, tor_strdup("ed25519")); desc->encrypted_data.intro_points = smartlist_new(); if (!no_ip) { @@ -332,6 +334,10 @@ hs_helper_desc_equal(const hs_descriptor_t *desc1, /* Encrypted data section. */ tt_uint_op(desc1->encrypted_data.create2_ntor, OP_EQ, desc2->encrypted_data.create2_ntor); + tt_uint_op(desc1->encrypted_data.single_onion_service, OP_EQ, + desc2->encrypted_data.single_onion_service); + tt_str_op(desc1->encrypted_data.flow_control_pv, OP_EQ, + desc2->encrypted_data.flow_control_pv); /* Authentication type. */ tt_int_op(!!desc1->encrypted_data.intro_auth_types, OP_EQ, diff --git a/src/test/test_protover.c b/src/test/test_protover.c index ae40556220..7ad02cb9c1 100644 --- a/src/test/test_protover.c +++ b/src/test/test_protover.c @@ -355,6 +355,9 @@ test_protover_supports_version(void *arg) #define PROTOVER_PADDING_V1 1 #define PROTOVER_FLOWCTRL_V1 1 +#define PROTOVER_FLOWCTRL_V2 2 + +#define PROTOVER_RELAY_NTOR_V3 4 /* Make sure we haven't forgotten any supported protocols */ static void @@ -644,7 +647,8 @@ test_protover_vote_roundtrip_ours(void *args) "supports_establish_intro_dos_extension: %d,\n" \ "supports_v3_hsdir: %d,\n" \ "supports_v3_rendezvous_point: %d,\n" \ - "supports_hs_setup_padding: %d.", \ + "supports_hs_setup_padding: %d,\n" \ + "supports_congestion_control: %d.", \ (flags).protocols_known, \ (flags).supports_extend2_cells, \ (flags).supports_accepting_ipv6_extends, \ @@ -656,7 +660,8 @@ test_protover_vote_roundtrip_ours(void *args) (flags).supports_establish_intro_dos_extension, \ (flags).supports_v3_hsdir, \ (flags).supports_v3_rendezvous_point, \ - (flags).supports_hs_setup_padding); \ + (flags).supports_hs_setup_padding, \ + (flags).supports_congestion_control); \ STMT_END /* Test that the proto_string version version_macro sets summary_flag. */ @@ -699,6 +704,22 @@ test_protover_summarize_flags(void *args) /* Now check version exceptions */ + /* Congestion control. */ + memset(&flags, 0, sizeof(flags)); + summarize_protover_flags(&flags, + PROTOVER("FlowCtrl", PROTOVER_FLOWCTRL_V2), + NULL); + summarize_protover_flags(&flags, + PROTOVER("Relay", PROTOVER_RELAY_NTOR_V3), + NULL); + DEBUG_PROTOVER(flags); + tt_int_op(flags.protocols_known, OP_EQ, 1); + tt_int_op(flags.supports_congestion_control, OP_EQ, 1); + /* Now clear those flags, and check the rest are zero */ + flags.protocols_known = 0; + flags.supports_congestion_control = 0; + tt_mem_op(&flags, OP_EQ, &zero_flags, sizeof(flags)); + /* EXTEND2 cell support */ memset(&flags, 0, sizeof(flags)); summarize_protover_flags(&flags, NULL, "Tor 0.2.4.8-alpha");

1 0

[tor/main] hs: Fix tests for congestion control
by dgoulet＠torproject.org 22 Feb '22

22 Feb '22

commit 27d948dab8f579890abdef155d20062938b84259 Author: David Goulet <dgoulet(a)torproject.org> Date: Thu Feb 3 12:11:42 2022 +0000 hs: Fix tests for congestion control --- src/test/test_hs_client.c | 4 ++++ src/test/test_hs_descriptor.c | 5 +++++ src/test/test_protover.c | 17 ----------------- 3 files changed, 9 insertions(+), 17 deletions(-) diff --git a/src/test/test_hs_client.c b/src/test/test_hs_client.c index 0fe71ed7bd..11a5589d21 100644 --- a/src/test/test_hs_client.c +++ b/src/test/test_hs_client.c @@ -54,6 +54,9 @@ #include "core/or/origin_circuit_st.h" #include "core/or/socks_request_st.h" +#define TOR_CONGESTION_CONTROL_PRIVATE +#include "core/or/congestion_control_common.h" + static int mock_connection_ap_handshake_send_begin(entry_connection_t *ap_conn) { @@ -771,6 +774,7 @@ test_desc_has_arrived_cleanup(void *arg) (void) arg; hs_init(); + congestion_control_set_cc_enabled(); MOCK(networkstatus_get_reasonably_live_consensus, mock_networkstatus_get_reasonably_live_consensus); diff --git a/src/test/test_hs_descriptor.c b/src/test/test_hs_descriptor.c index ec6c8ba6b4..ecb7da2450 100644 --- a/src/test/test_hs_descriptor.c +++ b/src/test/test_hs_descriptor.c @@ -24,6 +24,9 @@ #include "test/log_test_helpers.h" #include "test/rng_test_helpers.h" +#define TOR_CONGESTION_CONTROL_PRIVATE +#include "core/or/congestion_control_common.h" + #ifdef HAVE_CFLAG_WOVERLENGTH_STRINGS DISABLE_GCC_WARNING("-Woverlength-strings") /* We allow huge string constants in the unit tests, but not in the code @@ -247,6 +250,8 @@ test_decode_descriptor(void *arg) (void) arg; + congestion_control_set_cc_enabled(); + ret = ed25519_keypair_generate(&signing_kp, 0); tt_int_op(ret, OP_EQ, 0); desc = hs_helper_build_hs_desc_with_ip(&signing_kp); diff --git a/src/test/test_protover.c b/src/test/test_protover.c index 7ad02cb9c1..9d14fd678a 100644 --- a/src/test/test_protover.c +++ b/src/test/test_protover.c @@ -355,7 +355,6 @@ test_protover_supports_version(void *arg) #define PROTOVER_PADDING_V1 1 #define PROTOVER_FLOWCTRL_V1 1 -#define PROTOVER_FLOWCTRL_V2 2 #define PROTOVER_RELAY_NTOR_V3 4 @@ -704,22 +703,6 @@ test_protover_summarize_flags(void *args) /* Now check version exceptions */ - /* Congestion control. */ - memset(&flags, 0, sizeof(flags)); - summarize_protover_flags(&flags, - PROTOVER("FlowCtrl", PROTOVER_FLOWCTRL_V2), - NULL); - summarize_protover_flags(&flags, - PROTOVER("Relay", PROTOVER_RELAY_NTOR_V3), - NULL); - DEBUG_PROTOVER(flags); - tt_int_op(flags.protocols_known, OP_EQ, 1); - tt_int_op(flags.supports_congestion_control, OP_EQ, 1); - /* Now clear those flags, and check the rest are zero */ - flags.protocols_known = 0; - flags.supports_congestion_control = 0; - tt_mem_op(&flags, OP_EQ, &zero_flags, sizeof(flags)); - /* EXTEND2 cell support */ memset(&flags, 0, sizeof(flags)); summarize_protover_flags(&flags, NULL, "Tor 0.2.4.8-alpha");

1 0

[tor/main] hs: Decode and cache the INTRODUCE cell congestion control extension
by dgoulet＠torproject.org 22 Feb '22

22 Feb '22

commit 729dd14fdec9ece47142a5dc1434d32da109982e Author: David Goulet <dgoulet(a)torproject.org> Date: Thu Feb 3 22:44:25 2022 +0000 hs: Decode and cache the INTRODUCE cell congestion control extension Signed-off-by: David Goulet <dgoulet(a)torproject.org> --- src/feature/hs/hs_cell.c | 41 +++++++++++++++++++++++++++++++++++++++++ src/feature/hs/hs_cell.h | 4 ++++ 2 files changed, 45 insertions(+) diff --git a/src/feature/hs/hs_cell.c b/src/feature/hs/hs_cell.c index 4b961a6add..b7ab68f7c4 100644 --- a/src/feature/hs/hs_cell.c +++ b/src/feature/hs/hs_cell.c @@ -14,6 +14,7 @@ #include "feature/hs/hs_cell.h" #include "feature/hs/hs_ob.h" #include "core/crypto/hs_ntor.h" +#include "core/or/congestion_control_common.h" #include "core/or/origin_circuit_st.h" @@ -783,6 +784,31 @@ get_introduce2_keys_and_verify_mac(hs_cell_introduce2_data_t *data, return intro_keys_result; } +/** Parse the given INTRODUCE cell extension. Update the data object + * accordingly depending on the extension. */ +static void +parse_introduce_cell_extension(hs_cell_introduce2_data_t *data, + const trn_extension_field_t *field) +{ + trn_extension_field_cc_t *cc_field = NULL; + + tor_assert(data); + tor_assert(field); + + switch (trn_extension_field_get_field_type(field)) { + case TRUNNEL_EXT_TYPE_CC_FIELD_REQUEST: + /* CC requests, enable it. */ + data->cc_enabled = 1; + data->pv.protocols_known = 1; + data->pv.supports_congestion_control = data->cc_enabled; + break; + default: + break; + } + + trn_extension_field_cc_free(cc_field); +} + /** Parse the INTRODUCE2 cell using data which contains everything we need to * do so and contains the destination buffers of information we extract and * compute from the cell. Return 0 on success else a negative value. The @@ -911,6 +937,21 @@ hs_cell_parse_introduce2(hs_cell_introduce2_data_t *data, smartlist_add(data->link_specifiers, lspec_dup); } + /* Extract any extensions. */ + const trn_extension_t *extensions = + trn_cell_introduce_encrypted_get_extensions(enc_cell); + if (extensions != NULL) { + for (size_t idx = 0; idx < trn_extension_get_num(extensions); idx++) { + const trn_extension_field_t *field = + trn_extension_getconst_fields(extensions, idx); + if (BUG(field == NULL)) { + /* The number of extensions should match the number of fields. */ + break; + } + parse_introduce_cell_extension(data, field); + } + } + /* Success. */ ret = 0; log_info(LD_REND, "Valid INTRODUCE2 cell. Launching rendezvous circuit."); diff --git a/src/feature/hs/hs_cell.h b/src/feature/hs/hs_cell.h index 43be038a93..c76a0690a8 100644 --- a/src/feature/hs/hs_cell.h +++ b/src/feature/hs/hs_cell.h @@ -84,6 +84,10 @@ typedef struct hs_cell_introduce2_data_t { smartlist_t *link_specifiers; /** Replay cache of the introduction point. */ replaycache_t *replay_cache; + /** Flow control negotiation parameters. */ + protover_summary_flags_t pv; + /** Congestion control parameters. */ + unsigned int cc_enabled : 1; } hs_cell_introduce2_data_t; /* Build cell API. */

1 0

[tor/main] hs: Build INTRODUCE extension in the encrypted section
by dgoulet＠torproject.org 22 Feb '22

22 Feb '22

commit 38e9d9b465f5ae825d054b7baf06a851ad6b371a Author: David Goulet <dgoulet(a)torproject.org> Date: Thu Feb 3 21:06:28 2022 +0000 hs: Build INTRODUCE extension in the encrypted section Signed-off-by: David Goulet <dgoulet(a)torproject.org> --- src/feature/hs/hs_cell.c | 28 ++++++++++++++++++++++++++-- src/feature/hs/hs_cell.h | 2 ++ src/feature/hs/hs_circuit.c | 8 ++++++++ 3 files changed, 36 insertions(+), 2 deletions(-) diff --git a/src/feature/hs/hs_cell.c b/src/feature/hs/hs_cell.c index 116395b3c8..4b961a6add 100644 --- a/src/feature/hs/hs_cell.c +++ b/src/feature/hs/hs_cell.c @@ -18,6 +18,7 @@ #include "core/or/origin_circuit_st.h" /* Trunnel. */ +#include "trunnel/congestion_control.h" #include "trunnel/ed25519_cert.h" #include "trunnel/extension.h" #include "trunnel/hs/cell_establish_intro.h" @@ -372,6 +373,26 @@ introduce1_encrypt_and_encode(trn_cell_introduce1_t *cell, tor_free(encrypted); } +/** Build and set the INTRODUCE congestion control extension in the given + * extensions. */ +static void +build_introduce_cc_extension(trn_extension_t *extensions) +{ + trn_extension_field_t *field = NULL; + + /* Build CC request extension. */ + field = trn_extension_field_new(); + trn_extension_field_set_field_type(field, + TRUNNEL_EXT_TYPE_CC_FIELD_REQUEST); + + /* No payload indicating a request to use congestion control. */ + trn_extension_field_set_field_len(field, 0); + + /* Build final extension. */ + trn_extension_add_fields(extensions, field); + trn_extension_set_num(extensions, trn_extension_get_num(extensions) + 1); +} + /** Using the INTRODUCE1 data, setup the ENCRYPTED section in cell. This means * set it, encrypt it and encode it. */ static void @@ -387,10 +408,13 @@ introduce1_set_encrypted(trn_cell_introduce1_t *cell, enc_cell = trn_cell_introduce_encrypted_new(); tor_assert(enc_cell); - /* Set extension data. None are used. */ + /* Setup extension(s) if any. */ ext = trn_extension_new(); tor_assert(ext); - trn_extension_set_num(ext, 0); + /* Build congestion control extension is enabled. */ + if (data->cc_enabled) { + build_introduce_cc_extension(ext); + } trn_cell_introduce_encrypted_set_extensions(enc_cell, ext); /* Set the rendezvous cookie. */ diff --git a/src/feature/hs/hs_cell.h b/src/feature/hs/hs_cell.h index c25fd45567..43be038a93 100644 --- a/src/feature/hs/hs_cell.h +++ b/src/feature/hs/hs_cell.h @@ -40,6 +40,8 @@ typedef struct hs_cell_introduce1_data_t { const curve25519_keypair_t *client_kp; /** Rendezvous point link specifiers. */ smartlist_t *link_specifiers; + /** Congestion control parameters. */ + unsigned int cc_enabled : 1; } hs_cell_introduce1_data_t; /** This data structure contains data that we need to parse an INTRODUCE2 cell diff --git a/src/feature/hs/hs_circuit.c b/src/feature/hs/hs_circuit.c index 3347bdca07..10a6f51eb3 100644 --- a/src/feature/hs/hs_circuit.c +++ b/src/feature/hs/hs_circuit.c @@ -37,6 +37,7 @@ #include "trunnel/ed25519_cert.h" #include "trunnel/hs/cell_establish_intro.h" +#include "core/or/congestion_control_st.h" #include "core/or/cpath_build_state_st.h" #include "core/or/crypt_path_st.h" #include "feature/nodelist/node_st.h" @@ -549,6 +550,7 @@ setup_introduce1_data(const hs_desc_intro_point_t *ip, /* We can't rendezvous without the curve25519 onion key. */ goto end; } + /* Success, we have valid introduce data. */ ret = 0; @@ -1072,6 +1074,12 @@ hs_circ_send_introduce1(origin_circuit_t *intro_circ, goto close; } + /* If the rend circ was set up for congestion control, add that to the + * intro data, to signal it in an extension */ + if (TO_CIRCUIT(rend_circ)->ccontrol) { + intro1_data.cc_enabled = 1; + } + /* Final step before we encode a cell, we setup the circuit identifier which * will generate both the rendezvous cookie and client keypair for this * connection. Those are put in the ident. */

1 0

[tor/main] hs: Encode flow control value in the descriptor
by dgoulet＠torproject.org 22 Feb '22

22 Feb '22

commit 95639f35aede81bfde8bd4ee1616e10048176cc7 Author: David Goulet <dgoulet(a)torproject.org> Date: Thu Nov 4 10:26:04 2021 -0400 hs: Encode flow control value in the descriptor This simply adds the "flow-control" line, as detailed in prop324, to the descriptor. No decoding is done at this commit. Part of #40506 --- src/feature/dirparse/parsecommon.h | 1 + src/feature/hs/hs_descriptor.c | 12 ++++++++++++ 2 files changed, 13 insertions(+) diff --git a/src/feature/dirparse/parsecommon.h b/src/feature/dirparse/parsecommon.h index 0f343e9c62..675c5f68d5 100644 --- a/src/feature/dirparse/parsecommon.h +++ b/src/feature/dirparse/parsecommon.h @@ -172,6 +172,7 @@ typedef enum { R3_DESC_AUTH_KEY, R3_DESC_AUTH_CLIENT, R3_ENCRYPTED, + R3_FLOW_CONTROL, R_IPO_IDENTIFIER, R_IPO_IP_ADDRESS, diff --git a/src/feature/hs/hs_descriptor.c b/src/feature/hs/hs_descriptor.c index a37eab5b5d..80273c27b1 100644 --- a/src/feature/hs/hs_descriptor.c +++ b/src/feature/hs/hs_descriptor.c @@ -61,6 +61,8 @@ #include "trunnel/ed25519_cert.h" /* Trunnel interface. */ #include "feature/hs/hs_descriptor.h" #include "core/or/circuitbuild.h" +#include "core/or/congestion_control_common.h" +#include "core/or/protover.h" #include "lib/crypt_ops/crypto_rand.h" #include "lib/crypt_ops/crypto_util.h" #include "feature/dirparse/parsecommon.h" @@ -69,6 +71,7 @@ #include "feature/nodelist/torcert.h" /* tor_cert_encode_ed22519() */ #include "lib/memarea/memarea.h" #include "lib/crypt_ops/crypto_format.h" +#include "core/or/versions.h" #include "core/or/extend_info_st.h" @@ -92,6 +95,7 @@ #define str_ip_legacy_key "legacy-key" #define str_ip_legacy_key_cert "legacy-key-cert" #define str_intro_point_start "\n" str_intro_point " " +#define str_flow_control "flow-control" /* Constant string value for the construction to encrypt the encrypted data * section. */ #define str_enc_const_superencryption "hsdir-superencrypted-data" @@ -138,6 +142,7 @@ static token_rule_t hs_desc_encrypted_v3_token_table[] = { T1_START(str_create2_formats, R3_CREATE2_FORMATS, CONCAT_ARGS, NO_OBJ), T01(str_intro_auth_required, R3_INTRO_AUTH_REQUIRED, GE(1), NO_OBJ), T01(str_single_onion, R3_SINGLE_ONION_SERVICE, ARGS, NO_OBJ), + T01(str_flow_control, R3_FLOW_CONTROL, GE(2), NO_OBJ), END_OF_TABLE }; @@ -765,6 +770,13 @@ get_inner_encrypted_layer_plaintext(const hs_descriptor_t *desc) if (desc->encrypted_data.single_onion_service) { smartlist_add_asprintf(lines, "%s\n", str_single_onion); } + + if (congestion_control_enabled()) { + /* Add flow control line into the descriptor. */ + smartlist_add_asprintf(lines, "%s %s %u\n", str_flow_control, + protover_get_supported(PRT_FLOWCTRL), + congestion_control_sendme_inc()); + } } /* Build the introduction point(s) section. */

1 0

[tor/main] Use path type hint for Vegas queue parameters.
by dgoulet＠torproject.org 22 Feb '22

22 Feb '22

commit b2553bfba28b2e26f09041a3d78fa39c35fd4ac8 Author: Mike Perry <mikeperry-git(a)torproject.org> Date: Thu Feb 3 12:01:23 2022 +0000 Use path type hint for Vegas queue parameters. These parameters will vary depending on path length, especially for onions. --- src/app/config/config.c | 1 + src/app/config/or_options_st.h | 3 + src/core/mainloop/cpuworker.c | 8 ++- src/core/or/circuitbuild.c | 16 +++++- src/core/or/congestion_control_common.c | 14 +++-- src/core/or/congestion_control_common.h | 18 +++++- src/core/or/congestion_control_vegas.c | 97 ++++++++++++++++++++++++++++----- src/core/or/congestion_control_vegas.h | 3 +- src/feature/hs/hs_circuit.c | 26 ++++++++- src/feature/hs/hs_client.c | 14 ++++- 10 files changed, 174 insertions(+), 26 deletions(-) diff --git a/src/app/config/config.c b/src/app/config/config.c index 05bd96fc6a..15addd5be4 100644 --- a/src/app/config/config.c +++ b/src/app/config/config.c @@ -676,6 +676,7 @@ static const config_var_t option_vars_[] = { V(UseMicrodescriptors, AUTOBOOL, "auto"), OBSOLETE("UseNTorHandshake"), VAR("__AlwaysCongestionControl", BOOL, AlwaysCongestionControl, "0"), + VAR("__SbwsExit", BOOL, SbwsExit, "0"), V_IMMUTABLE(User, STRING, NULL), OBSOLETE("UserspaceIOCPBuffers"), OBSOLETE("V1AuthoritativeDirectory"), diff --git a/src/app/config/or_options_st.h b/src/app/config/or_options_st.h index a1ef7a8cf8..290a2bb9b4 100644 --- a/src/app/config/or_options_st.h +++ b/src/app/config/or_options_st.h @@ -604,6 +604,9 @@ struct or_options_t { /** Boolean: Switch to override consensus to enable congestion control */ int AlwaysCongestionControl; + /** Boolean: Switch to specify this is an sbws measurement exit */ + int SbwsExit; + int RephistTrackTime; /**< How many seconds do we keep rephist info? */ /** Should we always fetch our dir info on the mirror schedule (which * means directly from the authorities) no matter our other config? */ diff --git a/src/core/mainloop/cpuworker.c b/src/core/mainloop/cpuworker.c index 2cb667615d..ab970259b5 100644 --- a/src/core/mainloop/cpuworker.c +++ b/src/core/mainloop/cpuworker.c @@ -391,7 +391,13 @@ cpuworker_onion_handshake_replyfn(void *work_) /* If the client asked for congestion control, if our consensus parameter * allowed it to negotiate as enabled, allocate a congestion control obj. */ if (rpl.circ_params.cc_enabled) { - TO_CIRCUIT(circ)->ccontrol = congestion_control_new(&rpl.circ_params); + if (get_options()->SbwsExit) { + TO_CIRCUIT(circ)->ccontrol = congestion_control_new(&rpl.circ_params, + CC_PATH_SBWS); + } else { + TO_CIRCUIT(circ)->ccontrol = congestion_control_new(&rpl.circ_params, + CC_PATH_EXIT); + } } if (onionskin_answer(circ, diff --git a/src/core/or/circuitbuild.c b/src/core/or/circuitbuild.c index 2326dc2a6d..f62a1d93f5 100644 --- a/src/core/or/circuitbuild.c +++ b/src/core/or/circuitbuild.c @@ -1275,7 +1275,21 @@ circuit_finish_handshake(origin_circuit_t *circ, } if (params.cc_enabled) { - hop->ccontrol = congestion_control_new(&params); + int circ_len = circuit_get_cpath_len(circ); + + if (circ_len == DEFAULT_ROUTE_LEN && + circuit_get_cpath_hop(circ, DEFAULT_ROUTE_LEN) == hop) { + hop->ccontrol = congestion_control_new(&params, CC_PATH_EXIT); + } else if (circ_len == SBWS_ROUTE_LEN && + circuit_get_cpath_hop(circ, SBWS_ROUTE_LEN) == hop) { + hop->ccontrol = congestion_control_new(&params, CC_PATH_SBWS); + } else { + static ratelim_t cc_path_limit = RATELIM_INIT(600); + log_fn_ratelim(&cc_path_limit, LOG_WARN, LD_CIRC, + "Unexpected path length %d for circuit", + circ_len); + hop->ccontrol = congestion_control_new(&params, CC_PATH_EXIT); + } } hop->state = CPATH_STATE_OPEN; diff --git a/src/core/or/congestion_control_common.c b/src/core/or/congestion_control_common.c index 09c6c04bf3..e316b631d1 100644 --- a/src/core/or/congestion_control_common.c +++ b/src/core/or/congestion_control_common.c @@ -168,7 +168,8 @@ congestion_control_new_consensus_params(const networkstatus_t *ns) */ static void congestion_control_init_params(congestion_control_t *cc, - const circuit_params_t *params) + const circuit_params_t *params, + cc_path_t path) { const or_options_t *opts = get_options(); cc->sendme_inc = params->sendme_inc_cells; @@ -266,7 +267,7 @@ congestion_control_init_params(congestion_control_t *cc, if (cc->cc_alg == CC_ALG_WESTWOOD) { congestion_control_westwood_set_params(cc); } else if (cc->cc_alg == CC_ALG_VEGAS) { - congestion_control_vegas_set_params(cc); + congestion_control_vegas_set_params(cc, path); } else if (cc->cc_alg == CC_ALG_NOLA) { congestion_control_nola_set_params(cc); } @@ -326,24 +327,25 @@ congestion_control_set_cc_enabled(void) */ static void congestion_control_init(congestion_control_t *cc, - const circuit_params_t *params) + const circuit_params_t *params, + cc_path_t path) { cc->sendme_pending_timestamps = smartlist_new(); cc->sendme_arrival_timestamps = smartlist_new(); cc->in_slow_start = 1; - congestion_control_init_params(cc, params); + congestion_control_init_params(cc, params, path); cc->next_cc_event = CWND_UPDATE_RATE(cc); } /** Allocate and initialize a new congestion control object */ congestion_control_t * -congestion_control_new(const circuit_params_t *params) +congestion_control_new(const circuit_params_t *params, cc_path_t path) { congestion_control_t *cc = tor_malloc_zero(sizeof(congestion_control_t)); - congestion_control_init(cc, params); + congestion_control_init(cc, params, path); return cc; } diff --git a/src/core/or/congestion_control_common.h b/src/core/or/congestion_control_common.h index 1e5a00c942..1a57d71331 100644 --- a/src/core/or/congestion_control_common.h +++ b/src/core/or/congestion_control_common.h @@ -19,6 +19,21 @@ typedef struct congestion_control_t congestion_control_t; +/** + * Specifies the path type to help choose congestion control + * parameters. Since these paths are different lengths, they + * will need different queue parameters. */ +typedef enum { + CC_PATH_EXIT = 0, + CC_PATH_ONION = 1, + CC_PATH_ONION_SOS = 2, + CC_PATH_ONION_VG = 3, + CC_PATH_SBWS = 4, +} cc_path_t; + +/** The length of a path for sbws measurement */ +#define SBWS_ROUTE_LEN 2 + /** Wrapper for the free function, set the CC pointer to NULL after free */ #define congestion_control_free(cc) \ FREE_AND_NULL(congestion_control_t, congestion_control_free_, cc) @@ -27,7 +42,8 @@ void congestion_control_free_(congestion_control_t *cc); struct circuit_params_t; congestion_control_t *congestion_control_new( - const struct circuit_params_t *params); + const struct circuit_params_t *params, + cc_path_t path); int congestion_control_dispatch_cc_alg(congestion_control_t *cc, const circuit_t *circ, diff --git a/src/core/or/congestion_control_vegas.c b/src/core/or/congestion_control_vegas.c index 8e13499aff..e7ed838478 100644 --- a/src/core/or/congestion_control_vegas.c +++ b/src/core/or/congestion_control_vegas.c @@ -25,9 +25,31 @@ #define OUTBUF_CELLS (2*TLS_RECORD_MAX_CELLS) -#define VEGAS_ALPHA(cc) (3*OUTBUF_CELLS-TLS_RECORD_MAX_CELLS) -#define VEGAS_BETA(cc) (3*OUTBUF_CELLS) -#define VEGAS_GAMMA(cc) (3*OUTBUF_CELLS) +/* sbws circs are two hops, so params are based on 2 outbufs of cells */ +#define VEGAS_ALPHA_SBWS_DFLT (2*OUTBUF_CELLS-TLS_RECORD_MAX_CELLS) +#define VEGAS_BETA_SBWS_DFLT (2*OUTBUF_CELLS) +#define VEGAS_GAMMA_SBWS_DFLT (2*OUTBUF_CELLS) + +/* Exits are three hops, so params are based on 3 outbufs of cells */ +#define VEGAS_ALPHA_EXIT_DFLT (3*OUTBUF_CELLS-TLS_RECORD_MAX_CELLS) +#define VEGAS_BETA_EXIT_DFLT (3*OUTBUF_CELLS) +#define VEGAS_GAMMA_EXIT_DFLT (3*OUTBUF_CELLS) + +/* Onion rends are six hops, so params are based on 6 outbufs of cells */ +#define VEGAS_ALPHA_ONION_DFLT (6*OUTBUF_CELLS-TLS_RECORD_MAX_CELLS) +#define VEGAS_BETA_ONION_DFLT (6*OUTBUF_CELLS) +#define VEGAS_GAMMA_ONION_DFLT (6*OUTBUF_CELLS) + +/* Single Onions are three hops, so params are based on 3 outbufs of cells */ +#define VEGAS_ALPHA_SOS_DFLT (3*OUTBUF_CELLS-TLS_RECORD_MAX_CELLS) +#define VEGAS_BETA_SOS_DFLT (3*OUTBUF_CELLS) +#define VEGAS_GAMMA_SOS_DFLT (3*OUTBUF_CELLS) + +/* Vanguard Onions are 7 hops (or 8 if both sides use vanguards, but that + * should be rare), so params are based on 7 outbufs of cells */ +#define VEGAS_ALPHA_VG_DFLT (7*OUTBUF_CELLS-TLS_RECORD_MAX_CELLS) +#define VEGAS_BETA_VG_DFLT (7*OUTBUF_CELLS) +#define VEGAS_GAMMA_VG_DFLT (7*OUTBUF_CELLS) #define VEGAS_BDP_MIX_PCT 100 @@ -54,25 +76,74 @@ vegas_bdp_mix(const congestion_control_t *cc) * Cache Vegas consensus parameters. */ void -congestion_control_vegas_set_params(congestion_control_t *cc) +congestion_control_vegas_set_params(congestion_control_t *cc, + cc_path_t path) { tor_assert(cc->cc_alg == CC_ALG_VEGAS); + const char *alpha_str = NULL, *beta_str = NULL, *gamma_str = NULL; + int alpha, beta, gamma; - cc->vegas_params.gamma = - networkstatus_get_param(NULL, "cc_vegas_gamma", - VEGAS_GAMMA(cc), - 0, - 1000); + switch (path) { + case CC_PATH_SBWS: + alpha_str = "cc_vegas_alpha_sbws"; + beta_str = "cc_vegas_beta_sbws"; + gamma_str = "cc_vegas_gamma_sbws"; + alpha = VEGAS_ALPHA_SBWS_DFLT; + beta = VEGAS_BETA_SBWS_DFLT; + gamma = VEGAS_GAMMA_SBWS_DFLT; + break; + case CC_PATH_EXIT: + alpha_str = "cc_vegas_alpha_exit"; + beta_str = "cc_vegas_beta_exit"; + gamma_str = "cc_vegas_gamma_exit"; + alpha = VEGAS_ALPHA_EXIT_DFLT; + beta = VEGAS_BETA_EXIT_DFLT; + gamma = VEGAS_GAMMA_EXIT_DFLT; + break; + case CC_PATH_ONION: + alpha_str = "cc_vegas_alpha_onion"; + beta_str = "cc_vegas_beta_onion"; + gamma_str = "cc_vegas_gamma_onion"; + alpha = VEGAS_ALPHA_ONION_DFLT; + beta = VEGAS_BETA_ONION_DFLT; + gamma = VEGAS_GAMMA_ONION_DFLT; + break; + case CC_PATH_ONION_SOS: + alpha_str = "cc_vegas_alpha_sos"; + beta_str = "cc_vegas_beta_sos"; + gamma_str = "cc_vegas_gamma_sos"; + alpha = VEGAS_ALPHA_SOS_DFLT; + beta = VEGAS_BETA_SOS_DFLT; + gamma = VEGAS_GAMMA_SOS_DFLT; + break; + case CC_PATH_ONION_VG: + alpha_str = "cc_vegas_alpha_vg"; + beta_str = "cc_vegas_beta_vg"; + gamma_str = "cc_vegas_gamma_vg"; + alpha = VEGAS_ALPHA_VG_DFLT; + beta = VEGAS_BETA_VG_DFLT; + gamma = VEGAS_GAMMA_VG_DFLT; + break; + default: + tor_assert(0); + break; + } cc->vegas_params.alpha = - networkstatus_get_param(NULL, "cc_vegas_alpha", - VEGAS_ALPHA(cc), + networkstatus_get_param(NULL, alpha_str, + alpha, 0, 1000); cc->vegas_params.beta = - networkstatus_get_param(NULL, "cc_vegas_beta", - VEGAS_BETA(cc), + networkstatus_get_param(NULL, beta_str, + beta, + 0, + 1000); + + cc->vegas_params.gamma = + networkstatus_get_param(NULL, gamma_str, + gamma, 0, 1000); diff --git a/src/core/or/congestion_control_vegas.h b/src/core/or/congestion_control_vegas.h index 111345081c..95fcea5722 100644 --- a/src/core/or/congestion_control_vegas.h +++ b/src/core/or/congestion_control_vegas.h @@ -16,7 +16,8 @@ int congestion_control_vegas_process_sendme(struct congestion_control_t *cc, const circuit_t *circ, const crypt_path_t *layer_hint); -void congestion_control_vegas_set_params(struct congestion_control_t *cc); +void congestion_control_vegas_set_params(struct congestion_control_t *cc, + cc_path_t path); /* Private section starts. */ #ifdef TOR_CONGESTION_CONTROL_VEGAS_PRIVATE diff --git a/src/feature/hs/hs_circuit.c b/src/feature/hs/hs_circuit.c index f2953cfb02..271bf652e7 100644 --- a/src/feature/hs/hs_circuit.c +++ b/src/feature/hs/hs_circuit.c @@ -415,7 +415,20 @@ launch_rendezvous_point_circuit,(const hs_service_t *service, .cc_enabled = data->cc_enabled, .sendme_inc_cells = congestion_control_sendme_inc(), }; - TO_CIRCUIT(circ)->ccontrol = congestion_control_new(&circ_params); + + /* Initialize ccontrol for appropriate path type */ + if (service->config.is_single_onion) { + TO_CIRCUIT(circ)->ccontrol = congestion_control_new(&circ_params, + CC_PATH_ONION_SOS); + } else { + if (get_options()->HSLayer3Nodes) { + TO_CIRCUIT(circ)->ccontrol = congestion_control_new(&circ_params, + CC_PATH_ONION_VG); + } else { + TO_CIRCUIT(circ)->ccontrol = congestion_control_new(&circ_params, + CC_PATH_ONION); + } + } } end: @@ -519,7 +532,16 @@ retry_service_rendezvous_point(const origin_circuit_t *circ) .cc_enabled = 1, .sendme_inc_cells = TO_CIRCUIT(circ)->ccontrol->sendme_inc, }; - TO_CIRCUIT(new_circ)->ccontrol = congestion_control_new(&circ_params); + + /* As per above, in this case, we are a full 3 hop rend, even if we're a + * single-onion service */ + if (get_options()->HSLayer3Nodes) { + TO_CIRCUIT(new_circ)->ccontrol = congestion_control_new(&circ_params, + CC_PATH_ONION_VG); + } else { + TO_CIRCUIT(new_circ)->ccontrol = congestion_control_new(&circ_params, + CC_PATH_ONION_SOS); + } } done: diff --git a/src/feature/hs/hs_client.c b/src/feature/hs/hs_client.c index 69b071e197..81c0459a86 100644 --- a/src/feature/hs/hs_client.c +++ b/src/feature/hs/hs_client.c @@ -788,7 +788,19 @@ setup_rendezvous_circ_congestion_control(origin_circuit_t *circ) circ_params.cc_enabled = congestion_control_enabled(); if (circ_params.cc_enabled) { circ_params.sendme_inc_cells = desc->encrypted_data.sendme_inc; - TO_CIRCUIT(circ)->ccontrol = congestion_control_new(&circ_params); + + if (desc->encrypted_data.single_onion_service) { + TO_CIRCUIT(circ)->ccontrol = congestion_control_new(&circ_params, + CC_PATH_ONION_SOS); + } else { + if (get_options()->HSLayer3Nodes) { + TO_CIRCUIT(circ)->ccontrol = congestion_control_new(&circ_params, + CC_PATH_ONION_VG); + } else { + TO_CIRCUIT(circ)->ccontrol = congestion_control_new(&circ_params, + CC_PATH_ONION); + } + } } }

1 0

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

tor-commits February 2022