September 2015 - tor-commits - lists.torproject.org

[nyx/master] Merging ConnectionEntry into parent class
by atagar＠torproject.org 22 Sep '15

22 Sep '15

commit 3d48452bf48d7e125aecb127e85f10e0ca6dae90 Author: Damian Johnson <atagar(a)torproject.org> Date: Sat Jul 25 18:11:52 2015 -0700 Merging ConnectionEntry into parent class What a mess. The ConnectionEntry was the sole subclass of the parent. I see what I was intending to do with the separation, but... seriously? *sigh* --- nyx/connections/conn_entry.py | 52 -------------------------------- nyx/connections/conn_panel.py | 2 +- nyx/connections/entries.py | 67 +++++++++++++++++++++++++++++------------ 3 files changed, 48 insertions(+), 73 deletions(-) diff --git a/nyx/connections/conn_entry.py b/nyx/connections/conn_entry.py index 7693982..ec1779e 100644 --- a/nyx/connections/conn_entry.py +++ b/nyx/connections/conn_entry.py @@ -42,10 +42,6 @@ CATEGORY_COLOR = { LABEL_FORMAT = '%s --> %s %s%s' LABEL_MIN_PADDING = 2 # min space between listing label and following data -# sort value for scrubbed ip addresses - -SCRUBBED_IP_VAL = 255 ** 4 - CONFIG = conf.config_dict('nyx', { 'features.connection.markInitialConnections': True, 'features.connection.showIps': True, @@ -119,54 +115,6 @@ class Endpoint: return default -class ConnectionEntry(entries.ConnectionPanelEntry): - """ - Represents a connection being made to or from this system. These only - concern real connections so it includes the inbound, outbound, directory, - application, and controller categories. - """ - - def __init__(self, conn): - entries.ConnectionPanelEntry.__init__(self) - self.connection = conn - self.lines = [ConnectionLine(conn)] - - def get_sort_value(self, attr, listing_type): - """ - Provides the value of a single attribute used for sorting purposes. - """ - - connection_line = self.lines[0] - - if attr == entries.SortAttr.IP_ADDRESS: - if connection_line.is_private(): - return SCRUBBED_IP_VAL # orders at the end - - return connection_line.sort_address - elif attr == entries.SortAttr.PORT: - return connection_line.sort_port - elif attr == entries.SortAttr.FINGERPRINT: - return connection_line.foreign.get_fingerprint('UNKNOWN') - elif attr == entries.SortAttr.NICKNAME: - my_nickname = connection_line.foreign.get_nickname() - - if my_nickname: - return my_nickname.lower() - else: - return 'z' * 20 # orders at the end - elif attr == entries.SortAttr.CATEGORY: - return Category.index_of(connection_line.get_type()) - elif attr == entries.SortAttr.UPTIME: - return self.connection.start_time - elif attr == entries.SortAttr.COUNTRY: - if connection.is_private_address(self.lines[0].foreign.get_address()): - return '' - else: - return connection_line.foreign.get_locale('') - else: - return entries.ConnectionPanelEntry.get_sort_value(self, attr, listing_type) - - class ConnectionLine(entries.ConnectionPanelLine): """ Display component of the ConnectionEntry. diff --git a/nyx/connections/conn_panel.py b/nyx/connections/conn_panel.py index 364c42f..18fe7e7 100644 --- a/nyx/connections/conn_panel.py +++ b/nyx/connections/conn_panel.py @@ -470,7 +470,7 @@ class ConnectionPanel(panel.Panel, threading.Thread): current_resolution_count = conn_resolver.run_counter() with self._vals_lock: - new_entries = [conn_entry.ConnectionEntry(conn) for conn in conn_resolver.get_value()] + new_entries = [entries.ConnectionPanelEntry.from_connection(conn) for conn in conn_resolver.get_value()] for circ in tor_controller().get_circuits([]): # Skips established single-hop circuits (these are for directory diff --git a/nyx/connections/entries.py b/nyx/connections/entries.py index f4693b0..301b457 100644 --- a/nyx/connections/entries.py +++ b/nyx/connections/entries.py @@ -29,32 +29,36 @@ SORT_COLORS = { PORT_COUNT = 65536 +# sort value for scrubbed ip addresses + +SCRUBBED_IP_VAL = 255 ** 4 + def to_unix_time(dt): return (dt - datetime.datetime(1970, 1, 1)).total_seconds() class ConnectionPanelEntry: - """ - Common parent for connection panel entries. This consists of a list of lines - in the panel listing. This caches results until the display indicates that - they should be flushed. - """ - - def __init__(self): + def __init__(self, start_time): self.lines = [] self.flush_cache = True + self.start_time = start_time + self.lines = [] + + @staticmethod + def from_connection(conn): + import nyx.connections.conn_entry + + entry = ConnectionPanelEntry(conn.start_time) + entry.lines = [nyx.connections.conn_entry.ConnectionLine(conn)] + return entry @staticmethod def from_circuit(circ): import nyx.connections.circ_entry - import nyx.connections.conn_entry import nyx.util.tracker - # TODO: should be ConnectionPanelEntry rather than a ConnectionEntry, but - # looks like that presently provides sorting - - entry = nyx.connections.conn_entry.ConnectionEntry(nyx.util.tracker.Connection(to_unix_time(circ.created), False, '127.0.0.1', 0, '127.0.0.1', 0, 'tcp')) + entry = ConnectionPanelEntry(to_unix_time(circ.created)) entry.lines = [nyx.connections.circ_entry.CircHeaderLine(circ)] path = [path_entry[0] for path_entry in circ.path] @@ -116,14 +120,37 @@ class ConnectionPanelEntry: def get_sort_value(self, attr, listing_type): """ Provides the value of a single attribute used for sorting purposes. - - Arguments: - attr - list of SortAttr values for the field being sorted on - listing_type - ListingType enumeration for the attribute we're listing - entries by """ - if attr == SortAttr.LISTING: + connection_line = self.lines[0] + + if attr == SortAttr.IP_ADDRESS: + if connection_line.is_private(): + return SCRUBBED_IP_VAL # orders at the end + + return connection_line.sort_address + elif attr == SortAttr.PORT: + return connection_line.sort_port + elif attr == SortAttr.FINGERPRINT: + return connection_line.foreign.get_fingerprint('UNKNOWN') + elif attr == SortAttr.NICKNAME: + my_nickname = connection_line.foreign.get_nickname() + + if my_nickname: + return my_nickname.lower() + else: + return 'z' * 20 # orders at the end + elif attr == SortAttr.CATEGORY: + import nyx.connections.conn_entry + return nyx.connections.conn_entry.Category.index_of(connection_line.get_type()) + elif attr == SortAttr.UPTIME: + return self.start_time + elif attr == SortAttr.COUNTRY: + if connection_line.connection.is_private_address(self.lines[0].foreign.get_address()): + return '' + else: + return connection_line.foreign.get_locale('') + elif attr == SortAttr.LISTING: if listing_type == ListingType.IP_ADDRESS: # uses the IP address as the primary value, and port as secondary sort_value = self.get_sort_value(SortAttr.IP_ADDRESS, listing_type) * PORT_COUNT @@ -133,8 +160,8 @@ class ConnectionPanelEntry: return self.get_sort_value(SortAttr.FINGERPRINT, listing_type) elif listing_type == ListingType.NICKNAME: return self.get_sort_value(SortAttr.NICKNAME, listing_type) - - return '' + else: + return '' def reset_display(self): """

1 0

[nyx/master] Drop flags for possibly being a client or directory connection
by atagar＠torproject.org 22 Sep '15

22 Sep '15

commit e75db3fd056fa86185b9976f445967cb815daff0 Author: Damian Johnson <atagar(a)torproject.org> Date: Sat Aug 1 13:54:05 2015 -0700 Drop flags for possibly being a client or directory connection Huh. These flags are currently never used. Only place they're set is in a cached funtion after they're used so they can never evaluate to anything except true. Meh, whatever. Fine spot to start with for simplifying the mess around type detection. --- nyx/connections/conn_entry.py | 36 +++++++++--------------------------- 1 file changed, 9 insertions(+), 27 deletions(-) diff --git a/nyx/connections/conn_entry.py b/nyx/connections/conn_entry.py index 1eae80f..2ef50e1 100644 --- a/nyx/connections/conn_entry.py +++ b/nyx/connections/conn_entry.py @@ -68,15 +68,6 @@ class ConnectionLine(entries.ConnectionPanelLine): controller = tor_controller() - # True if the connection has matched the properties of a client/directory - # connection every time we've checked. The criteria we check is... - # client - first hop in an established circuit - # directory - matches an established single-hop circuit (probably a - # directory mirror) - - self._possible_client = True - self._possible_directory = True - socks_ports = controller.get_ports(Listener.SOCKS, []) or_ports = controller.get_ports(Listener.OR, []) dir_ports = controller.get_ports(Listener.DIR, []) @@ -291,38 +282,29 @@ class ConnectionLine(entries.ConnectionPanelLine): if exit_policy and exit_policy.can_exit_to(self.connection.remote_address, port): self.cached_type = Category.EXIT - elif self._possible_client or self._possible_directory: + else: # This belongs to a known relay. If we haven't eliminated ourselves as # a possible client or directory connection then check if it still # holds true. my_circuits = controller.get_circuits([]) - if self._possible_client: - # Checks that this belongs to the first hop in a circuit that's - # either unestablished or longer than a single hop (ie, anything but - # a built 1-hop connection since those are most likely a directory - # mirror). + # Checks that this belongs to the first hop in a circuit that's + # either unestablished or longer than a single hop (ie, anything but + # a built 1-hop connection since those are most likely a directory + # mirror). - for circ in my_circuits: - if circ.path and circ.path[0][0] == destination_fingerprint and (circ.status != 'BUILT' or len(circ.path) > 1): - self.cached_type = Category.CIRCUIT # matched a probable guard connection - - # if we fell through, we can eliminate ourselves as a guard in the future - if not self.cached_type: - self._possible_client = False + for circ in my_circuits: + if circ.path and circ.path[0][0] == destination_fingerprint and (circ.status != 'BUILT' or len(circ.path) > 1): + self.cached_type = Category.CIRCUIT # matched a probable guard connection - if self._possible_directory: + if not self.cached_type: # Checks if we match a built, single hop circuit. for circ in my_circuits: if circ.path and circ.path[0][0] == destination_fingerprint and circ.status == 'BUILT' and len(circ.path) == 1: self.cached_type = Category.DIRECTORY - # if we fell through, eliminate ourselves as a directory connection - if not self.cached_type: - self._possible_directory = False - if not self.cached_type: self.cached_type = self.base_type

1 0

[nyx/master] Merge base_type into the get_type() method
by atagar＠torproject.org 22 Sep '15

22 Sep '15

commit b401851708f360a7ce1137d51fa92c740dad307f Author: Damian Johnson <atagar(a)torproject.org> Date: Sat Aug 1 14:08:18 2015 -0700 Merge base_type into the get_type() method Connection entries determined a 'base_type' in its constructor that was pretty much solely used by its get_type() method. Simpler if we just move it there. --- nyx/connections/conn_entry.py | 54 +++++++++++++++++------------------------ 1 file changed, 22 insertions(+), 32 deletions(-) diff --git a/nyx/connections/conn_entry.py b/nyx/connections/conn_entry.py index 2ef50e1..f8593ff 100644 --- a/nyx/connections/conn_entry.py +++ b/nyx/connections/conn_entry.py @@ -64,33 +64,6 @@ class ConnectionLine(entries.ConnectionPanelLine): self.connection = conn - # overwrite the local fingerprint with ours - - controller = tor_controller() - - socks_ports = controller.get_ports(Listener.SOCKS, []) - or_ports = controller.get_ports(Listener.OR, []) - dir_ports = controller.get_ports(Listener.DIR, []) - control_ports = controller.get_ports(Listener.CONTROL, []) - - # get all target ports in our hidden service configuation - - my_hidden_service_ports = [] - - for hs_config in controller.get_hidden_service_conf({}).values(): - my_hidden_service_ports += [entry[2] for entry in hs_config['HiddenServicePort']] - - if conn.local_port in or_ports or conn.local_port in dir_ports: - self.base_type = Category.INBOUND - elif conn.local_port in socks_ports: - self.base_type = Category.SOCKS - elif conn.remote_port in my_hidden_service_ports: - self.base_type = Category.HIDDEN - elif conn.local_port in control_ports: - self.base_type = Category.CONTROL - else: - self.base_type = Category.OUTBOUND - self.cached_type = None # includes the port or expanded ip address field when displaying listing @@ -122,7 +95,7 @@ class ConnectionLine(entries.ConnectionPanelLine): Provides the fingerprint of this relay. """ - if self.base_type == Category.OUTBOUND: + if self.get_type() in (Category.OUTBOUND, Category.CIRCUIT, Category.DIRECTORY, Category.EXIT): my_fingerprint = nyx.util.tracker.get_consensus_tracker().get_relay_fingerprint(self.connection.remote_address, self.connection.remote_port) return my_fingerprint if my_fingerprint else default else: @@ -262,7 +235,24 @@ class ConnectionLine(entries.ConnectionPanelLine): # we want to reflect changes if not self.cached_type: - if self.base_type == Category.OUTBOUND: + controller = tor_controller() + + my_hidden_service_ports = [] # ports belonging to our hidden service configuation + + for hs_config in controller.get_hidden_service_conf({}).values(): + my_hidden_service_ports += [entry[2] for entry in hs_config['HiddenServicePort']] + + if self.connection.local_port in controller.get_ports(Listener.OR, []): + base_type = Category.INBOUND + elif self.connection.local_port in controller.get_ports(Listener.DIR, []): + base_type = Category.INBOUND + elif self.connection.local_port in controller.get_ports(Listener.SOCKS, []): + base_type = Category.SOCKS + elif self.connection.remote_port in my_hidden_service_ports: + base_type = Category.HIDDEN + elif self.connection.local_port in controller.get_ports(Listener.CONTROL, []): + base_type = Category.CONTROL + else: # Currently the only non-static categories are OUTBOUND vs... # - EXIT since this depends on the current consensus # - CIRCUIT if this is likely to belong to our guard usage @@ -271,8 +261,8 @@ class ConnectionLine(entries.ConnectionPanelLine): # The exitability, circuits, and fingerprints are all cached by the # tor_tools util keeping this a quick lookup. - controller = tor_controller() - destination_fingerprint = self.get_fingerprint() + base_type = Category.OUTBOUND + destination_fingerprint = nyx.util.tracker.get_consensus_tracker().get_relay_fingerprint(self.connection.remote_address, self.connection.remote_port) if not destination_fingerprint: # Not a known relay. This might be an exit connection. @@ -306,7 +296,7 @@ class ConnectionLine(entries.ConnectionPanelLine): self.cached_type = Category.DIRECTORY if not self.cached_type: - self.cached_type = self.base_type + self.cached_type = base_type return self.cached_type

1 0

[nyx/master] Limit locking for updates
by atagar＠torproject.org 22 Sep '15

22 Sep '15

commit 4f24a6c593ac7e34bf419585389d02b9d7959c6d Author: Damian Johnson <atagar(a)torproject.org> Date: Sat Aug 1 13:37:12 2015 -0700 Limit locking for updates Narrowing the scope where we hold a lock for updates. For most bits we don't need any self references. Also making it a no-op if connections are unchanged. --- nyx/connections/conn_panel.py | 37 ++++++++++++++++++++----------------- 1 file changed, 20 insertions(+), 17 deletions(-) diff --git a/nyx/connections/conn_panel.py b/nyx/connections/conn_panel.py index 629a559..c16f874 100644 --- a/nyx/connections/conn_panel.py +++ b/nyx/connections/conn_panel.py @@ -459,22 +459,23 @@ class ConnectionPanel(panel.Panel, threading.Thread): """ conn_resolver = nyx.util.tracker.get_connection_tracker() + current_resolution_count = conn_resolver.run_counter() if not conn_resolver.is_alive(): return # if we're not fetching connections then this is a no-op + elif current_resolution_count == self._last_resource_fetch: + return # no new connections to process - current_resolution_count = conn_resolver.run_counter() - - with self._vals_lock: - new_entries = [entries.ConnectionPanelEntry.from_connection(conn) for conn in conn_resolver.get_value()] + new_entries = [entries.ConnectionPanelEntry.from_connection(conn) for conn in conn_resolver.get_value()] - for circ in tor_controller().get_circuits([]): - # Skips established single-hop circuits (these are for directory - # fetches, not client circuits) + for circ in tor_controller().get_circuits([]): + # Skips established single-hop circuits (these are for directory + # fetches, not client circuits) - if not (circ.status == 'BUILT' and len(circ.path) == 1): - new_entries.append(entries.ConnectionPanelEntry.from_circuit(circ)) + if not (circ.status == 'BUILT' and len(circ.path) == 1): + new_entries.append(entries.ConnectionPanelEntry.from_circuit(circ)) + with self._vals_lock: # update stats for client and exit connections for entry in new_entries: @@ -494,13 +495,15 @@ class ConnectionPanel(panel.Panel, threading.Thread): self.set_sort_order() self._last_resource_fetch = current_resolution_count - if CONFIG['features.connection.resolveApps']: - local_ports, remote_ports = [], [] + if CONFIG['features.connection.resolveApps']: + local_ports, remote_ports = [], [] + + for entry in new_entries: + line = entry.get_lines()[0] - for line in self._entry_lines: - if line.get_type() in (conn_entry.Category.SOCKS, conn_entry.Category.CONTROL): - local_ports.append(line.connection.remote_port) - elif line.get_type() == conn_entry.Category.HIDDEN: - remote_ports.append(line.connection.local_port) + if line.get_type() in (conn_entry.Category.SOCKS, conn_entry.Category.CONTROL): + local_ports.append(line.connection.remote_port) + elif line.get_type() == conn_entry.Category.HIDDEN: + remote_ports.append(line.connection.local_port) - nyx.util.tracker.get_port_usage_tracker().query(local_ports, remote_ports) + nyx.util.tracker.get_port_usage_tracker().query(local_ports, remote_ports)

1 0

[nyx/master] Sorting by country referenced non-existant function
by atagar＠torproject.org 22 Sep '15

22 Sep '15

commit f514d1ee9687b63ce72953946d2683aeb4e440ea Author: Damian Johnson <atagar(a)torproject.org> Date: Sat Aug 29 14:24:28 2015 -0700 Sorting by country referenced non-existant function Calls is_private_address() on connections. This isn't a thing. Pretty clear what it's trying to do, though. --- nyx/connections/entries.py | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/nyx/connections/entries.py b/nyx/connections/entries.py index f0b06d3..70ca6ac 100644 --- a/nyx/connections/entries.py +++ b/nyx/connections/entries.py @@ -158,10 +158,7 @@ class ConnectionPanelEntry: elif attr == SortAttr.UPTIME: return self._start_time elif attr == SortAttr.COUNTRY: - if connection_line.connection.is_private_address(self.lines[0].connection.remote_address): - return '' - else: - return connection_line.get_locale('') + return '' if self.is_private() else connection_line.get_locale('') else: return ''

1 0

[nyx/master] Simplify sort handling
by atagar＠torproject.org 22 Sep '15

22 Sep '15

commit fe2f2c33956d28bd6afd6f4c59688593fb1a653b Author: Damian Johnson <atagar(a)torproject.org> Date: Sat Aug 8 17:04:31 2015 -0700 Simplify sort handling Move handling of 'sort by listing' to the panel which knows the listing type. Also dropping the get_sort_values() which simply called get_sort_value() for all entries. --- nyx/connections/conn_panel.py | 13 ++++++++++++- nyx/connections/entries.py | 38 +++++--------------------------------- 2 files changed, 17 insertions(+), 34 deletions(-) diff --git a/nyx/connections/conn_panel.py b/nyx/connections/conn_panel.py index 76f6f16..6c17cad 100644 --- a/nyx/connections/conn_panel.py +++ b/nyx/connections/conn_panel.py @@ -158,7 +158,18 @@ class ConnectionPanel(panel.Panel, threading.Thread): ordering_keys = [entries.SortAttr.keys()[entries.SortAttr.index_of(v)] for v in ordering] nyx_config.set('features.connection.order', ', '.join(ordering_keys)) - self._entries.sort(key = lambda i: (i.get_sort_values(CONFIG['features.connection.order'], self.get_listing_type()))) + def sort_type(attr): + if attr == entries.SortAttr.LISTING: + if self.get_listing_type() == entries.ListingType.IP_ADDRESS: + return entries.SortAttr.IP_ADDRESS + elif self.get_listing_type() == entries.ListingType.FINGERPRINT: + return entries.SortAttr.FINGERPRINT + elif self.get_listing_type() == entries.ListingType.NICKNAME: + return entries.SortAttr.NICKNAME + + return attr + + self._entries.sort(key = lambda i: [i.get_sort_value(sort_type(attr)) for attr in CONFIG['features.connection.order']]) self._entry_lines = list(itertools.chain.from_iterable([entry.get_lines() for entry in self._entries])) def get_listing_type(self): diff --git a/nyx/connections/entries.py b/nyx/connections/entries.py index 4fb981d..f0b06d3 100644 --- a/nyx/connections/entries.py +++ b/nyx/connections/entries.py @@ -132,20 +132,7 @@ class ConnectionPanelEntry: return self.lines - def get_sort_values(self, sort_attrs, listing_type): - """ - Provides the value used in comparisons to sort based on the given - attribute. - - Arguments: - sort_attrs - list of SortAttr values for the field being sorted on - listing_type - ListingType enumeration for the attribute we're listing - entries by - """ - - return [self.get_sort_value(attr, listing_type) for attr in sort_attrs] - - def get_sort_value(self, attr, listing_type): + def get_sort_value(self, attr): """ Provides the value of a single attribute used for sorting purposes. """ @@ -156,18 +143,15 @@ class ConnectionPanelEntry: if self.is_private(): return SCRUBBED_IP_VAL # orders at the end - return address_to_int(connection_line.connection.remote_address) + sort_value = address_to_int(connection_line.connection.remote_address) * PORT_COUNT + sort_value += connection_line.connection.remote_port + return sort_value elif attr == SortAttr.PORT: return connection_line.connection.remote_port elif attr == SortAttr.FINGERPRINT: return connection_line.get_fingerprint('UNKNOWN') elif attr == SortAttr.NICKNAME: - my_nickname = connection_line.get_nickname() - - if my_nickname: - return my_nickname.lower() - else: - return 'z' * 20 # orders at the end + return connection_line.get_nickname('z' * 20) elif attr == SortAttr.CATEGORY: import nyx.connections.conn_entry return nyx.connections.conn_entry.Category.index_of(self.get_type()) @@ -178,16 +162,6 @@ class ConnectionPanelEntry: return '' else: return connection_line.get_locale('') - elif attr == SortAttr.LISTING: - if listing_type == ListingType.IP_ADDRESS: - # uses the IP address as the primary value, and port as secondary - sort_value = self.get_sort_value(SortAttr.IP_ADDRESS, listing_type) * PORT_COUNT - sort_value += self.get_sort_value(SortAttr.PORT, listing_type) - return sort_value - elif listing_type == ListingType.FINGERPRINT: - return self.get_sort_value(SortAttr.FINGERPRINT, listing_type) - elif listing_type == ListingType.NICKNAME: - return self.get_sort_value(SortAttr.NICKNAME, listing_type) else: return '' @@ -224,8 +198,6 @@ class ConnectionPanelLine: width - available space to display in current_time - unix timestamp for what the results should consider to be the current time (this may be ignored due to caching) - listing_type - ListingType enumeration for the highest priority content - to be displayed """ if self._listing_cache_args != (width, listing_type):

1 0

[nyx/master] Move is_private() to be an entity method
by atagar＠torproject.org 22 Sep '15

22 Sep '15

commit d20add70f5a5775c1ddc87bf15c46b6f8222e05e Author: Damian Johnson <atagar(a)torproject.org> Date: Sat Aug 1 17:39:55 2015 -0700 Move is_private() to be an entity method Another thing that doesn't really belong on individual lines. Also addressing a 'todo' comment in the process about checking if dns queries are using udp (we now have this information handy). --- nyx/connections/conn_entry.py | 40 ++-------------------------------------- nyx/connections/conn_panel.py | 2 +- nyx/connections/entries.py | 39 +++++++++++++++++++++++++++++++++++++-- 3 files changed, 40 insertions(+), 41 deletions(-) diff --git a/nyx/connections/conn_entry.py b/nyx/connections/conn_entry.py index 021accb..13aaadf 100644 --- a/nyx/connections/conn_entry.py +++ b/nyx/connections/conn_entry.py @@ -175,42 +175,6 @@ class ConnectionLine(entries.ConnectionPanelLine): detail_format = (curses.A_BOLD, CATEGORY_COLOR[self.get_type()]) return [(line, detail_format) for line in self._get_detail_content(width)] - def is_private(self): - """ - Returns true if the endpoint is private, possibly belonging to a client - connection or exit traffic. - """ - - if not CONFIG['features.connection.showIps']: - return True - - # This is used to scrub private information from the interface. Relaying - # etiquette (and wiretapping laws) say these are bad things to look at so - # DON'T CHANGE THIS UNLESS YOU HAVE A DAMN GOOD REASON! - - my_type = self.get_type() - - if my_type == Category.INBOUND: - controller = tor_controller() - - if controller.is_user_traffic_allowed().inbound: - all_matches = nyx.util.tracker.get_consensus_tracker().get_all_relay_fingerprints(self.connection.remote_address) - return all_matches == [] - elif my_type == Category.EXIT: - # DNS connections exiting us aren't private (since they're hitting our - # resolvers). Everything else, however, is. - - # TODO: Ideally this would also double check that it's a UDP connection - # (since DNS is the only UDP connections Tor will relay), however this - # will take a bit more work to propagate the information up from the - # connection resolver. - - return self.connection.remote_port != 53 - - # for everything else this isn't a concern - - return False - def get_type(self): return self._entry.get_type() @@ -435,7 +399,7 @@ class ConnectionLine(entries.ConnectionPanelLine): lines = [''] * 7 lines[0] = 'address: %s' % self.get_destination_label(width - 11) - lines[1] = 'locale: %s' % ('??' if self.is_private() else self.get_locale('??')) + lines[1] = 'locale: %s' % ('??' if self._entry.is_private() else self.get_locale('??')) # Remaining data concerns the consensus results, with three possible cases: # - if there's a single match then display its details @@ -581,7 +545,7 @@ class ConnectionLine(entries.ConnectionPanelLine): # destination of the connection - address_label = '<scrubbed>' if self.is_private() else self.connection.remote_address + address_label = '<scrubbed>' if self._entry.is_private() else self.connection.remote_address port_label = ':%s' % self.connection.remote_port if include_port else '' destination_address = address_label + port_label diff --git a/nyx/connections/conn_panel.py b/nyx/connections/conn_panel.py index 7d06abe..76f6f16 100644 --- a/nyx/connections/conn_panel.py +++ b/nyx/connections/conn_panel.py @@ -481,7 +481,7 @@ class ConnectionPanel(panel.Panel, threading.Thread): for entry in new_entries: entry_line = entry.get_lines()[0] - if entry_line.is_private() and entry.get_type() == conn_entry.Category.INBOUND: + if entry.is_private() and entry.get_type() == conn_entry.Category.INBOUND: client_locale = entry_line.get_locale(None) if client_locale: diff --git a/nyx/connections/entries.py b/nyx/connections/entries.py index 6963123..1242887 100644 --- a/nyx/connections/entries.py +++ b/nyx/connections/entries.py @@ -9,7 +9,7 @@ import datetime from nyx.util import tor_controller from stem.control import Listener -from stem.util import enum +from stem.util import conf, enum # attributes we can list entries by @@ -37,6 +37,10 @@ PORT_COUNT = 65536 SCRUBBED_IP_VAL = 255 ** 4 ADDRESS_CACHE = {} +CONFIG = conf.config_dict('nyx', { + 'features.connection.showIps': True, +}) + def to_unix_time(dt): return (dt - datetime.datetime(1970, 1, 1)).total_seconds() @@ -110,6 +114,37 @@ class ConnectionPanelEntry: return self._connection_type + def is_private(self): + """ + Returns true if the endpoint is private, possibly belonging to a client + connection or exit traffic. + + This is used to scrub private information from the interface. Relaying + etiquette (and wiretapping laws) say these are bad things to look at so + DON'T CHANGE THIS UNLESS YOU HAVE A DAMN GOOD REASON! + """ + + import nyx.connections.conn_entry + import nyx.util.tracker + + if not CONFIG['features.connection.showIps']: + return True + + if self.get_type() == nyx.connections.conn_entry.Category.INBOUND: + controller = tor_controller() + + if controller.is_user_traffic_allowed().inbound: + return len(nyx.util.tracker.get_consensus_tracker().get_all_relay_fingerprints(self.connection.remote_address)) == 0 + elif self.get_type() == nyx.connections.conn_entry.Category.EXIT: + # DNS connections exiting us aren't private (since they're hitting our + # resolvers). Everything else, however, is. + + return self.connection.remote_port != 53 or self.connection.protocol != 'udp' + + # for everything else this isn't a concern + + return False + def get_lines(self): """ Provides the individual lines in the connection listing. @@ -138,7 +173,7 @@ class ConnectionPanelEntry: connection_line = self.lines[0] if attr == SortAttr.IP_ADDRESS: - if connection_line.is_private(): + if self.is_private(): return SCRUBBED_IP_VAL # orders at the end return address_to_int(connection_line.connection.remote_address)

1 0

[nyx/master] Move application resolution into the lines
by atagar＠torproject.org 22 Sep '15

22 Sep '15

commit eb37d9008ec6cd460ddf352b98ed1fa14f454125 Author: Damian Johnson <atagar(a)torproject.org> Date: Wed Jul 29 10:17:20 2015 -0700 Move application resolution into the lines Our panel resolved applications, then populated attributes on the lines. Ewww! The tracker caches results so the lines can just retrieve values from that on-demand. While doing this realized past changs made it so we can't differentiate between 'unknown' and 'still resolving', so should fix that next. --- nyx/connections/conn_entry.py | 37 ++++++++++++------------- nyx/connections/conn_panel.py | 45 ++++--------------------------- nyx/util/tracker.py | 15 ++++++++++- test/util/tracker/port_usage_tracker.py | 6 ++--- 4 files changed, 39 insertions(+), 64 deletions(-) diff --git a/nyx/connections/conn_entry.py b/nyx/connections/conn_entry.py index d945182..fe18485 100644 --- a/nyx/connections/conn_entry.py +++ b/nyx/connections/conn_entry.py @@ -77,12 +77,6 @@ class ConnectionLine(entries.ConnectionPanelLine): self._possible_client = True self._possible_directory = True - # attributes for SOCKS, HIDDEN, and CONTROL connections - - self.application_name = None - self.application_pid = None - self.is_application_resolving = False - socks_ports = controller.get_ports(Listener.SOCKS, []) or_ports = controller.get_ports(Listener.OR, []) dir_ports = controller.get_ports(Listener.DIR, []) @@ -151,6 +145,16 @@ class ConnectionLine(entries.ConnectionPanelLine): nickname = nyx.util.tracker.get_consensus_tracker().get_relay_nickname(self.get_fingerprint()) return nickname if nickname else default + def get_process(self): + """ + Local process using this connection. This is only available for socks, + hidden service, and controller connections. This is **None** if the + application is either still being resolved or can't be determined. + """ + + port = self.connection.local_port if self.get_type() == Category.HIDDEN else self.connection.remote_port + return nyx.util.tracker.get_port_usage_tracker().fetch(port) + def get_listing_entry(self, width, current_time, listing_type): """ Provides the tuple list for this connection's listing. Lines are composed @@ -195,13 +199,6 @@ class ConnectionLine(entries.ConnectionPanelLine): return my_listing - def is_unresolved_application(self): - """ - True if our display uses application information that hasn't yet been resolved. - """ - - return self.application_name is None and self.get_type() in (Category.SOCKS, Category.HIDDEN, Category.CONTROL) - def _get_listing_entry(self, width, current_time, listing_type): entry_type = self.get_type() @@ -354,16 +351,16 @@ class ConnectionLine(entries.ConnectionPanelLine): if self.get_type() in (Category.SOCKS, Category.HIDDEN, Category.CONTROL): display_label = '' + process = self.get_process() - if self.application_name: - if self.application_pid: - display_label = '%s (%s)' % (self.application_name, self.application_pid) + if process: + if process.pid: + display_label = '%s (%s)' % (process.name, process.pid) else: - display_label = self.application_name - elif self.is_application_resolving: - display_label = 'resolving...' + display_label = process.name else: - display_label = 'UNKNOWN' + # TODO: We should differentiate between 'resolving...' and 'unknown' + display_label = 'resolving...' if len(display_label) < width: return ('%%-%is' % width) % display_label diff --git a/nyx/connections/conn_panel.py b/nyx/connections/conn_panel.py index e40a431..5163ec9 100644 --- a/nyx/connections/conn_panel.py +++ b/nyx/connections/conn_panel.py @@ -13,7 +13,7 @@ import nyx.popups import nyx.util.tracker from nyx.connections import descriptor_popup, entries, conn_entry -from nyx.util import panel, tor_controller, tracker, ui_tools +from nyx.util import panel, tor_controller, ui_tools from stem.control import State from stem.util import conf, connection, enum @@ -115,10 +115,6 @@ class ConnectionPanel(panel.Panel, threading.Thread): self._last_resource_fetch = -1 - # resolver for the command/pid associated with SOCKS, HIDDEN, and CONTROL connections - - self._app_resolver = tracker.get_port_usage_tracker() - # mark the initially exitsing connection uptimes as being estimates for entry in self._entries: @@ -509,41 +505,10 @@ class ConnectionPanel(panel.Panel, threading.Thread): if not CONFIG['features.connection.resolveApps']: return - unresolved_lines = [l for l in self._entry_lines if isinstance(l, conn_entry.ConnectionLine) and l.is_unresolved_application()] - - # get the ports used for unresolved applications - app_ports = [] - for line in unresolved_lines: - app_ports.append(line.connection.local_port if line.get_type() == conn_entry.Category.HIDDEN else line.connection.remote_port) - - # Queue up resolution for the unresolved ports (skips if it's still working - # on the last query). - - if app_ports and not self._app_resolver.is_alive(): - self._app_resolver.get_processes_using_ports(app_ports) + for line in self._entry_lines: + if line.get_type() in (conn_entry.Category.SOCKS, conn_entry.Category.HIDDEN, conn_entry.Category.CONTROL): + app_ports.append(line.connection.local_port if line.get_type() == conn_entry.Category.HIDDEN else line.connection.remote_port) - # Fetches results. If the query finishes quickly then this is what we just - # asked for, otherwise these belong to an earlier resolution. - # - # The application resolver might have given up querying (for instance, if - # the lsof lookups aren't working on this platform or lacks permissions). - # The is_application_resolving flag lets the unresolved entries indicate if there's - # a lookup in progress for them or not. - - time.sleep(0.2) # TODO: previous resolver only blocked while awaiting a lookup - app_results = self._app_resolver.get_processes_using_ports(app_ports) - - for line in unresolved_lines: - is_local = line.get_type() == conn_entry.Category.HIDDEN - line_port = line.connection.local_port if is_local else line.connection.remote_port - - if line_port in app_results: - result = app_results[line_port] - - line.application_name = result.name - line.application_pid = result.pid - line.is_application_resolving = False - else: - line.is_application_resolving = self._app_resolver.is_alive + nyx.util.tracker.get_port_usage_tracker().query(app_ports) diff --git a/nyx/util/tracker.py b/nyx/util/tracker.py index f6219ad..5d9c81e 100644 --- a/nyx/util/tracker.py +++ b/nyx/util/tracker.py @@ -670,7 +670,20 @@ class PortUsageTracker(Daemon): self._processes_for_ports = {} self._failure_count = 0 # number of times in a row we've failed to get results - def get_processes_using_ports(self, ports): + def fetch(self, port): + """ + Provides the process running on the given port. This retrieves the results + from our cache, so it only works if we've already issued a query() request + for it and gotten results. + + :param int port: port number to look up + + :returns: **Process** using the given port, or **None** if it's unavailable + """ + + return self._processes_for_ports.get(port) + + def query(self, ports): """ Registers a given set of ports for further lookups, and returns the last set of 'port => process' mappings we retrieved. Note that this means that diff --git a/test/util/tracker/port_usage_tracker.py b/test/util/tracker/port_usage_tracker.py index 8528e69..41d88d0 100644 --- a/test/util/tracker/port_usage_tracker.py +++ b/test/util/tracker/port_usage_tracker.py @@ -91,10 +91,10 @@ class TestPortUsageTracker(unittest.TestCase): with PortUsageTracker(0.02) as daemon: time.sleep(0.01) - self.assertEqual({}, daemon.get_processes_using_ports([37277, 51849])) + self.assertEqual({}, daemon.query([37277, 51849])) time.sleep(0.04) - self.assertEqual({37277: 'python', 51849: 'tor'}, daemon.get_processes_using_ports([37277, 51849])) + self.assertEqual({37277: 'python', 51849: 'tor'}, daemon.query([37277, 51849])) @patch('nyx.util.tracker.tor_controller') @patch('nyx.util.tracker._process_for_ports') @@ -110,7 +110,7 @@ class TestPortUsageTracker(unittest.TestCase): time.sleep(0.05) self.assertEqual(0, daemon._failure_count) - daemon.get_processes_using_ports([37277, 51849]) + daemon.query([37277, 51849]) time.sleep(0.03) self.assertTrue(daemon.is_alive()) time.sleep(0.1)

1 0

[nyx/master] Drop set_exit() from CircHeaderLine
by atagar＠torproject.org 22 Sep '15

22 Sep '15

commit 0d556766d75f048b448a3773ceb882a231ca1492 Author: Damian Johnson <atagar(a)torproject.org> Date: Sat Aug 1 17:57:35 2015 -0700 Drop set_exit() from CircHeaderLine Simlifying the CircHeaderLine a little. The set_exit() is part of construction, and there because we previously didn't have the full circuit available when it was first made. We now use a Stem circuit class so all the information's there. --- nyx/connections/circ_entry.py | 32 ++++++++++++++------------------ nyx/connections/entries.py | 4 ---- 2 files changed, 14 insertions(+), 22 deletions(-) diff --git a/nyx/connections/circ_entry.py b/nyx/connections/circ_entry.py index 7d3fc8d..0e6ca3f 100644 --- a/nyx/connections/circ_entry.py +++ b/nyx/connections/circ_entry.py @@ -25,23 +25,20 @@ class CircHeaderLine(conn_entry.ConnectionLine): """ def __init__(self, entry, circ): - conn_entry.ConnectionLine.__init__(self, entry, nyx.util.tracker.Connection(entries.to_unix_time(circ.created), False, '127.0.0.1', 0, '0.0.0.0', 0, 'tcp'), False, False) - self.circuit_id = circ.id - self.purpose = circ.purpose.capitalize() - self.is_built = False - self._timestamp = entries.to_unix_time(circ.created) - self._remote_fingerprint = None - - def set_exit(self, exit_address, exit_port, exit_fingerprint): - conn_entry.ConnectionLine.__init__(self, self._entry, nyx.util.tracker.Connection(self._timestamp, False, '127.0.0.1', 0, exit_address, exit_port, 'tcp'), False, False) - self.is_built = True - self._remote_fingerprint = exit_fingerprint + if circ.status == 'BUILT': + self._remote_fingerprint = circ.path[-1][0] + exit_address, exit_port = nyx.util.tracker.get_consensus_tracker().get_relay_address(self._remote_fingerprint, ('192.168.0.1', 0)) + self.is_built = True + else: + exit_address, exit_port = '0.0.0.0', 0 + self.is_built = False + self._remote_fingerprint = None + + conn_entry.ConnectionLine.__init__(self, entry, nyx.util.tracker.Connection(entries.to_unix_time(circ.created), False, '127.0.0.1', 0, exit_address, exit_port, 'tcp'), False, False) + self.circuit = circ def get_fingerprint(self, default = None): - if self._remote_fingerprint: - return self._remote_fingerprint - else: - return conn_entry.ConnectionLine.get_fingerprint(self, default) + return self._remote_fingerprint if self._remote_fingerprint else conn_entry.ConnectionLine.get_fingerprint(self, default) def get_destination_label(self, max_length, include_locale = False): if not self.is_built: @@ -55,7 +52,7 @@ class CircHeaderLine(conn_entry.ConnectionLine): shown completely (not enough room) is dropped. """ - etc_attr = ['Purpose: %s' % self.purpose, 'Circuit ID: %s' % self.circuit_id] + etc_attr = ['Purpose: %s' % self.circuit.purpose.capitalize(), 'Circuit ID: %s' % self.circuit.id] for i in range(len(etc_attr), -1, -1): etc_label = ', '.join(etc_attr[:i]) @@ -81,10 +78,9 @@ class CircLine(conn_entry.ConnectionLine): """ def __init__(self, entry, remote_address, remote_port, remote_fingerprint, placement_label, timestamp): - conn_entry.ConnectionLine.__init__(self, entry, nyx.util.tracker.Connection(timestamp, False, '127.0.0.1', 0, remote_address, remote_port, 'tcp')) + conn_entry.ConnectionLine.__init__(self, entry, nyx.util.tracker.Connection(timestamp, False, '127.0.0.1', 0, remote_address, remote_port, 'tcp'), False) self._remote_fingerprint = remote_fingerprint self.placement_label = placement_label - self.include_port = False # determines the sort of left hand bracketing we use diff --git a/nyx/connections/entries.py b/nyx/connections/entries.py index 1242887..a4e2014 100644 --- a/nyx/connections/entries.py +++ b/nyx/connections/entries.py @@ -84,10 +84,6 @@ class ConnectionPanelEntry: path = [path_entry[0] for path_entry in circ.path] - if circ.status == 'BUILT': - exit_ip, exit_port = nyx.util.tracker.get_consensus_tracker().get_relay_address(path[-1], ('192.168.0.1', 0)) - entry.lines[0].set_exit(exit_ip, exit_port, path[-1]) - for i, relay_fingerprint in enumerate(path): relay_ip, relay_port = nyx.util.tracker.get_consensus_tracker().get_relay_address(relay_fingerprint, ('192.168.0.1', 0))

1 0

[nyx/master] Move more initialization logic into CircLine
by atagar＠torproject.org 22 Sep '15

22 Sep '15

commit 94e48a725930af385a4a58dd54ca4f18e08c7c41 Author: Damian Johnson <atagar(a)torproject.org> Date: Sat Aug 1 18:17:41 2015 -0700 Move more initialization logic into CircLine The caller was doing more to initialize CircLine than it needed. The constructor can figure out its own position in the circuit. --- nyx/connections/circ_entry.py | 24 ++++++++++++++++++------ nyx/connections/entries.py | 20 ++------------------ 2 files changed, 20 insertions(+), 24 deletions(-) diff --git a/nyx/connections/circ_entry.py b/nyx/connections/circ_entry.py index 0e6ca3f..b1d95c7 100644 --- a/nyx/connections/circ_entry.py +++ b/nyx/connections/circ_entry.py @@ -77,17 +77,29 @@ class CircLine(conn_entry.ConnectionLine): caching, etc). """ - def __init__(self, entry, remote_address, remote_port, remote_fingerprint, placement_label, timestamp): - conn_entry.ConnectionLine.__init__(self, entry, nyx.util.tracker.Connection(timestamp, False, '127.0.0.1', 0, remote_address, remote_port, 'tcp'), False) - self._remote_fingerprint = remote_fingerprint - self.placement_label = placement_label + def __init__(self, entry, circ, fingerprint, timestamp): + relay_ip, relay_port = nyx.util.tracker.get_consensus_tracker().get_relay_address(fingerprint, ('192.168.0.1', 0)) + conn_entry.ConnectionLine.__init__(self, entry, nyx.util.tracker.Connection(timestamp, False, '127.0.0.1', 0, relay_ip, relay_port, 'tcp'), False) + self._fingerprint = fingerprint + + circ_path = [path_entry[0] for path_entry in circ.path] + circ_index = circ_path.index(fingerprint) + + if circ_index == len(circ_path) - 1: + placement_type = 'Exit' if circ.status == 'BUILT' else 'Extending' + elif circ_index == 0: + placement_type = 'Guard' + else: + placement_type = 'Middle' + + self.placement_label = '%i / %s' % (circ_index + 1, placement_type) # determines the sort of left hand bracketing we use - self.is_last = False + self.is_last = circ_index == len(circ_path) - 1 def get_fingerprint(self, default = None): - self._remote_fingerprint + self._fingerprint def get_listing_prefix(self): if self.is_last: diff --git a/nyx/connections/entries.py b/nyx/connections/entries.py index a4e2014..4fb981d 100644 --- a/nyx/connections/entries.py +++ b/nyx/connections/entries.py @@ -77,28 +77,12 @@ class ConnectionPanelEntry: def from_circuit(circ): import nyx.connections.circ_entry import nyx.connections.conn_entry - import nyx.util.tracker entry = ConnectionPanelEntry(nyx.connections.conn_entry.Category.CIRCUIT, to_unix_time(circ.created)) entry.lines = [nyx.connections.circ_entry.CircHeaderLine(entry, circ)] - path = [path_entry[0] for path_entry in circ.path] - - for i, relay_fingerprint in enumerate(path): - relay_ip, relay_port = nyx.util.tracker.get_consensus_tracker().get_relay_address(relay_fingerprint, ('192.168.0.1', 0)) - - if i == len(path) - 1: - placement_type = 'Exit' if circ.status == 'BUILT' else 'Extending' - elif i == 0: - placement_type = 'Guard' - else: - placement_type = 'Middle' - - placement_label = '%i / %s' % (i + 1, placement_type) - - entry.lines.append(nyx.connections.circ_entry.CircLine(entry, relay_ip, relay_port, relay_fingerprint, placement_label, to_unix_time(circ.created))) - - entry.lines[-1].is_last = True + for fingerprint, _ in circ.path: + entry.lines.append(nyx.connections.circ_entry.CircLine(entry, circ, fingerprint, to_unix_time(circ.created))) return entry

1 0