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

[tor-commits] [sbws/master] Measure exits in the exit position; try harder to find a helper



commit 2fc8f53329caf2406870007e53110060ad3a73f1
Author: Matt Traudt <sirmatt@xxxxxxx>
Date:   Tue Jun 12 21:18:13 2018 -0400

    Measure exits in the exit position; try harder to find a helper
---
 CHANGELOG.md          | 13 ++++++++++
 sbws/core/scanner.py  | 67 ++++++++++++++++++++++++++++++++++++++++-----------
 sbws/lib/relaylist.py | 20 +++++++++++++++
 3 files changed, 86 insertions(+), 14 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3097ce2..918421a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,19 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ## [Unreleased]
 
+### Changed
+
+- If the relay to measure is an exit, put it in the exit position and choose a
+  non-exit to help. Previously the relay to measure would always be the first
+hop. (GH#181)
+- Try harder to find a relay to help measure the target relay with two changes.
+  Essentially: (1) Instead of only picking from relays that are 1.25 - 2.00
+times faster than it by consensus weight, try (in order) to find a relay that
+is at least 2.00, 1.75, 1.50, 1.25, or 1.00 times as fast. If that fails,
+instead of giving up, (2) pick the fastest relay in the network instead of
+giving up. This compliments the previous change about measuring target exits in
+the exit position.
+
 ### Fixed
 
 - Exception that causes sbws to fall back to one measurement thread. We first
diff --git a/sbws/core/scanner.py b/sbws/core/scanner.py
index 8e9f9c4..6af1b0c 100644
--- a/sbws/core/scanner.py
+++ b/sbws/core/scanner.py
@@ -131,6 +131,40 @@ def measure_bandwidth_to_server(session, conf, dest, content_length):
     return results
 
 
+def _pick_ideal_second_hop(relay, dest, rl, cont, is_exit):
+    '''
+    Sbws builds two hop circuits. Given the **relay** to measure with
+    destination **dest**, pick a second relay that is or is not an exit
+    according to **is_exit**.
+    '''
+    candidates = []
+    candidates.extend(rl.exits if is_exit else rl.non_exits)
+    if not len(candidates):
+        return None
+    log.debug('Picking a 2nd hop to measure %s from %d choices. is_exit=%s',
+              relay.nickname, len(candidates), is_exit)
+    for min_bw_factor in [2, 1.75, 1.5, 1.25, 1]:
+        min_bw = relay.bandwidth * min_bw_factor
+        new_candidates = stem_utils.only_relays_with_bandwidth(
+            cont, candidates, min_bw=min_bw)
+        if len(new_candidates) > 0:
+            chosen = rng.choice(new_candidates)
+            log.debug(
+                'Found %d candidate 2nd hops with at least %sx the bandwidth '
+                'of %s. Returning %s (bw=%s).',
+                len(new_candidates), min_bw_factor, relay.nickname,
+                chosen.nickname, chosen.bandwidth)
+            return chosen
+    candidates = sorted(candidates, key=lambda r: r.bandwidth, reverse=True)
+    chosen = candidates[0]
+    log.debug(
+        'Didn\'t find any 2nd hops at least as fast as %s (bw=%s). It\'s '
+        'probably really fast. Returning %s (bw=%s), the fastest '
+        'candidate we have.', relay.nickname, relay.bandwidth,
+        chosen.nickname, chosen.bandwidth)
+    return chosen
+
+
 def measure_relay(args, conf, destinations, cb, rl, relay):
     s = requests_utils.make_session(
         cb.controller, conf.getfloat('general', 'http_timeout'))
@@ -140,24 +174,29 @@ def measure_relay(args, conf, destinations, cb, rl, relay):
         log.warning('Unable to get destination to measure %s %s',
                     relay.nickname, relay.fingerprint[0:8])
         return None
-    # Pick an exit
-    exits = rl.exits_can_exit_to(dest.hostname, dest.port)
-    exits = [e for e in exits if e.fingerprint != relay.fingerprint]
-    exits = stem_utils.only_relays_with_bandwidth(
-        cb.controller, exits, min_bw=round(relay.bandwidth*1.25),
-        max_bw=max(round(relay.bandwidth*2.00), 100))
-    if len(exits) < 1:
-        log.warning('No available exits to help measure %s %s', relay.nickname,
-                    relay.fingerprint[0:8])
+    # Pick a relay to help us measure the given relay. If the given relay is an
+    # exit, then pick a non-exit. Otherwise pick an exit.
+    helper = None
+    circ_fps = None
+    if relay.can_exit_to(dest.hostname, dest.port):
+        helper = _pick_ideal_second_hop(
+            relay, dest, rl, cb.controller, is_exit=False)
+        if helper:
+            circ_fps = [helper.fingerprint, relay.fingerprint]
+    else:
+        helper = _pick_ideal_second_hop(
+            relay, dest, rl, cb.controller, is_exit=True)
+        if helper:
+            circ_fps = [relay.fingerprint, helper.fingerprint]
+    if not helper:
         # TODO: Return ResultError of some sort
+        log.warning('Unable to pick a 2nd hop to help measure %s %s',
+                    relay.nickname, relay.fingerprint[0:8])
         return None
-    exit = rng.choice(exits)
+    assert helper
+    assert circ_fps is not None and len(circ_fps) == 2
     # Build the circuit
-    log.debug('We selected exit %s %s (cw=%d) to help measure %s %s (cw=%d)',
-              exit.nickname, exit.fingerprint[0:8], exit.bandwidth,
-              relay.nickname, relay.fingerprint[0:8], relay.bandwidth)
     our_nick = conf['scanner']['nickname']
-    circ_fps = [relay.fingerprint, exit.fingerprint]
     circ_id = cb.build_circuit(circ_fps)
     if not circ_id:
         log.warning('Could not build circuit involving %s', relay.nickname)
diff --git a/sbws/lib/relaylist.py b/sbws/lib/relaylist.py
index 7b3d58a..2cc5fef 100644
--- a/sbws/lib/relaylist.py
+++ b/sbws/lib/relaylist.py
@@ -88,6 +88,22 @@ class Relay:
         # it seems that stem parses it as ed25519_master_key
         return self._from_desc('ed25519_master_key').rstrip('=')
 
+    def can_exit_to(self, host, port):
+        if not self.exit_policy:
+            return False
+        assert isinstance(host, str)
+        assert isinstance(port, int)
+        if not is_valid_ipv4_address(host) and not is_valid_ipv6_address(host):
+            # It certainly isn't perfect trying to guess if an exit can connect
+            # to an ipv4/6 address based on the DNS result we got locally. But
+            # it's the best we can do.
+            #
+            # Also, only use the first ipv4/6 we get even if there is more than
+            # one.
+            host = resolve(host)[0]
+        assert is_valid_ipv4_address(host) or is_valid_ipv6_address(host)
+        return self.exit_policy.can_exit_to(host, port)
+
 
 class RelayList:
     ''' Keeps a list of all relays in the current Tor network and updates it
@@ -116,6 +132,10 @@ class RelayList:
         return self._relays_with_flag(Flag.EXIT)
 
     @property
+    def non_exits(self):
+        return self._relays_without_flag(Flag.EXIT)
+
+    @property
     def guards(self):
         return self._relays_with_flag(Flag.GUARD)
 



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