def build_agent(self, proxy, headers):
"""Build an agent for this request
"""
fragments = common.parse_proxy(proxy)
pool = self.build_pool()
if fragments.host:
# add proxy authentication header
auth = base64.b64encode("%s:%s" %
(fragments.username, fragments.password))
headers['Proxy-Authorization'] = ["Basic " + auth.strip()]
# generate the agent
endpoint = endpoints.TCP4ClientEndpoint(
reactor,
fragments.host,
int(fragments.port),
timeout=self.settings.timeout)
agent = client.ProxyAgent(endpoint, reactor=reactor, pool=pool)
else:
agent = client.Agent(reactor,
connectTimeout=self.settings.timeout,
pool=pool)
agent = client.ContentDecoderAgent(agent,
[('gzip', client.GzipDecoder)])
# XXX if use same cookie for all then works...
# cookies usually empty
if proxy in self.cookiejars:
cj = self.cookiejars[proxy]
else:
cj = cookielib.CookieJar()
self.cookiejars[proxy] = cj
agent = client.CookieAgent(agent, cj)
return agent
def __call__(self, req):
serviceUrl = yield self._node_handle._master_proxy.lookupService(self._name)
protocol, rest = serviceUrl.split('://', 1)
host, port_str = rest.rsplit(':', 1)
port = int(port_str)
assert protocol == 'rosrpc'
conn = yield endpoints.TCP4ClientEndpoint(reactor, host, port).connect(util.AutoServerFactory(lambda addr: tcpros.Protocol()))
try:
conn.sendString(tcpros.serialize_dict(dict(
callerid=self._node_handle._name,
service=self._name,
md5sum=self._type._md5sum,
type=self._type._type,
)))
header = tcpros.deserialize_dict((yield conn.receiveString()))
# XXX do something with header
# request could be sent before header is received to reduce latency...
x = StringIO.StringIO()
self._type._request_class.serialize(req, x)
data = x.getvalue()
conn.sendString(data)
result = ord((yield conn.receiveByte()))
data = yield conn.receiveString()
if result: # success
defer.returnValue(self._type._response_class().deserialize(data))
else:
raise ServiceError(data)
finally:
conn.transport.loseConnection()
def run(self): if self.proxy: end_point = endpoints.TCP4ClientEndpoint(reactor, self.proxy[0], self.proxy[1]) self._http_agent = sock.SOCKS5Agent(reactor, proxyEndpoint=end_point) else: self._http_agent = Agent(reactor, connectTimeout = 500) return self._poll()
def setUp(self):
self.remote_helper = None
self.job_counter = 1
self.hook_counter = 1
self.temp_dir_counter = 1
self.pendingJobs = {}
self.pendingProcs = {}
self.pendingLists = {}
self.completedProcs = {} # only holds a jobid -> name map
# assign temporary ports starting from 32768
# FIXME: should be configurable!
self.temp_port = 32768
self.absWorkdir = None
self.tearingDown = False
self.tearDownDeferred = None
factory = SSHClientFactory(self.runner)
endpoint = endpoints.TCP4ClientEndpoint(reactor, self.host.getHost(),
self.host.getPort())
d = endpoint.connect(factory)
d.addCallback(self.startConnection)
self.setupDeferred = defer.Deferred()
return self.setupDeferred
def __init__(self, dp_addr, dr_socket, dst_connected_callback=None):
self.log = logging.getLogger('dr2dp.dr')
self.dr_socket = dr_socket
self.dst_connected_callback = dst_connected_callback
#self.dst_protocol = None
# Connect to the dst (DR2DP_DP)
self.dstFactory = Factory()
self.dstFactory.protocol = DstProtocol
self.dstFactory.dr2dp_dr = self
self.dstFactory.src_protocol = None
endpoint = endpoints.TCP4ClientEndpoint(reactor, dp_addr[0],
dp_addr[1])
d = endpoint.connect(self.dstFactory)
d.addCallback(self.dst_connected)
d.addErrback(self.dst_failed)
# Connect to the src (DR)
self.srcFactory = Factory()
self.srcFactory.protocol = SrcProtocol
self.srcFactory.dr2dp_dr = self
self.srcFactory.dst_protocol = None
# Remove previous instance of socket if it already exists.
if os.path.exists(self.dr_socket):
os.remove(self.dr_socket)
print "starting socket"
endpoint = endpoints.UNIXServerEndpoint(reactor, self.dr_socket)
endpoint.listen(self.srcFactory)
if self.dst_connected_callback:
# Let anyone that wants to know that we've connected to the
# destination and that the unix socket is up and ready
self.dst_connected_callback()
def login(self, _: EventDispatcher, host: "tuple[str, int]",
player: "tuple[int, str]") -> None:
server = endpoints.TCP4ClientEndpoint(reactor, *host)
self.connection = RboCI(*player, Main.handlers)
connecting = server.connect(self.connection)
connecting.addCallbacks(self.registering, self.ioError)
def main(reactor):
tor = yield txtorcon.connect(
reactor,
endpoints.TCP4ClientEndpoint(reactor, "localhost", 9251),
)
ep = tor.create_authenticated_onion_endpoint(
80,
auth=AuthBasic([
("alice", "0GaFhnbunp0TxZuBhejhxg"),
"bob",
]),
)
def on_progress(percent, tag, msg):
print('%03d: %s' % (percent, msg))
txtorcon.IProgressProvider(ep).add_progress_listener(on_progress)
print("Note: descriptor upload can take several minutes")
port = yield ep.listen(server.Site(Simple()))
print("Private key:\n{}".format(port.getHost().onion_key))
hs = port.onion_service
print("Clients:")
for name in hs.client_names():
print(
" {}: username={} token={}".format(
hs.get_client(name).hostname, name,
hs.get_client(name).auth_token), )
print("hs {}".format(hs))
print(type(hs))
print(dir(hs))
yield defer.Deferred() # wait forever
def connectV4(self, peer, host, port):
factory = TwistedClientFactory(peer)
endpoint = endpoints.TCP4ClientEndpoint(reactor, host, port)
print("Connecting to %s:%d" % (host, port))
d = endpoint.connect(factory)
d.addErrback(factory.failure, endpoint)
pass
def __init__(self, *args, **kwargs):
self.proxy_username = None
if "proxy_host" in kwargs:
port = 80
if "proxy_port" in kwargs:
port = kwargs["proxy_port"]
del kwargs["proxy_port"]
if "proxy_username" in kwargs:
self.proxy_username = kwargs["proxy_username"]
del kwargs["proxy_username"]
if "proxy_password" in kwargs:
self.proxy_password = kwargs["proxy_password"]
del kwargs["proxy_password"]
endpoint = endpoints.TCP4ClientEndpoint(reactor,
kwargs["proxy_host"], port)
self.agent = client.ProxyAgent(endpoint)
del kwargs["proxy_host"]
else:
from twisted.web import version as twisted_version
if twisted_version.major < 14:
# FIXME: for Ubuntu 12.04 Twisted 11? (until 2017/04)
self.agent = client.Agent(reactor)
else:
contextFactory = WebClientContextFactory()
self.agent = client.Agent(reactor, contextFactory)
Twitter.__init__(self, *args, **kwargs)
def main_loop():
while True:
fname = input('* enter file name or q[uit]: ')
if not fname:
fname = __file__
if 'quit'.startswith(fname.strip().lower()):
reactor.stop()
break
global the_file
the_file = fname
if not os.path.exists(the_file):
LOG.info('\tfile not found {}'.format(the_file))
continue
with open(fname, 'br') as f:
buffer = f.read()
try:
LOG.info('\tsending {} ...'.format(fname))
if not options.twisted:
yield defer.maybeDeferred(sockSend,
options.server,
options.port,
buffer,
verbose=True,
serialize=True,
compress=not options.nocompress)
else:
point = endpoints.TCP4ClientEndpoint(
reactor, options.server, options.port)
yield point.connect(SendStreamFactory(buffer))
except Exception as x:
LOG.error('Exception: {}'.format(x))
def endpoint(self, scheme, host, port):
ep = None
if scheme == 'http':
ep = endpoints.TCP4ClientEndpoint(reactor, host, port)
elif scheme == 'https':
ep = endpoints.SSL4ClientEndpoint(reactor, host, port, context)
return ep
def test_daphn3(self):
host = self.localOptions['host']
port = int(self.localOptions['port'])
def failure(failure):
log.msg("Failed to connect")
self.report['censored'] = True
self.report['mutation'] = 0
raise Exception("Error in connection, perhaps the backend is censored")
return
def success(protocol):
log.msg("Successfully connected")
protocol.sendPayload()
return protocol.d
log.msg("Connecting to %s:%s" % (host, port))
endpoint = endpoints.TCP4ClientEndpoint(reactor, host, port)
daphn3_factory = Daphn3ClientFactory()
daphn3_factory.steps = self.input
daphn3_factory.report = self.report
d = endpoint.connect(daphn3_factory)
d.addErrback(failure)
d.addCallback(success)
return d
def main(reactor):
# For the "single_hop=True" below to work, the Tor we're
# connecting to must have the following options set:
# SocksPort 0
# HiddenServiceSingleHopMode 1
# HiddenServiceNonAnonymousMode 1
tor = yield txtorcon.connect(
reactor,
endpoints.TCP4ClientEndpoint(reactor, "localhost", 9351),
)
if False:
ep = tor.create_onion_endpoint(
80,
version=3,
single_hop=True,
)
else:
ep = endpoints.serverFromString(reactor, "onion:80:version=3:singleHop=true")
def on_progress(percent, tag, msg):
print('%03d: %s' % (percent, msg))
txtorcon.IProgressProvider(ep).add_progress_listener(on_progress)
port = yield ep.listen(server.Site(Simple()))
print("Private key:\n{}".format(port.getHost().onion_key))
hs = port.onion_service
print("Site on http://{}".format(hs.hostname))
yield defer.Deferred() # wait forever
def sockswrapper(self, proxy, url):
dest = urlparse(url)
assert dest.port is not None, 'Must specify port number.'
endpoint = endpoints.TCP4ClientEndpoint(reactor, dest.hostname,
dest.port)
return SOCKSWrapper(reactor, proxy[1], proxy[2], endpoint,
self.timestamps)
def __init__(self, addr, client_connected_callback=None):
# check that the host name obeys RFC 1123
label = '[a-zA-Z0-9-]*[a-zA-Z0-9]'
if ((len(addr[0]) > 255)
or (not re.match('^(%s\.)*(%s)$' % (label, label), addr[0]))):
print >> sys.stderr, 'ERROR: bad hostname [%s]' % addr[0]
return
# input parameters
self.addr = addr
self.client_connected_callback = client_connected_callback
# instance of client protocol, after successful connection
self.client_protocol = None
# callback to use when response received from remora server
self.response_callback = None
self.client = Factory()
self.client.protocol = RemoraClientProtocol
self.client.remora = self
# connect to remora server
endpoint = endpoints.TCP4ClientEndpoint(reactor, addr[0], addr[1])
d = endpoint.connect(self.client)
d.addErrback(self.connection_failed)
def connectDst(self):
dst_endpoint = endpoints.TCP4ClientEndpoint(reactor,
self.dst_addr[0],
self.dst_addr[1],
timeout=1)
d = dst_endpoint.connect(self.dstFactory)
d.addErrback(self.dstConnectionFailed)
def new_connection(self):
"""return a new connection."""
d = Deferred()
proto = CryptarchiveClientProtocol(self._username, self._password, d=d)
ep = endpoints.TCP4ClientEndpoint(self.reactor, self._host, self._port)
endpoints.connectProtocol(ep, proto)
cp = yield d
returnValue(cp)
def sockswrapper(proxy, dest, ssl=False):
endpoint = endpoints.TCP4ClientEndpoint(reactor, dest[0], dest[1])
print "Connecting:", dest
return socksclient.SOCKSWrapper(reactor,
proxy[0],
proxy[1],
endpoint,
ssl=ssl)
def xmlrpc_createConnection(self, cid):
self.proxy.timeStamp.incrementClock(self.proxy.serverId)
host, port, _ = config.ADDR_PORT[str(cid)]
if cid in self.proxy.factory.peers: return 0
point = endpoints.TCP4ClientEndpoint(reactor, host, port + 500)
d = point.connect(self.proxy.factory)
d.addCallback(self.proxy.greeting, cid)
return 0
def setUp(self):
params = self.clientParams()
self.endpoint = endpoints.TCP4ClientEndpoint(reactor, "localhost", 5672)
self.factory = amqp.AMQPFactory(**params)
self.client = amqp.AMQPService(self.endpoint, self.factory, **params)
self.client.startService()
yield sleep(1)
def endpoint(self, scheme, host, port):
ep = None
if scheme == 'http':
ep = endpoints.TCP4ClientEndpoint(reactor, host, port)
elif scheme == 'https':
from twisted.internet import ssl
ep = endpoints.SSL4ClientEndpoint(reactor, host, port,
ssl.ClientContextFactory())
return ep
def test_main():
server = TestServer(('', 4000))
clientFactory = Factory()
clientFactory.protocol = Protocol
endpoint = endpoints.TCP4ClientEndpoint(reactor, '127.0.0.1', 4000)
d = endpoint.connect(clientFactory)
d.addCallback(client_connected)
reactor.run()
def make_client(listening_port):
addr = listening_port.getHost()
self.agent = client.ProxyAgent(
endpoints.TCP4ClientEndpoint(
self.reactor,
addr.host,
addr.port,
),
self.reactor,
)
def main(reactor):
endpoint = endpoints.TCP4ClientEndpoint(reactor, "127.0.0.1", 8001)
prot = yield endpoint.connect(protocol.Factory.forProtocol(amp.AMP))
res1 = yield prot.callRemote(twisted_book_configure.GetCapitalize)
res2 = yield prot.callRemote(twisted_book_configure.GetExclaim)
print(res1['value'], res2['value'])
yield prot.callRemote(twisted_book_configure.SetCapitalize, value=0.5)
yield prot.callRemote(twisted_book_configure.SetExclaim, value=0.5)
res1 = yield prot.callRemote(twisted_book_configure.GetCapitalize)
res2 = yield prot.callRemote(twisted_book_configure.GetExclaim)
print(res1['value'], res2['value'])
def main(reactor):
# a simple Web site; could be any other listening service of course
res = resource.Resource()
res.putChild(
b'',
static.Data("<html>Hello, onion-service world!</html>", 'text/html'))
def on_progress(percent, tag, msg):
print('%03d: %s' % (percent, msg))
# We are using launch() here instead of connect() because
# filesystem services are very picky about the permissions and
# ownership of the directories involved. If you *do* want to
# connect to e.g. a system service or Tor Browser Bundle, it's way
# more likely to work to use Ephemeral services
tor = yield txtorcon.connect(
reactor,
endpoints.TCP4ClientEndpoint(reactor, "localhost",
txtorcon.util.default_control_port()),
)
# NOTE: you should put these somewhere you've thought about more
# and made proper permissions for the parent directory, etc. A
# good choice for a system-wide Tor is /var/lib/tor/<whatever>
# The parent directory must be mode 700
os.mkdir("hs_parent")
os.chmod("hs_parent", 0o700)
hs_dir = './hs_parent/hs_dir'
print("Creating stealth-authenticated hidden-service, keys in: {}".format(
hs_dir))
ep = tor.create_authenticated_filesystem_onion_endpoint(
80,
hs_dir=hs_dir,
auth=txtorcon.AuthStealth(['alice', 'bob']),
group_readable=True,
)
print("Note: descriptor upload can take several minutes")
txtorcon.IProgressProvider(ep).add_progress_listener(on_progress)
port = yield ep.listen(server.Site(res))
hs = port.getHost().onion_service
for name in hs.client_names():
client = hs.get_client(name)
print(" {}: {}".format(name, client.hostname))
print(" auth token: {}".format(client.auth_token))
print(" private key: {}..".format(client.private_key[:40]))
print(" HidServAuth {} {}".format(client.hostname,
client.auth_token))
yield tor.protocol.on_disconnect
print("disconnected")
def _publisher_thread(self, url):
while True:
try:
proxy = rosxmlrpc.Proxy(xmlrpc.Proxy(url),
self._node_handle._name)
value = yield proxy.requestTopic(self._name, [['TCPROS']])
protocol, host, port = value
conn = yield endpoints.TCP4ClientEndpoint(
reactor, host, port).connect(
util.AutoServerFactory(lambda addr: tcpros.Protocol()))
try:
conn.sendString(
tcpros.serialize_dict(
dict(
message_definition=self._type._full_text,
callerid=self._node_handle._name,
topic=self._name,
md5sum=self._type._md5sum,
type=self._type._type,
)))
header = tcpros.deserialize_dict((yield
conn.receiveString()))
self._connections[conn] = header.get('callerid', None)
try:
while True:
data = yield conn.receiveString()
msg = self._type().deserialize(data)
try:
self._callback(msg)
except:
traceback.print_exc()
self._last_message = msg
self._last_message_time = self._node_handle.get_time(
)
old, self._message_dfs = self._message_dfs, []
for df in old:
df.callback(msg)
finally:
del self._connections[conn]
finally:
conn.transport.loseConnection()
except (error.ConnectionDone, error.ConnectionLost,
error.ConnectionRefusedError):
pass
except Exception:
traceback.print_exc()
yield util.wall_sleep(
1
) # pause so that we don't repeatedly reconnect immediately on failure
def connectDst(self):
"""
Create connection to the VPN server.
"""
print "Connecting VPN"
print "ipaddr %s port %s" % (self._vpn_ipaddr, self._vpn_port)
endpoint = endpoints.TCP4ClientEndpoint(reactor,
self._vpn_ipaddr, self._vpn_port, timeout=1)
connection = endpoint.connect(self.dstFactory)
connection.addErrback(self.dstConnectionFailed)
def connectionMade(self):
"""
We've connected to a src. Make a connection to the dst (CCP).
"""
dstFactory = Factory()
dstFactory.protocol = DstProtocol
dstFactory.src_protocol = self
endpoint = endpoints.TCP4ClientEndpoint(reactor,
self.factory.dstaddr[0],
self.factory.dstaddr[1])
d = endpoint.connect(dstFactory)
d.addCallback(self.dstConnected)
def _sendCommands(self, commands):
def gotProtocol(proto):
log.msg('Telnet protocol created', debug=True, system=LOG_SYSTEM)
d = proto.sendCommands(commands)
return d
log.msg('Creating telnet connection', debug=True, system=LOG_SYSTEM)
factory = TelnetFactory(self.username, self.password)
point = endpoints.TCP4ClientEndpoint(reactor, self.host, self.port)
d = point.connect(factory)
d.addCallback(gotProtocol)
return d
def _create_tcp_connection(self):
def host_verified(proto):
return proto
def got_protocol(proto):
proto.connection_secure_d.addCallback(host_verified)
return proto.connection_secure_d
factory = SSHClientFactory(self.fingerprint)
endpoint = endpoints.TCP4ClientEndpoint(reactor, self.host, self.port)
d = endpoint.connect(factory)
d.addCallback(got_protocol)
return d