commit a0688866101db87c5e4692dd8523c3c338efbcb5
Author: Quinn Jarrell <qjarrell(a)gosynapsify.com>
Date: Mon Jun 2 15:30:46 2014 -0400
Added a configuration class which reads in a fog-file. Added example fog-file. Added launching from a fog-file.
---
example-fog-config | 13 ++++
obfs-flash-client | 206 +++++++++++++++++++++++++++++++++++++++++-----------
2 files changed, 178 insertions(+), 41 deletions(-)
diff --git a/example-fog-config b/example-fog-config
new file mode 100644
index 0000000..746e5ad
--- /dev/null
+++ b/example-fog-config
@@ -0,0 +1,13 @@
+#Based off of ticket #9744
+#Client transports are setup like so:
+#ClientTransportPlugin name commandline
+#For instance to launch obfs3, the client transport line should be this
+#ClientTransportPlugin obfs3 obfsproxy managed
+#
+#For chaining transports together, an alias line is used.
+#Alias chainname firsttransportname|secondtransportname
+#tor expects alias to use underscores instead of pipes. So an alias links the tor version of a plugin chain to the actual plugins. See ticket #9580
+
+ClientTransportPlugin dummy obfsproxy managed
+ClientTransportPlugin b64 obfsproxy managed
+Alias dummy_b64 dummy|b64
diff --git a/obfs-flash-client b/obfs-flash-client
index 32c0c9c..cc45d40 100755
--- a/obfs-flash-client
+++ b/obfs-flash-client
@@ -25,7 +25,10 @@ from twisted.protocols.portforward import ProxyServer as _ProxyServer
from twisted.python import log
from txsocksx.client import SOCKS4ClientEndpoint
-PT_METHOD_NAME = "obfs3_flashproxy"
+import shlex
+
+import logging
+
def pt_child_env(managed_ver, env=os.environ):
"""
@@ -38,7 +41,7 @@ def pt_child_env(managed_ver, env=os.environ):
cur_env.append(('TOR_PT_MANAGED_TRANSPORT_VER', ','.join(managed_ver)))
return cur_env
-class CMethod(namedtuple('MethodSpec', 'name protocol addrport args opts')):
+class MethodSpec(namedtuple('MethodSpec', 'name protocol addrport args opts')):
@classmethod
def fromLine(cls, line):
args = line.rstrip('\n').split(' ')
@@ -47,7 +50,7 @@ class CMethod(namedtuple('MethodSpec', 'name protocol addrport args opts')):
addrport = parse_addr_spec(args[2])
args = args[3][-5:].split(',') if len(args) > 3 and args[3].startswith("ARGS=") else []
opts = args[4][-9:].split(',') if len(args) > 4 and args[4].startswith("OPT-ARGS=") else []
- return CMethod(name, protocol, addrport, args, opts)
+ return MethodSpec(name, protocol, addrport, args, opts)
def branch(parent):
"""
@@ -103,7 +106,7 @@ class ManagedTransportProtocolV1(LineReceiver):
if version != self.protocol_version:
self._abort(ValueError("child used unsupported managed transport version: %s" % version))
elif kw == "CMETHOD":
- cmethod = CMethod.fromLine(args)
+ cmethod = MethodSpec.fromLine(args)
self.cmethods[cmethod.name] = cmethod
elif kw == "CMETHODS" and args == "DONE":
self._fireCMethodsDone().callback(self.cmethods)
@@ -218,99 +221,220 @@ if sys.platform == "win32":
self.proto.makeConnection(self)
-def pt_launch_child(reactor, client, methodnames, cmdline):
+def pt_launch_child(reactor, client, methodnames, pt_method_name, cmdline):
"""Launch a child PT and ensure it has the right transport methods."""
cur_env = pt_child_env(ManagedTransportProtocolV1.protocol_version)
+ environment = dict(cur_env + {
+ "TOR_PT_CLIENT_TRANSPORTS": ",".join(methodnames),
+ }.items())
sub_proc = Popen(cmdline,
stdout = PIPE,
- env = dict(cur_env + {
- "TOR_PT_CLIENT_TRANSPORTS": ",".join(methodnames),
- }.items()),
+ env = environment,
)
sub_protocol = ManagedTransportProtocolV1()
# we ought to pass reactor=reactor in below, but this breaks Twisted 12
StandardIO(sub_protocol, stdin=sub_proc.stdout.fileno())
methoddefers = [sub_protocol.whenCMethodsDone().addCallback(
- partial(pt_require_child, client, name))
+ partial(pt_require_child, client, name, pt_method_name))
for name in methodnames]
return sub_proc, sub_protocol, methoddefers
-def pt_require_child(client, childmethod, cmethods):
+def pt_require_child(client, childmethod, pt_method_name, cmethods):
"""Callback for checking a child PT has the right transport methods."""
if childmethod not in cmethods:
- client.reportMethodError(PT_METHOD_NAME, "failed to start required child transport: %s" % childmethod)
+ client.reportMethodError(pt_method_name, "failed to start required child transport: %s" % childmethod)
raise ValueError()
return cmethods[childmethod]
-def obfs3_flashproxy(reactor, client, obfs_out, fp_remote, fp_args=[], fp_local=0):
+def pt_launch_pair(reactor, client, callback_port, configuration, pt_method_name):
"""
- Set up the obfs3_flashproxy combined PT.
-
+ Launches a pair of pluggable transports. Currently only supports chaining two transports together.
+ The pair is set by pt_method_names
:param twisted.internet.interfaces.IReactor reactor: Reactor to install this PT to.
:param pyptlib.client.ClientTransportPlugin client: PT client API.
- :param int obfs_out: Local listen port for obfsproxy to connect to.
- :param str fp_remote: Listen address for remote flashproxy connections.
- :param int fp_local: Local listen port for local flashproxy connections.
+ :param int callback_port: Local listen port for the first PT to connect to.
+ :param Config configuration: The configuration structure for this pair.
+ :param String pt_method_name: The name of the pt chain to launch. Ex: "obfs3_flashproxy"
"""
- ob_client = os.getenv("OBFSPROXY", "obfsproxy")
- fp_client = os.getenv("FLASHPROXY_CLIENT", "flashproxy-client")
+ #TODO Modify pt_launch_pair to launch more than 2 transports
+
+ if pt_method_name in configuration.alias_map:
+ pt_chain = configuration.alias_map[pt_method_name]
+ else:
+ logging.error('Pluggable Transport Combination %s not found in configuration alias map.' % pt_method_name)
+ raise KeyError()
- # start fp and ensure that it launches OK
- _, _, fp_defer = pt_launch_child(reactor, client,
- ["flashproxy"], [fp_client, "--transport", "obfs3|websocket"] + fp_args +
- ['127.0.0.1:%s' % fp_local, fp_remote])
+ defer_list = []
- # start ob and ensure that it launches OK
- _, _, ob_defer = pt_launch_child(reactor, client,
- ["obfs3"], [ob_client, "managed"])
+ for pt in pt_chain:
+ if pt in configuration.transport_map:
+ pt_cmdline = configuration.transport_map[pt]
+ else:
+ logging.error("Pluggable transport %s not found in transport_map. Check your configuration file." % str(pt))
+ raise ValueError()
+ _, _, defer = pt_launch_child(reactor, client, [pt], pt_method_name, pt_cmdline)
+ defer_list.extend(defer)
+ whenAllDone = DeferredList(defer_list, consumeErrors=False)
- whenAllDone = DeferredList(fp_defer + ob_defer, consumeErrors=True)
def allDone(success_list):
- success = all(r[0] for r in success_list)
+ """
+ :param success_list: A list of tuples containing a launch status boolean, MethodSpec pairs.
+ Ex: [(True, MethodSpec(name='dummy', protocol='socks4', addrport=('127.0.0.1', 58982), args=[], opts=[])),
+ (True, MethodSpec(name='b64', protocol='socks4', addrport=('127.0.0.1', 58981), args=[], opts=[]))]
+ """
+
+ success = all(r[0] for r in success_list if r[1].name in pt_chain)
# failure was already reported by pt_require_child, just return
if not success: return
- fp_result = [r[1] for r in success_list if r[1].name == "flashproxy"][0]
- ob_result = [r[1] for r in success_list if r[1].name == "obfs3"][0]
- fp_port = fp_result.addrport[1] # if port was 0, read the actual port
+ result1 = [r[1] for r in success_list if r[1].name == pt_chain[0]][0] # Normally obfs3 result
+ result2 = [r[1] for r in success_list if r[1].name == pt_chain[1]][0] # Normally flashproxy result
+ destination_port = result2.addrport[1] # if port was 0, read the actual port
# shim to wrap obfs data output to SOCKS input for flashproxy
- reactor.listenTCP(interface='127.0.0.1', port=obfs_out, factory=
- SOCKS4WrapperFactory('127.0.0.1', fp_port, '0.0.1.0', 1))
-
+ reactor.listenTCP(interface='127.0.0.1', port=callback_port, factory=
+ SOCKS4WrapperFactory('127.0.0.1', destination_port, '0.0.1.0', 1))
# now report success of the overall composed PT
- client.reportMethodSuccess(PT_METHOD_NAME, ob_result.protocol, ob_result.addrport)
+ client.reportMethodSuccess(pt_method_name, result1.protocol, result1.addrport)
client.reportMethodsEnd()
whenAllDone.addCallback(allDone)
+class Config():
+ # Transport map links a pluggable transport name to the a commandline to launch it.
+ # Ex: {'b64' : 'exec obfsproxy managed'}
+ transport_map = None
+
+ #Alias map links a pluggable transport chain name to a list of individual pluggable transports
+ # Ex: {'dummy_b64_dummy2' : ['dummy''b64''dummy2']}
+ alias_map = None
+
+ def __init__(self, transport_map, alias_map):
+ self.transport_map = transport_map
+ self.alias_map = alias_map
+
+ def __repr__(self):
+ return "Config(%s, %s)" % (self.transport_map, self.alias_map)
+
+ def __str__(self):
+ return "Config Object with transport_map: %s, and alias_map %s." % (self.transport_map, self.alias_map)
+
+ @classmethod
+ def parse(cls, config_string):
+ """
+ Reads a configuration string and returns an instance of configuration. Uses shlex to parse configuration lines.
+ :param String config_string: The string which will be parsed to populate the transport_map and alias_map hash tables.
+ See the file example-fog-config for format.
+ """
+ # TODO Add possibility of reading a ClientTransportPlugin with multiple transport types
+ # Ex: ClientTransportPlugin obfs3,scramblesuit obfsclient --option=value
+
+ line_counter = 0
+ lines = config_string.split('\n')
+ transport_map = {}
+ alias_map = {}
+
+ for line in lines:
+ line_counter += 1
+ if len(line) > 0 and line[0] != '#' : # Check for empty lines and comment tags on the first
+ line = line.strip()
+ delimited_tokens = shlex.split(line)
+ if len(delimited_tokens) > 1:
+ config_line_type = delimited_tokens[0] # This can be either Alias or ClientTransportPlugin
+ if config_line_type == 'ClientTransportPlugin':
+ cls.parse_transport_line(transport_map, delimited_tokens, line_counter)
+ elif config_line_type == 'Alias':
+ cls.parse_alias_line(alias_map, transport_map, delimited_tokens, line_counter)
+ else:
+ logging.warn("Configuration file has unknown line %s: '%s'" % (line_counter, line))
+ return cls(transport_map, alias_map)
+
+ @classmethod
+ def parse_transport_line(cls, transport_map, delimited_tokens, line_counter):
+ transport_name = delimited_tokens[1]
+ transport_cmdline = delimited_tokens[2:]
+ if transport_name in transport_map:
+ raise ValueError('Configuration file has duplicate ClientTransportPlugin lines. Duplicate line is at line number %s' % line_counter)
+ transport_map[transport_name] = transport_cmdline
+
+ @classmethod
+ def parse_alias_line(cls, alias_map, transport_map, delimited_tokens, line_counter):
+ alias_name = delimited_tokens[1] # Example: "obfs3_flashproxy"
+ alias_path = delimited_tokens[2].split('|') # Example: "obfs3|flashproxy"
+ if alias_name in alias_map:
+ raise ValueError('Configuration file has duplicate Alias lines. Duplicate line is at line number %s' % line_counter)
+ for pt_name in alias_path:
+ if pt_name not in transport_map:
+ raise KeyError('Transport map is missing pluggable transport %s needed for chain %s. Check your configuration file for a ClientTransportPlugin line can launch %s' % (pt_name, alias_name, pt_name))
+ alias_map[alias_name] = alias_path
+
+def obfs3_flashproxy(reactor, client, callback_port, fp_remote, fp_args=[], fp_local=0):
+ """
+ Set up the obfs3_flashproxy combined PT.
+
+ :param twisted.internet.interfaces.IReactor reactor: Reactor to install this PT to.
+ :param pyptlib.client.ClientTransportPlugin client: PT client API.
+ :param int callback_port: Local listen port for obfsproxy to connect to.
+ :param str fp_remote: Listen address for remote flashproxy connections.
+ :param int fp_local: Local listen port for local flashproxy connections.
+ """
+
+ ob_client = os.getenv("OBFSPROXY", "obfsproxy")
+ fp_client = os.getenv("FLASHPROXY_CLIENT", "flashproxy-client")
+
+ fp_cmdline = [fp_client, "--transport", '"obfs3|websocket"'] + fp_args + ['127.0.0.1:%s' % fp_local, fp_remote]
+ obfs_cmd_line = [ob_client, "managed"]
+
+ transport_map = {'obfs3': obfs_cmd_line, 'flashproxy': fp_cmdline}
+ alias_map = {'obfs3_flashproxy': ['obfs3', 'flashproxy']}
+
+ configuration = Config(transport_map, alias_map)
+ pt_launch_pair(reactor, client, callback_port, configuration, "obfs3_flashproxy") # Launch
+
def main(*args):
parser = argparse.ArgumentParser()
- parser.add_argument("obfs_out", help="local listen port for obfsproxy to "
- "connect to. This must match the appropriate 'Bridge %s' line in your "
- "torrc." % PT_METHOD_NAME,
+ parser.add_argument("callback_port", help="local listen port for obfsproxy to "
+ "connect to. This must match the appropriate bridge line in your " # TODO print bridge line
+ "torrc.",
metavar='PORT', type=int)
parser.add_argument("fp_remote", help="remote connections listen address "
"for flashproxy, default %(default)s",
metavar='REMOTE:PORT', nargs='?', default=":9000")
parser.add_argument("--fp-arg", help="arguments for flashproxy-client",
metavar='ARG', action='append')
+ parser.add_argument("-f", help="fog configuration file path",
+ metavar='FOGFILE', type=argparse.FileType('r'))
+
# TODO(infinity0): add an "external" mode, which would require us to run
# obfsproxy in external mode too.
opts = parser.parse_args(args)
+
# ensure str address is valid
_, _, = parse_addr_spec(opts.fp_remote, defhost="0.0.0.0")
+ configuration = None
+
+ if opts.f:
+ file_contents = opts.f.read()
+ configuration = Config.parse(file_contents)
+ pt_method_names = configuration.alias_map.keys()
client = ClientTransportPlugin()
- client.init([PT_METHOD_NAME])
+ client.init(pt_method_names) # Initialize our possible methods to all the chains listed by the fog file and stored in alias map.
if not client.getTransports():
- print >> sys.stderr, "no transports to serve"
+ logging.error("no transports to serve. pt_method_names may be invalid.")
return 1
from twisted.internet import reactor
auto_killall(1, cleanup=reactor.stop)
- obfs3_flashproxy(reactor, client, opts.obfs_out, opts.fp_remote, opts.fp_arg or [])
+ #TODO Change from launching a single pair to launching multiple chains.
+ if configuration:
+ pt_launch_pair(reactor, client, opts.callback_port, configuration, pt_method_names[0])
+ else:
+ logging.warn("No configuration file specified. Defaulting to launching obfs|flashproxy pair.")
+ obfs3_flashproxy(reactor, client, opts.callback_port, opts.fp_remote, opts.fp_arg or [])
+
reactor.run(installSignalHandlers=0)
return 0
if __name__ == "__main__":
sys.exit(main(*sys.argv[1:]))
+
