[Author Prev][Author Next][Thread Prev][Thread Next][Author Index][Thread Index]
[tor-commits] [ooni-probe/master] Moving bootstrap_tor() functions to experiment()
commit 0b892accffdd5a09c5bba87b9c75adfcdc50eea2
Author: Isis Lovecruft <isis@xxxxxxxxxxxxxx>
Date: Tue Sep 11 11:38:45 2012 +0000
Moving bootstrap_tor() functions to experiment()
---
ooni/assets/bridgetests.txt | 8 +-
ooni/plugins/bridget.py | 362 ++++++++++++++++++++++++++++++++++++------
2 files changed, 315 insertions(+), 55 deletions(-)
diff --git a/ooni/assets/bridgetests.txt b/ooni/assets/bridgetests.txt
index c837988..7bba841 100644
--- a/ooni/assets/bridgetests.txt
+++ b/ooni/assets/bridgetests.txt
@@ -1,3 +1,5 @@
-213.151.89.102:9001
-108.166.106.156:443
-217.150.224.213:443
+#213.151.89.102:9001
+#108.166.106.156:443
+#217.150.224.213:443
+85.193.252.111:443
+#68.98.41.14:9001
diff --git a/ooni/plugins/bridget.py b/ooni/plugins/bridget.py
index 5562fb6..f665290 100644
--- a/ooni/plugins/bridget.py
+++ b/ooni/plugins/bridget.py
@@ -8,92 +8,350 @@
# | connection to a list of bridges or relays. |
# +----------------------------------------------+
#
-# :authors: Arturo Filasto, Isis Lovecruft, Jacob Appelbaum
+# :authors: Arturo Filasto, Isis Lovecruft
# :licence: see included LICENSE
# :version: 0.1.0-alpha
-from zope.interface import implements
-from twisted.python import usage
-from twisted.plugin import IPlugin
-from twisted.internet import reactor
+from __future__ import with_statement
+from zope.interface import implements
+from twisted.python import usage
+from twisted.plugin import IPlugin
+from twisted.internet import reactor, error
-from ooni.utils import log
-from ooni.plugoo.tests import ITest, OONITest
-from ooni.plugoo.assets import Asset
+import random
-class bridgetArgs(usage.Options):
- optParameters = [['bridges', 'b', None, 'List of bridges to scan'],
- ['relays', 'f', None, 'List of relays to scan'],
- ['resume', 'r', 0, 'Resume at this index']]
+try:
+ from ooni.lib.txtorcon import CircuitListenerMixin, IStreamAttacher
+except:
+ print "BridgeT requires txtorcon: https://github.com/meejah/txtorcon.git";
+ print "Your copy of OONI should have it included, if you're seeing this"
+ print "message, please file a bug report."
+ log.msg ("Bridget: Unable to import from ooni.lib.txtorcon")
-class bridgetTest(OONITest):
+from ooni.utils import log
+from ooni.plugoo.tests import ITest, OONITest
+from ooni.plugoo.assets import Asset
+
+
+class BridgetArgs(usage.Options):
+ optParameters = [
+ ['bridges', 'b', None,
+ 'List of bridges to scan (IP:ORport)'],
+ ['relays', 'f', None,
+ 'List of relays to scan (IP)'],
+ ['socks', 's', 9049,
+ 'Tor SocksPort to use'],
+ ['control', 'c', 9052,
+ 'Tor ControlPort to use'],
+ ['random', 'x', False,
+ 'Randomize control and socks ports'],
+ ['tor-path', 'p', '/usr/sbin/tor',
+ 'Path to the Tor binary to use'],
+ ['transport', 't', None,
+ 'Tor ClientTransportPlugin string. Requires -b.'],
+ ['resume', 'r', 0,
+ 'Resume at this index']]
+
+class CustomCircuit(CircuitListenerMixin):
+ implements(IStreamAttacher)
+
+ from txtorcon.interface import IRouterContainer, ICircuitContainer
+
+ def __init__(self, state):
+ self.state = state
+ self.waiting_circuits = []
+
+ def waiting_on(self, circuit):
+ for (circid, d) in self.waiting_circuits:
+ if circuit.id == circid:
+ return true
+ return False
+
+ def circuit_extend(self, circuit, router):
+ "ICircuitListener"
+ if circuit.purpose != 'GENERAL':
+ return
+ if self.waiting_on(circuit):
+ log.msg("Circuit %d (%s)" % (circuit.id, router.id_hex))
+
+ def circuit_built(self, circuit):
+ "ICircuitListener"
+ if circuit.purpose != 'GENERAL':
+ return
+
+ log.msg("Circuit %s built ..." % circuit.id)
+ log.msg("Full path of %s: %s" % (circuit.id, circuit.path))
+
+ for (circid, d) in self.waiting_circuits:
+ if circid == circuit.id:
+ self.waiting_circuits.remove(circid, d)
+ d.callback(circuit)
+
+ def circuit_failed(self, circuit, reason):
+ if self.waiting_on(circuit):
+ log.msg("A circuit we requested %s failed for reason %s" %
+ (circuit.id, reason))
+ circid, d = None, None
+ for x in self.waiting_circuits:
+ if x[0] == circuit.id:
+ circid, d, stream_cc = x
+ if d is None:
+ raise Exception("Expected to find circuit.")
+
+ self.waiting_circuits.remove((circid, d))
+ log.msg("Trying to build a circuit for %s" % circid)
+ self.request_circuit_build(d)
+
+ def check_circuit_route(self, circuit, router):
+ if router in circuit.path:
+ #router.update() ## XXX can i use without args? no.
+ TorInfo.dump(self)
+
+ def request_circuit_build(self, deferred):
+ entries = self.state.entry_guards.value()
+ relays = self.state.routers.values()
+
+ log.msg("We have these nodes listed as entry guards:")
+ log.msg("%s" % entries)
+ log.msg("We have these nodes listed as relays:")
+ log.msg("%s" % relays)
+
+ path = [random.choice(entries),
+ random.choice(relays),
+ random.choice(relays)]
+
+ log.msg("Requesting a circuit: %s"
+ % '-->'.join(map(lambda x: x.location.countrycode, path)))
+
+ class AppendWaiting:
+ def __init__(self, attacher, deferred):
+ self.attacher = attacher
+ self.d = deferred
+
+ def __call__(self, circuit):
+ """
+ Return from build_circuit is a Circuit, however, we want to
+ wait until it is built before we can issue an attach on it and
+ callback to the Deferred we issue here.
+ """
+ log.msg("Circuit %s is in progress ..." % circuit.id)
+ self.attacher.waiting_circuits.append((circuit.id, self.d))
+
+ return self.state.build_circuit(path).addCallback(AppendWaiting(self, deferred_to_callback)).addErrback(log.err)
+
+class BridgetTest(OONITest):
+ """
+ XXX fill me in
+
+ :ivar config:
+ An :class:`ooni.lib.txtorcon.TorConfig` instance.
+ :ivar use_bridges:
+ A boolean integer [0|1].
+ :ivar entry_nodes:
+ A string of all provided relays to test. We have to do this
+ because txtorcon.TorState().entry_guards won't build a custom
+ circuit if the first hop isn't in the torrc's EntryNodes.
+ :ivar relay_list:
+ The same as :ivar entry_nodes: but in list form.
+ :ivar socks_port:
+ Integer for Tor's SocksPort.
+ :ivar control_port:
+ Integer for Tor's ControlPort.
+ :ivar plug_transport:
+ String defining the Tor's ClientTransportPlugin, for testing
+ a bridge's pluggable transport functionality.
+ :ivar tor_binary:
+ Path to the Tor binary to use, e.g. \'/usr/sbin/tor\'
+ """
implements(IPlugin, ITest)
shortName = "bridget"
- description = "Use a slave Tor process to test RELAY_EXTEND to bridges/relays"
+ description = "Use a Tor process to test connecting to bridges/relays"
requirements = None
- options = bridgetArgs
+ options = BridgetArgs
blocking = False
- def experiment(self, args):
- log.msg("BridgeT: initiating test ... ")
+ def load_assets(self):
+ """
+ Load bridges from file given in user options. Bridges should be given
+ in the form IP:ORport. We don't want to load relays as assets, because
+ it's inefficient to test them one at a time.
+ """
+ assets = {}
+ if self.local_options:
+ if self.local_options['bridges']:
+ assets.update({'bridge': Asset(self.local_options['bridges'])})
+ return assets
+ def initialize(self):
+ """
+ Extra initialization steps. We only want one child Tor process
+ running, so we need to deal with the creation of the torrc only once,
+ before the experiment runs.
+ """
+ self.relay_list = []
+ ## XXX why doesn't the default set in the options work?
+ self.socks_port = 9049
+ self.control_port = 9052
+
+ if self.local_options:
+ try:
+ from ooni.lib.txtorcon import TorConfig
+ except:
+ log.msg("Could not import TorConfig class from txtorcon")
+ raise
+
+ options = self.local_options
+ self.config = TorConfig()
+ self.socks_port = options['socks']
+ self.control_port = options['control']
+
+ if options['bridges']:
+ log.msg("Using Bridges ...")
+ self.config.UseBridges = 1
+
+ if options['relays']:
+ '''
+ Stupid hack for when testing only relays (and not bridges):
+ Tor doesn't use EntryNodes when UseBridges is enabled, but
+ txtorcon requires config.state.entry_guards to make a custom
+ circuit, so we should list them as EntryNodes anyway.
+ '''
+ log.msg("Using relays ...")
+
+ with open(options['relays']) as relay_file:
+ for line in relay_file.readlines():
+ if line.startswith('#'):
+ continue
+ else:
+ relay = line.replace('\n', '') ## not assets because
+ self.relay_list.append(relay) ## we don't want to
+ ## test one at a time
+ self.config.EntryNodes = ','
+ self.config.EntryNodes.join(relay_list)
+
+ if options['random']:
+ log.msg("Using randomized ControlPort and SocksPort ...")
+ self.socks_port = random.randint(1024, 2**16)
+ self.control_port = random.randint(1024, 2**16)
+
+ if options['tor-path']:
+ self.tor_binary = options['tor-path']
+
+ if options['transport']:
+ '''
+ ClientTransportPlugin transport socks4|socks5 IP:PORT
+ ClientTransportPlugin transport exec path-to-binary [options]
+ '''
+ if not options['bridges']:
+ e = "To test pluggable transports, you must provide a file"
+ e = e+"with a list of bridge IP:ORPorts. See \'-b' option."
+ raise usage.UsageError("%s" % e)
+
+ log.msg("Using pluggable transport ...")
+ ## XXX fixme there's got to be a better way to check the exec
+ assert type(options['transport']) is str
+ self.config.ClientTransportPlugin = options['transport']
+
+ self.config.SocksPort = self.socks_port
+ self.config.ControlPort = self.control_port
+ self.config.save()
+
+ print self.config.create_torrc()
+ report = {'tor_config': self.config.config}
+ #log.msg("Starting Tor")
+ #
+ #self.tor_process_protocol = self.bootstrap_tor(self.config)
+ #self.d = self.bootstrap_tor(self.d, self.config,
+ # self.reactor, self.report)
+ #return self.d
+ return self.config
+ else:
+ return None
+
+ def bootstrap_tor(self, config, args):
+ """
+ Launch a Tor process with the TorConfig instance returned from
+ initialize().
+
+ Returns a Deferred which callbacks with a TorProcessProtocol connected
+ to the fully-bootstrapped Tor; this has a txtorcon.TorControlProtocol
+ instance as .protocol.
+ """
from ooni.lib.txtorcon import TorProtocolFactory, TorConfig, TorState
from ooni.lib.txtorcon import DEFAULT_VALUE, launch_tor
- reactor = self.reactor
+ log.msg("Tor config: %s" % config)
+ log.msg("Starting Tor ...")
def setup_failed(args):
log.msg("Setup Failed.")
report.update({'failed': args})
reactor.stop()
- #return report
def setup_complete(proto):
log.msg("Setup Complete: %s" % proto)
state = TorState(proto.tor_protocol)
state.post_bootstrap.addCallback(state_complete).addErrback(setup_failed)
report.update({'success': args})
- #return report
def bootstrap(c):
conf = TorConfig(c)
conf.post_bootstrap.addCallback(setup_complete).addErrback(setup_failed)
- log.msg("Slave Tor process connected, bootstrapping ...")
-
- config = TorConfig()
- import random
- config.SocksPort = random.randint(1024, 2**16)
- config.ControlPort = random.randint(1024, 2**16)
- #config.SocksPort = 12345
- #config.ControlPort = 12346
-
- if 'bridge' in args:
- config.UseBridges = 1
- config.Bridge = args['bridge']
- config.save()
- print config.create_torrc()
- report = {'tor_config': config.config}
- log.msg("Starting Tor")
+ log.msg("Tor process connected, bootstrapping ...")
def updates(prog, tag, summary):
log.msg("%d%%: %s" % (prog, summary))
- #return
- d = launch_tor(config, self.reactor, progress_updates=updates)
- d.addCallback(setup_complete)
- d.addErrback(setup_failed)
- return d
+ ## :return: a Deferred which callbacks with a TorProcessProtocol
+ ## connected to the fully-bootstrapped Tor; this has a
+ ## txtorcon.TorControlProtocol instance as .protocol.
+ deferred = launch_tor(config, reactor, progress_updates=updates,
+ tor_binary=self.tor_binary)
+ deferred.addCallback(bootstrap, config)
+ deferred.addErrback(setup_failed)
- def load_assets(self):
- assets = {}
- if self.local_options:
- if self.local_options['bridges']:
- assets.update({'bridge': Asset(self.local_options['bridges'])})
- elif self.local_options['relays']:
- assets.update({'relay': Asset(self.local_options['relays'])})
- return assets
+ #print "Tor process ID: %s" % d.transport.pid
+ return deferred
+
+ def experiment(self, args):
+ """
+ XXX fill me in
+ """
+ log.msg("BridgeT: initiating test ... ")
+
+ def reconfigure_failed(args):
+
+ def reconfigure_controller(proto, args):
+ ## if bridges and relays, use one bridge then build a circuit
+ ## from the relays
+ if args['bridge']:
+ print args
+ print args['bridge']
+ #d.addCallback(CustomCircuit(state))
+ proto.set_conf('Bridge', args['bridge'])
+ ## if bridges only, try one bridge at a time, but don't build
+ ## circuits, just return
+ ## if relays only, build circuits from relays
+
+ ## XXX see txtorcon.TorControlProtocol.add_event_listener
+ ## we may not need full CustomCircuit class
+
+ d = defer.Deferred() ## 1 make deferred
+ d.addCallback(self.bootstrap_tor, self.config) ## 2 blastoff
+ ## 3 reconfigure
+ ## 4 build circuits
+
+ #d = self.bootstrap_tor(self.config, args).addCallback(configure,
+ ##c = CustomCircuit(state)
+ #d.addCallback(configure, d.protocol)
+ #d.addErrback(err)
+ #return d
+
+## So that getPlugins() can register the Test:
+bridget = BridgetTest(None, None, None)
-# We need to instantiate it otherwise getPlugins does not detect it
-# XXX Find a way to load plugins without instantiating them.
-bridget = bridgetTest(None, None, None)
+## ISIS' NOTES
+##
+##
+##
_______________________________________________
tor-commits mailing list
tor-commits@xxxxxxxxxxxxxxxxxxxx
https://lists.torproject.org/cgi-bin/mailman/listinfo/tor-commits