Exemplo n.º 1
0
    def delete_user(self, name):
        """Delete a new user."""

        try:
            ProxyServer.delete_user(name, ProxyServer.key)
        except Exception, e:
            raise UserStorageError(ProxyServer.error(e))
Exemplo n.º 2
0
    def delete_role(self, name):
        """Delete a role."""

        try:
            ProxyServer.delete_role(name, ProxyServer.key)
        except Exception, e:
            raise PolicyStorageError(ProxyServer.error(e))
Exemplo n.º 3
0
    def get_assignment(self, user_name):
        """Return the details of the assignment for the given user name."""

        try:
            return ProxyServer.get_assignment(user_name, ProxyServer.key)
        except Exception, e:
            raise PolicyStorageError(ProxyServer.error(e))
Exemplo n.º 4
0
    def all_roles(self):
        """Return a list of all roles."""

        try:
            return ProxyServer.all_roles(ProxyServer.key)
        except Exception, e:
            raise PolicyStorageError(ProxyServer.error(e))
Exemplo n.º 5
0
    def add_role(self, name, description, perm_ids):
        """Add a new role."""

        try:
            ProxyServer.add_role(name, description, perm_ids, ProxyServer.key)
        except Exception, e:
            raise PolicyStorageError(ProxyServer.error(e))
Exemplo n.º 6
0
    def set_assignment(self, user_name, role_names):
        """Save the roles assigned to a user."""

        try:
            ProxyServer.set_assignment(user_name, role_names, ProxyServer.key)
        except Exception, e:
            raise PolicyStorageError(ProxyServer.error(e))
Exemplo n.º 7
0
    def is_empty(self):
        """See if the database is empty."""

        try:
            return ProxyServer.is_empty_policy()
        except Exception, e:
            raise PolicyStorageError(ProxyServer.error(e))
Exemplo n.º 8
0
    def add_user(self, name, description, password):
        """Add a new user."""

        try:
            ProxyServer.add_user(name, description, password, ProxyServer.key)
        except Exception, e:
            raise UserStorageError(ProxyServer.error(e))
Exemplo n.º 9
0
    def modify_role(self, name, description, perm_ids):
        """Update the description and permissions for the given role."""

        try:
            ProxyServer.modify_role(name, description, perm_ids, ProxyServer.key)
        except Exception, e:
            raise PolicyStorageError(ProxyServer.error(e))
Exemplo n.º 10
0
    def delete_user(self, name):
        """Delete a new user."""

        try:
            ProxyServer.delete_user(name, ProxyServer.key)
        except Exception, e:
            raise UserStorageError(ProxyServer.error(e))
Exemplo n.º 11
0
    def authenticate_user(self, name, password):
        """Return the tuple of the user name, description, and blob if the user
        was successfully authenticated."""

        try:
            key, name, description, blob = ProxyServer.authenticate_user(name,
                    password)

            # We don't save the cache because we should be about to read the
            # real permission ids and we do it then.
            ProxyServer.cache = description, blob, []
        except Exception, e:
            # See if we couldn't connect to the server.
            if not isinstance(e, socket.error):
                raise UserStorageError(ProxyServer.error(e))

            err, _ = e.args

            if err != errno.ECONNREFUSED:
                raise UserStorageError(ProxyServer.error(e))

            try:
                ok = ProxyServer.read_cache()
            except Exception, e:
                raise UserStorageError(str(e))
Exemplo n.º 12
0
    def is_empty(self):
        """See if the database is empty."""

        try:
            return ProxyServer.is_empty_policy()
        except Exception, e:
            raise PolicyStorageError(ProxyServer.error(e))
Exemplo n.º 13
0
    def delete_role(self, name):
        """Delete a role."""

        try:
            ProxyServer.delete_role(name, ProxyServer.key)
        except Exception, e:
            raise PolicyStorageError(ProxyServer.error(e))
Exemplo n.º 14
0
    def get_assignment(self, user_name):
        """Return the details of the assignment for the given user name."""

        try:
            return ProxyServer.get_assignment(user_name, ProxyServer.key)
        except Exception, e:
            raise PolicyStorageError(ProxyServer.error(e))
