def kill_all_processes(processes_to_kill):
for p in processes_to_kill:
try:
if p.poll() is None:
logger.debug('killing process %s' % p.pid)
osinteraction.getInstance().kill_pid(p.pid)
p.wait()
except Exception as e:
logger.exception(e)
def setUp(self):
print self._testMethodName
self.os_interaction = getInstance()
set_log_level(logging.DEBUG)
self.app = OpenportApp()
self.os_interaction = osinteraction.getInstance()
self.test_db = os.path.join(os.path.dirname(__file__), 'testfiles',
'tmp', 'db_test.db')
try:
os.remove(self.test_db)
except:
pass
self.stop_port_forward = False
def get_default_key_locations():
app_data_path = osinteraction.getInstance().get_app_data_path()
log.debug('app_data_path: %s' % app_data_path)
private_key_file = os.path.join(app_data_path, 'id_rsa')
public_key_file = os.path.join(app_data_path, 'id_rsa.pub')
return public_key_file, private_key_file
def run(self, timeout):
def target():
#print 'Thread started'
command = self.cmd
if osinteraction.is_windows():
command = ' '.join(['"%s"' % arg for arg in self.cmd])
self.process = subprocess.Popen(
command,
stderr=subprocess.PIPE,
stdout=subprocess.PIPE,
shell=osinteraction.is_windows(),
close_fds=not osinteraction.is_windows())
self.process.wait()
#self.process.communicate()
#print 'Thread finished'
thread = threading.Thread(target=target)
thread.start()
thread.join(timeout)
if thread.is_alive():
print 'Terminating process'
self.process.terminate()
thread.join()
print self.process.returncode
return osinteraction.getInstance().get_output(self.process)
def get_and_save_random_manager_port(self):
config = ConfigFileHandler(self.config.config)
manager_port = osinteraction.getInstance().get_open_port()
# manager_port = 22
self.config.manager_port = manager_port
config.set('manager', 'port', str(manager_port))
self.config.manager_port_from_config_file = True
return manager_port
def set_manager_port(self, command):
os_interaction = osinteraction.getInstance()
if self.config.manager_port_from_config_file:
command = os_interaction.unset_variable(command, '--listener-port')
elif self.config.manager_port > 0:
command = os_interaction.set_variable(command, '--listener-port',
self.config.manager_port)
return command
def start_openport_process_from_session(self, session, database=''):
command = self.get_restart_command(session, database=database)
logger.debug(command)
session.restart_command = command
os_interaction = osinteraction.getInstance()
full_command = os_interaction.get_full_restart_command(session)
p = os_interaction.start_process(full_command)
return p
def __init__(self):
self.account_id = -1
self.key_id = -1
self.openport_address = DEFAULT_SERVER
self.manager_port = -1
self.manager_port_from_config_file = False
self.config = osinteraction.getInstance().get_app_data_path(
'openport.cfg')
self.contact_manager = True
self.verbose = False
self.tcp_listeners = set()
self.app = None
def setUp(self):
print self._testMethodName
set_log_level(logging.DEBUG)
self.server = "https://test2.openport.io"
#self.server = "http://localhost:8000"
if os.path.exists('/usr/bin/phantomjs'):
self.browser = webdriver.PhantomJS('/usr/bin/phantomjs')
else:
self.browser = webdriver.PhantomJS('/usr/local/bin/phantomjs')
self.browser.set_window_size(1124, 850)
#self.browser = webdriver.Firefox()
#self.browser = webdriver.Chrome('/usr/local/bin/chromedriver')
self.processes_to_kill = []
self.os_interaction = osinteraction.getInstance()
def __init__(self, db_location=None, init_db=True, echo_queries=False):
self.osinteraction = osinteraction.getInstance()
if not db_location:
db_location = self.osinteraction.get_app_data_path('openport.db')
db_exists = os.path.exists(db_location)
logger.debug('db location: %s' % db_location)
self.engine = create_engine('sqlite:///%s' % db_location,
echo=echo_queries)
self.db_location = db_location
self.session_factory = sessionmaker(bind=self.engine)
logger.debug('db location: %s' % db_location)
self.Session = scoped_session(self.session_factory)
if init_db:
self.init_db(db_exists)
def __init__(self, parent):
super(OpenPortItTaskBarIcon, self).__init__()
self.frame = parent
self.parentApp = parent
self.os_interaction = osinteraction.getInstance()
if osinteraction.is_mac():
icon_file = self.os_interaction.get_resource_path(
'resources/icon.icns')
self.icon = wx.Icon(icon_file, wx.BITMAP_TYPE_ICON)
else:
icon_file = self.os_interaction.get_resource_path(
'resources/icon.ico')
self.icon = wx.Icon(icon_file, wx.BITMAP_TYPE_ICO)
self.SetIcon(self.icon, "Openport")
self.imgidx = 1
# self.CreateMenu()
self.items = []
def check_username_in_config_file(self):
if not osinteraction.is_windows():
if osinteraction.getInstance().user_is_root():
return
if not os.path.exists(USER_CONFIG_FILE):
logger.warning(
'The file %s does not exist. Your sessions will not be automatically restarted '
'on reboot. You can restart your session with "openport --restart-shares"'
% USER_CONFIG_FILE)
return
username = self.os_interaction.get_username()
with open(USER_CONFIG_FILE, 'r') as f:
lines = [l.strip() for l in f.readlines()]
if username not in lines:
logger.warning(
'Your username (%s) is not in %s. Your sessions will not be automatically restarted '
'on reboot. You can restart your session with "openport --restart-shares"'
% (username, USER_CONFIG_FILE))
return
def __init__(self,
parent=None,
id=-1,
title='Openport - Easy and secure reverse SSH',
wx_app=None,
db_location=''):
wx.Frame.__init__(self,
parent,
-1,
title,
style=wx.DEFAULT_FRAME_STYLE
| wx.NO_FULL_REPAINT_ON_RESIZE)
self.wx_app = wx_app
self.addMenuBar()
self.rebuild()
self.Bind(wx.EVT_CLOSE, self.onClose)
self.os_interaction = osinteraction.getInstance()
self.config = OpenportAppConfig()
self.config.app = self
self.config_service = ConfigService(self.config)
self.app_service = AppService(self.config)
self.db_location = db_location
self.db_handler = DBHandler(db_location)
port = self.config_service.get_and_save_manager_port()
self.server = GUITcpServer('127.0.0.1', port, self.config,
self.db_handler)
if osinteraction.is_mac():
icon_file = self.os_interaction.get_resource_path(
'resources/icon.icns')
icon = wx.Icon(icon_file, wx.BITMAP_TYPE_ICON)
else:
icon_file = self.os_interaction.get_resource_path(
'resources/icon.ico')
icon = wx.Icon(icon_file, wx.BITMAP_TYPE_ICO)
self.SetIcon(icon)
self.addTrayIcon()
def get_logger(name):
if name in loggers:
return loggers[name]
logger = logging.getLogger(name)
ch = logging.StreamHandler(stdout)
ch.setFormatter(short_formatter)
ch.setLevel(log_level)
logger.addHandler(ch)
os_interaction = osinteraction.getInstance(use_logger=False)
fh = logging.handlers.RotatingFileHandler(os_interaction.get_app_data_path(
'%s.log' % os_interaction.get_app_name()),
maxBytes=1000000,
backupCount=5)
fh.setFormatter(long_formatter)
fh.setLevel(logging.DEBUG)
logger.addHandler(fh)
logger.setLevel(logging.DEBUG)
loggers[name] = logger
return logger
def __init__(self):
self.config = OpenportAppConfig()
self.config.app = self
self.manager_app_started = False
self.os_interaction = osinteraction.getInstance()
self.args = {}
self.session = None
self.openport = Openport()
self.db_handler = None
self.server = AppTcpServer('127.0.0.1',
self.os_interaction.get_open_port(),
self.config, self.db_handler)
self.config_service = ConfigService(self.config)
self.app_service = AppService(self.config)
self.argument_parser = argparse.ArgumentParser()
if self.os_interaction.is_compiled():
from openport.common.tee import TeeStdErr, TeeStdOut
TeeStdOut(
self.os_interaction.get_app_data_path('openport_app.out.log'),
'a')
TeeStdErr(
self.os_interaction.get_app_data_path(
'openport_app.error.log'), 'a')
try:
if not osinteraction.is_windows():
signal.signal(signal.SIGINT, self.handleSigTERM)
signal.signal(signal.SIGTERM, self.handleSigTERM)
else:
# To be honest, I don't think this does anything...
signal.signal(signal.SIGINT, self.handleSigTERM)
signal.signal(signal.SIGTERM, self.handleSigTERM)
# self.os_interaction.handle_signals(self.handleSigTERM)
except ValueError:
pass
import cgi
from urlparse import urlparse, parse_qs
import SocketServer
import os
import posixpath
import socket
import urllib
from OpenSSL import SSL
from openport.services.logger_service import get_logger
from openport.services import osinteraction
from ext_http_server import RangeHandler
_file_serve_path = None
_token = None
logger = get_logger(__name__)
os_interaction = osinteraction.getInstance()
class FileServeHandler(RangeHandler):
def setup(self):
self.connection = self.request
self.rfile = socket._fileobject(self.request, "rb", self.rbufsize)
self.wfile = socket._fileobject(self.request, "wb", self.wbufsize)
def send_head(self):
if not self.check_token(): return None
return self.send_file(_file_serve_path)
def send_file(self, path):
f = None
logger.debug('path = %s' % path)
def setUp(self):
print(self._testMethodName)
set_log_level(logging.DEBUG)
#self.test_server = 'http://test.openport.be'
self.test_server = 'https://test2.openport.io'
self.osinteraction = osinteraction.getInstance()
def __init__(self, openport_app_config):
self.config = openport_app_config
self.os_interaction = osinteraction.getInstance()
def request_port(public_key,
local_port=None,
url='%s/api/v1/request-port' % DEFAULT_SERVER,
restart_session_token='',
request_server_port=-1,
http_forward=False,
automatic_restart=False,
forward_tunnel=False,
ip_link_protection=None,
client_version=VERSION):
"""
Requests a port on the server using the openPort protocol
return a tuple with ( server_ip, server_port, message )
"""
os_interaction = osinteraction.getInstance()
r = None
try:
request_data = {
'public_key': public_key,
'request_port': request_server_port,
'restart_session_token': restart_session_token,
'http_forward': 'on' if http_forward else '',
'automatic_restart': 'on' if automatic_restart else '',
'local_port': local_port if local_port else '',
'client_version': client_version,
'forward_tunnel': 'on' if forward_tunnel else '',
'platform': platform.platform(),
}
if ip_link_protection is not None:
request_data[
'ip_link_protection'] = 'on' if ip_link_protection else ''
# if sys.version_info >= (2, 7, 9):
# import ssl
# ssl._create_default_https_context = ssl._create_unverified_context
logger.debug('sending request %s %s' % (url, request_data))
#
verify = 'local' not in url and '192.168' not in url and not os.environ.get(
'NO_SSL_VERIFY')
r = requests.post(url, data=request_data, verify=verify)
if r.status_code == 200:
#logger.debug(r.text)
return r.json()
if r.status_code == 500:
return {'error': r.reason}
return {
'error': 'status code: {} text: {}'.format(r.status_code, r.text)
}
except requests.HTTPError as e:
logger.error(
"An error has occurred while communicating with the openport servers. %s"
% e)
if r is not None:
logger.debug('error: got response: %s' % r.text)
try:
error_page_file_path = os_interaction.get_app_data_path(
'error.html')
with open(error_page_file_path, 'w') as f:
f.write(r.text)
logger.debug('error is available here: %s' %
error_page_file_path)
except Exception as e:
logger.debug(e)
if e.response:
logger.debug('error: got response: %s' % e.response.text)
if e.response.status_code == 500:
try:
error_page_file_path = os_interaction.get_app_data_path(
'error.html')
with open(error_page_file_path, 'w') as f:
logger.debug('error is available here: %s' %
error_page_file_path)
f.write(e.response.text)
except Exception as e:
logger.debug(e)
raise
except Exception as e:
if r is not None:
try:
error_page_file_path = os_interaction.get_app_data_path(
'error.html')
with open(error_page_file_path, 'w') as f:
f.write(r.text)
logger.debug('error is available here: %s' %
error_page_file_path)
except Exception as e:
logger.debug(e)
logger.error(
"An error has occurred while communicating with the openport servers. %s"
% e)
#logger.exception(e)
raise e
if __name__ == '__main__':
# port = get_open_port()
# s = SimpleTcpServer(port)
# s.runThreaded()
# sleep(1)
#
# c = SimpleTcpClient('localhost', port)
#
# var = raw_input('Enter something: ')
# print 'you entered ', var
# print 'server replied', c.send(var)
port = osinteraction.getInstance().get_open_port()
s = TestHTTPServer(port)
s.reply('hooray')
s.runThreaded()
sleep(1)
c = SimpleHTTPClient()
print 'server replied', c.get('http://localhost:%s' % port)
def run_command_with_timeout(args, timeout_s):
class Command(object):
def __init__(self, cmd):
self.cmd = cmd
self.process = None