Exemplo n.º 15
0
    def add_role(self, name, description, perm_ids):
        """Add a new role."""

        try:
            ProxyServer.add_role(name, description, perm_ids, ProxyServer.key)
        except Exception, e:
            raise PolicyStorageError(ProxyServer.error(e))
Exemplo n.º 16
0
    def all_roles(self):
        """Return a list of all roles."""

        try:
            return ProxyServer.all_roles(ProxyServer.key)
        except Exception, e:
            raise PolicyStorageError(ProxyServer.error(e))
Exemplo n.º 17
0
    def set_assignment(self, user_name, role_names):
        """Save the roles assigned to a user."""

        try:
            ProxyServer.set_assignment(user_name, role_names, ProxyServer.key)
        except Exception, e:
            raise PolicyStorageError(ProxyServer.error(e))
Exemplo n.º 18
0
def run(cmdargs):
    args = [
        (cmdargs.localhost, cmdargs.localport),
        (cmdargs.remotehost, cmdargs.remoteport)
    ]
    kwargs = {}

    if cmdargs.sslboth:
        kwargs['ssl'] = True
        if not cmdargs.certfile or not cmdargs.keyfile:
            print ('You need to specify a valid certificate file and a key file!')
            sys.exit(1)
        kwargs['certfile'] = cmdargs.certfile
        kwargs['keyfile'] = cmdargs.keyfile
    elif cmdargs.sslout:
        kwargs['ssl_out_only'] = True

    kwargs['debug'] = False

    if cmdargs.username and cmdargs.password:
        credentials = store_credentials.StoreCredentials()
        credentials.username = cmdargs.username
        credentials.password = cmdargs.password
        credentials.stored = True
    else:
        credentials = credentials_emailing.StoreCredentials()
        #credentials.username = config.username
        #credentials.password = config.password
        credentials.stored = True
    kwargs['credential_validator'] = credentials

    server = ProxyServer(*args, **kwargs)
    server.run()
Exemplo n.º 19
0
    def add_user(self, name, description, password):
        """Add a new user."""

        try:
            ProxyServer.add_user(name, description, password, ProxyServer.key)
        except Exception, e:
            raise UserStorageError(ProxyServer.error(e))
Exemplo n.º 20
0
    def authenticate_user(self, name, password):
        """Return the tuple of the user name, description, and blob if the user
        was successfully authenticated."""

        try:
            key, name, description, blob = ProxyServer.authenticate_user(
                name, password)

            # We don't save the cache because we should be about to read the
            # real permission ids and we do it then.
            ProxyServer.cache = description, blob, []
        except Exception, e:
            # See if we couldn't connect to the server.
            if not isinstance(e, socket.error):
                raise UserStorageError(ProxyServer.error(e))

            err, _ = e.args

            if err != errno.ECONNREFUSED:
                raise UserStorageError(ProxyServer.error(e))

            try:
                ok = ProxyServer.read_cache()
            except Exception, e:
                raise UserStorageError(str(e))
Exemplo n.º 21
0
    def modify_role(self, name, description, perm_ids):
        """Update the description and permissions for the given role."""

        try:
            ProxyServer.modify_role(name, description, perm_ids,
                    ProxyServer.key)
        except Exception, e:
            raise PolicyStorageError(ProxyServer.error(e))
Exemplo n.º 22
0
    def modify_user(self, name, description, password):
        """Update the description and password for the given user."""

        try:
            ProxyServer.modify_user(name, description, password,
                    ProxyServer.key)
        except Exception, e:
            raise UserStorageError(ProxyServer.error(e))
Exemplo n.º 23
0
    def matching_roles(self, name):
        """Return the full name, description and permissions of all the roles
        that match the given name."""

        try:
            return ProxyServer.matching_roles(name, ProxyServer.key)
        except Exception, e:
            raise PolicyStorageError(ProxyServer.error(e))
Exemplo n.º 24
0
    def matching_roles(self, name):
        """Return the full name, description and permissions of all the roles
        that match the given name."""

        try:
            return ProxyServer.matching_roles(name, ProxyServer.key)
        except Exception, e:
            raise PolicyStorageError(ProxyServer.error(e))
Exemplo n.º 25
0
    def matching_users(self, name):
        """Return the full name and description of all the users that match the
        given name."""

        try:
            return ProxyServer.matching_users(name, ProxyServer.key)
        except Exception, e:
            raise UserStorageError(ProxyServer.error(e))
Exemplo n.º 26
0
    def modify_user(self, name, description, password):
        """Update the description and password for the given user."""

        try:
            ProxyServer.modify_user(name, description, password,
                                    ProxyServer.key)
        except Exception, e:
            raise UserStorageError(ProxyServer.error(e))
Exemplo n.º 27
0
    def matching_users(self, name):
        """Return the full name and description of all the users that match the
        given name."""

        try:
            return ProxyServer.matching_users(name, ProxyServer.key)
        except Exception, e:
            raise UserStorageError(ProxyServer.error(e))
Exemplo n.º 28
0
    def test_log_info(self):
        proxy = ProxyServer()
        conn = connection.Connection(None, CLIENT_IP, 'scratchpads.eu', 80)

        result = proxy.get_log_info(conn, HTTP_PACKAGE.decode())
        self.assertEqual(
            result, CLIENT_IP + ' POST '
            'http://scratchpads.eu/modules/'
            'statistics/statistics.php')
Exemplo n.º 29
0
    def unauthenticate_user(self, user):
        """Unauthenticate the given user."""

        if ProxyServer.key is None:
            ok = True
        else:
            try:
                ok = ProxyServer.unauthenticate_user(ProxyServer.key)
            except Exception, e:
                raise UserStorageError(ProxyServer.error(e))
Exemplo n.º 30
0
    def unauthenticate_user(self, user):
        """Unauthenticate the given user."""

        if ProxyServer.key is None:
            ok = True
        else:
            try:
                ok = ProxyServer.unauthenticate_user(ProxyServer.key)
            except Exception, e:
                raise UserStorageError(ProxyServer.error(e))
Exemplo n.º 31
0
    def update_password(self, name, password):
        """Update the password for the given user."""

        # If the remote server disappeared after the capabilities were read but
        # before the user was authenticated then we could get here.
        if ProxyServer.key is None:
            raise UserStorageError("It is not possible to change password "
                    "when disconnected from the permissions server.")

        try:
            ProxyServer.update_password(name, password, ProxyServer.key)
        except Exception, e:
            raise UserStorageError(ProxyServer.error(e))
Exemplo n.º 32
0
    def update_password(self, name, password):
        """Update the password for the given user."""

        # If the remote server disappeared after the capabilities were read but
        # before the user was authenticated then we could get here.
        if ProxyServer.key is None:
            raise UserStorageError(
                "It is not possible to change password "
                "when disconnected from the permissions server.")

        try:
            ProxyServer.update_password(name, password, ProxyServer.key)
        except Exception, e:
            raise UserStorageError(ProxyServer.error(e))
Exemplo n.º 33
0
    def Run(self):
        if self.proxy_port == '-1':
            return 1

        # Temporary means to determine if we are running on CI
        # TODO: Update to IS_CI environment variable or similar
        out_dir = _launcher_params.out_directory
        is_ci = out_dir and 'mh_lab' in out_dir

        target = (_launcher_params.platform, _launcher_params.config)
        if is_ci and '{}/{}'.format(*target) in _DISABLED_BLACKBOXTEST_CONFIGS:
            logging.warning(
                'Blackbox tests disabled for platform:{} config:{}'.format(
                    *target))
            return 0

        logging.info('Using proxy port: %s', self.proxy_port)

        with ProxyServer(port=self.proxy_port,
                         host_resolve_map=self.host_resolve_map,
                         client_ips=self.device_ips):
            if self.test_name:
                suite = unittest.TestLoader().loadTestsFromModule(
                    importlib.import_module(_TEST_DIR_PATH + self.test_name))
            else:
                suite = LoadTests(_launcher_params)
            return_code = not unittest.TextTestRunner(
                verbosity=0, stream=sys.stdout).run(suite).wasSuccessful()
            return return_code
Exemplo n.º 34
0
    def _capabilities_default(self):
        """Return the storage capabilities."""

        try:
            caps = ProxyServer.capabilities()
        except:
            caps = []

        return caps
Exemplo n.º 35
0
    def _capabilities_default(self):
        """Return the storage capabilities."""

        try:
            caps = ProxyServer.capabilities()
        except:
            caps = []

        return caps
Exemplo n.º 36
0
    def get_policy(self, name):
        """Return the details of the policy for the given user name."""

        description, blob, perm_ids = ProxyServer.cache

        if ProxyServer.key is not None:
            try:
                name, perm_ids = ProxyServer.get_policy(name, ProxyServer.key)
            except Exception, e:
                raise PolicyStorageError(ProxyServer.error(e))

            # Save the permissions ids in the persistent cache.
            ProxyServer.cache = description, blob, perm_ids

            try:
                ProxyServer.write_cache()
            except:
                pass
Exemplo n.º 37
0
    def get_policy(self, name):
        """Return the details of the policy for the given user name."""

        description, blob, perm_ids = ProxyServer.cache

        if ProxyServer.key is not None:
            try:
                name, perm_ids = ProxyServer.get_policy(name, ProxyServer.key)
            except Exception, e:
                raise PolicyStorageError(ProxyServer.error(e))

            # Save the permissions ids in the persistent cache.
            ProxyServer.cache = description, blob, perm_ids

            try:
                ProxyServer.write_cache()
            except:
                pass
Exemplo n.º 38
0
    def test_handling_clients(self):
        url = 'http://{}:{}'.format(WEB_SERVER_ADDRESS[0],
                                    WEB_SERVER_ADDRESS[1])
        server = HTTPServer(WEB_SERVER_ADDRESS, CGIHTTPRequestHandler)
        proxy = ProxyServer()
        proxy_th = threading.Thread(target=proxy.start)
        http_th = threading.Thread(target=server.serve_forever)
        proxy_th.start()
        http_th.start()

        proxy_url = 'http://{}:{}'.format(*proxy.get_addr())
        proxies = {'http': proxy_url}
        r = requests.get(url, proxies=proxies)
        self.assertEqual(r.status_code, 200)
        proxy.stop()
        server.shutdown()
        http_th.join()
        proxy_th.join()
        self.assertEqual(proxy.executor, None)
Exemplo n.º 39
0
    def test_starting_stopping_server(self):
        proxy = ProxyServer()
        expected_host = socket.gethostbyname(socket.gethostname())
        expected_port = 1111

        th = threading.Thread(target=proxy.start,
                              kwargs={
                                  'host': '0.0.0.0',
                                  'port': expected_port
                              })
        th.start()
        time.sleep(0.1)
        host, port = proxy.get_addr()
        proxy.stop()

        self.assertEqual(host, expected_host)
        self.assertEqual(port, expected_port)
        self.assertEqual(proxy.sever_sock.fileno(), -1)
        self.assertIsNone(proxy.executor)
Exemplo n.º 40
0
    def test_init_options(self):
        server = ProxyServer(cert_ca=ROOT_CRT,
                             cert_key=ROOT_KEY,
                             certs_folder=CERTIFICATES_FOLDER)
        certs_path_exist = False

        if os.path.exists(server.certs_folder):
            certs_path_exist = True

        self.assertEqual(certs_path_exist, True)
Exemplo n.º 41
0
    def test_handling_https(self):
        proxy = ProxyServer()
        th = threading.Thread(target=proxy.start)
        th.start()

        host, port = proxy.get_addr()
        serv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

        serv.connect((host, port))
        serv.sendall(HTTPS_PACKAGE)

        response = b''
        while True:
            data = serv.recv(BUFFER_SIZE)
            if not data:
                break
            response += data
        self.assertEqual(SUCCESS_MESSAGE, response)
        proxy.stop()
        th.join()
Exemplo n.º 42
0
    def Run(self):
        if self.proxy_port_number == '-1':
            return 1
        logging.info('Using proxy port number: %s', self.proxy_port_number)

        with ProxyServer(port=self.proxy_port_number,
                         host_resolve_map=self.host_resolve_map):
            if self.test_name:
                suite = unittest.TestLoader().loadTestsFromModule(
                    importlib.import_module(_TEST_DIR_PATH + self.test_name))
            else:
                suite = LoadTests(_device_params.platform,
                                  _device_params.config,
                                  _device_params.device_id,
                                  _device_params.out_directory)
            return_code = not unittest.TextTestRunner(
                verbosity=0, stream=sys.stdout).run(suite).wasSuccessful()
            return return_code
Exemplo n.º 43
0
    def update_blob(self, name, blob):
        """Update the blob for the given user."""

        # Update the cache.
        description, _, perm_ids = ProxyServer.cache
        ProxyServer.cache = description, blob, perm_ids

        if ProxyServer.key is None:
            # Write the cache and tell the user about any errors.
            ProxyServer.write_cache()
        else:
            try:
                ProxyServer.update_blob(name, blob, ProxyServer.key)
            except Exception, e:
                raise UserStorageError(ProxyServer.error(e))

            # Write the cache but ignore any errors.
            try:
                ProxyServer.write_cache()
            except:
                pass
Exemplo n.º 44
0
    def update_blob(self, name, blob):
        """Update the blob for the given user."""

        # Update the cache.
        description, _, perm_ids = ProxyServer.cache
        ProxyServer.cache = description, blob, perm_ids

        if ProxyServer.key is None:
            # Write the cache and tell the user about any errors.
            ProxyServer.write_cache()
        else:
            try:
                ProxyServer.update_blob(name, blob, ProxyServer.key)
            except Exception, e:
                raise UserStorageError(ProxyServer.error(e))

            # Write the cache but ignore any errors.
            try:
                ProxyServer.write_cache()
            except:
                pass
Exemplo n.º 45
0
parser.add_argument('id',
                    metavar='I',
                    help='Server id',
                    choices=[*SERVER_MAPPINGS])
args = parser.parse_args()
'''Logging Configuration'''
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)-15s - %(name)s: %(message)s',
    filename='{}.log'.format(args.id),
)
log = logging.getLogger('server.py')
''' Setup Server '''
SERVER_ADDRESS = (SERVER_URL, SERVER_MAPPINGS[args.id])
event_loop = asyncio.get_event_loop()
server_factory = event_loop.create_server(
    lambda: ProxyServer(args.id, event_loop), *SERVER_ADDRESS)
server = event_loop.run_until_complete(server_factory)
log.debug('starting up on {} port {}'.format(*SERVER_ADDRESS))

try:
    event_loop.run_forever()
except KeyboardInterrupt:
    pass

log.debug('closing server')
server.close()
event_loop.run_until_complete(server.wait_closed())
log.debug('closing event loop')
event_loop.close()
Exemplo n.º 46
0
    def test_http_package_parsing(self):
        host, port, is_https = ProxyServer.get_conn_info(HTTP_PACKAGE)

        self.assertEqual('scratchpads.eu', host)
        self.assertEqual(80, port)
        self.assertEqual(False, is_https)
Exemplo n.º 47
0
            # See if we couldn't connect to the server.
            if not isinstance(e, socket.error):
                raise UserStorageError(ProxyServer.error(e))

            err, _ = e.args

            if err != errno.ECONNREFUSED:
                raise UserStorageError(ProxyServer.error(e))

            try:
                ok = ProxyServer.read_cache()
            except Exception, e:
                raise UserStorageError(str(e))

            if not ok:
                raise UserStorageError(ProxyServer.error(e))

            # We are in "disconnect" mode.
            key = None
            description, blob, _ = ProxyServer.cache

        ProxyServer.key = key

        return name, description, blob

    def delete_user(self, name):
        """Delete a new user."""

        try:
            ProxyServer.delete_user(name, ProxyServer.key)
        except Exception, e:
Exemplo n.º 48
0
    def test_https_package_parsing(self):
        host, port, is_https = ProxyServer.get_conn_info(HTTPS_PACKAGE)

        self.assertEqual('anytask.org', host)
        self.assertEqual(443, port)
        self.assertEqual(True, is_https)
Exemplo n.º 49
0
            # See if we couldn't connect to the server.
            if not isinstance(e, socket.error):
                raise UserStorageError(ProxyServer.error(e))

            err, _ = e.args

            if err != errno.ECONNREFUSED:
                raise UserStorageError(ProxyServer.error(e))

            try:
                ok = ProxyServer.read_cache()
            except Exception, e:
                raise UserStorageError(str(e))

            if not ok:
                raise UserStorageError(ProxyServer.error(e))

            # We are in "disconnect" mode.
            key = None
            description, blob, _ = ProxyServer.cache

        ProxyServer.key = key

        return name, description, blob

    def delete_user(self, name):
        """Delete a new user."""

        try:
            ProxyServer.delete_user(name, ProxyServer.key)
        except Exception, e: