def post(self): def count_total_records(key): return db.get_session().query(DetectorRequestData).filter_by(detected=key).count() def count_server_records(server_id, key): return db.get_session().query(DetectorRequestData).filter_by(detected=key, to_server_id=server_id).count() incoming_json = request.get_json() errors = check_json_object(incoming_json, ["email"], "Could not find {} at the incoming json object.") if len(errors) > 0: log("[API][GetActiveServicesHandler] Could not process the request: {}".format(errors), LogLevel.INFO, self.post) return False user = db.get_session().query(Users).filter(Users.email == incoming_json["email"]).first() if user is None: log("[API][GetActiveServicesHandler] Could not find the user in the DB: {}".format(incoming_json["email"]), LogLevel.INFO, self.post) return False try: joined_statuses = [] all_servers = db.get_session().query(Server).filter(Server.user_id == user.item_id).all() log("[API][GetActiveServicesHandler] all_servers: {}".format(all_servers), LogLevel.INFO, self.post) for server in all_servers: log("[API][GetActiveServicesHandler] server: {}".format(server), LogLevel.INFO, self.post) services = db.get_session().query(Services).filter(Services.server_id == server.item_id).first() if services is None: log("[API][GetActiveServicesHandler] Could not find the services in the DB: {}".format( server.server_dns), LogLevel.INFO, self.post) return False jsoned_services = to_json(services, ignore_list=["server_id", "user_id", "id", "created_on"], to_str=True) final_services_json = { key: { "state": value, "count": count_total_records(key) if user.is_admin else count_server_records(server.item_id, key) } for key, value in jsoned_services.items() } log("[API][GetActiveServicesHandler] final_services_json: {}".format(final_services_json), LogLevel.INFO, self.post) joined_object = {**final_services_json, **to_json(server, to_str=True)} joined_object['website'] = joined_object['server_dns'] del joined_object['server_dns'] joined_statuses.append(joined_object) log("[API][GetActiveServicesHandler] return {}".format(joined_statuses), LogLevel.DEBUG, self.post) return joined_statuses except Exception as e: log("[API][GetActiveServicesHandler] Exception: {}".format(e), LogLevel.ERROR, self.post) return False
def _list_of_detectors(self, server_id): session = db.get_session() services = session.query(Services).filter_by( server_id=server_id).first() services = to_json(services, ignore_list=self.kb["ignore_list"]) return [ self._detectors[key] for key in services if key in self._detectors and services[key] ]
def post(self): all_users = db.get_session().query(Users).all() all_servers = db.get_session().query(Server).all() all_services = db.get_session().query(Services).all() joined_objects = [] for user in all_users: current_object = to_json(user, to_str=True) del current_object["password"] for server in all_servers: if server.user_id == user.item_id: current_object = {**current_object, **to_json(server, to_str=True)} for service in all_services: if service.server_id == server.item_id: current_object = {**current_object, **to_json(service, ignore_list=["server_id", "user_id", "id", "created_on"], to_str=True)} joined_objects.append(current_object) log("[API][GetUsersDataHandler] joined_objects: {}".format(joined_objects), LogLevel.DEBUG, self.post) return joined_objects
def post(self): incoming_json = request.get_json() errors = check_json_object(incoming_json, ["website", "update_data"], "Could not find {} at the incoming json object.") if len(errors) > 0: log("[API][UpdateServiceStatusHandler] Could not process the request: {}".format(errors), LogLevel.INFO, self.post) return 0 server = db.get_session().query(Server).filter(Server.server_dns == incoming_json['website']).first() if server is None: log("[API][UpdateServiceStatusHandler] Could not find the server at the Database: {}" .format(incoming_json['website']), LogLevel.INFO, self.post) return 0 update_data = incoming_json['update_data'] update_data_final = {k: 1 if v == 'True' else 0 for k, v in update_data.items()} log("[API][UpdateServiceStatusHandler] Services update_data_final: {}".format(update_data_final), LogLevel.INFO, self.post) sess = db.get_session() sess.query(Services).filter(Services.server_id == server.item_id).update(update_data_final) sess.commit() log("[API][UpdateServiceStatusHandler] Services update successfully for: {}".format(server.server_dns), LogLevel.INFO, self.post) return 1
def _get_previous_request_info(self, ip, path, dns_name): brute_force_data = db.get_session().query( BruteForceDataItem).filter_by(ip=ip, path=path, dns_name=dns_name).first() if brute_force_data is None: brute_force_data = BruteForceDataItem(ip=ip, dns_name=dns_name, path=path, counter=0, time_stamp=time.time()) db.insert(brute_force_data) return brute_force_data
def post(self): incoming_json = request.get_json() errors = check_json_object(incoming_json, ["update_data"], "Could not find {} at the incoming json object.") if len(errors) > 0: log("[API][AdminUpdateServiceStatusHandler] Could not process the request: {}".format(errors), LogLevel.INFO, self.post) return 0 log("[API][AdminUpdateServiceStatusHandler] admin update: {}" .format(type(incoming_json['update_data'])), LogLevel.DEBUG, self.post) update_data = incoming_json['update_data'] sess = db.get_session() sess.query(Services).update(update_data) sess.commit() log("[API][AdminUpdateServiceStatusHandler] Date updated: {}".format(incoming_json['update_data']), LogLevel.DEBUG, self.post) return 1
def _check_cookie_is_authorized(self, parsed_data): """ To do (Generate the key in the proxy for verifying) :param parsed_data: Parsed Data (from the parser module) of the request / response :return: """ cookies = parsed_data.headers.get("Cookie", None) if cookies is None: return False cookies_token = db.get_session().query(CookiesToken).\ filter_by(active=True, ip=parsed_data.from_ip, dns_name=parsed_data.host_name).first() if cookies_token is None: return True m = re.match(self.kb["token_regex"], cookies) if m is None: return True secret_value = m.group(1) check = secret_value != cookies_token.token return check
def post(self): incoming_json = request.get_json() errors = check_json_object(incoming_json, ["email", "password"], "Could not find {} at the incoming json object.") if len(errors) > 0: log("[API][LoginHandler] Could not process the request: {}".format(errors), LogLevel.INFO, self.post) return 0 user = db.get_session().query(Users).filter(Users.email == incoming_json['email']).first() if user is None: log("[API][LoginHandler] Could not locate the {} user: "******"[API][LoginHandler] Admin login has occurred: {}".format(incoming_json['email']), LogLevel.INFO, self.post) return 2 return 1 log("[API][LoginHandler] Login Failure has occurred:: {} {}".format(request.remote_addr, incoming_json['email']), LogLevel.INFO, self.post) return 0
def _is_authorized(self, requester_ip): """ :param server: :param requester_ip: :return: """ session = db.get_session() white_list = session.query(WhiteList).filter_by( server_id=self._server.item_id).all() black_list = session.query(BlackList).filter_by( server_id=self._server.item_id).all() valid = False for item in white_list: valid = valid or item.ip == requester_ip if valid: return IsAuthorized.Yes for item in black_list: valid = valid or item.ip == requester_ip if valid: return IsAuthorized.No return IsAuthorized.NoData
def post(self): incoming_json = request.get_json() errors = check_json_object(incoming_json, ["email", "services"], "Could not find {} at the incoming json object.") if len(errors) > 0: log("[API][AddNewWebsiteHandler] Could not process the request: {}".format(errors), LogLevel.INFO, self.post) return 0 errors = check_json_object(incoming_json["services"], services_credentials, "Could not find {} at the services json object.") if len(errors) > 0: log("[API][AddNewWebsiteHandler] Could not process the request: {}".format(errors), LogLevel.INFO, self.post) return 0 user = db.get_session().query(Users).filter(Users.email == incoming_json["email"]).first() if user is None: log("[API][AddNewWebsiteHandler] Could not find this user at the datABASE: {}".format(incoming_json["email"]), LogLevel.INFO, self.post) return 0 server = Server(user_id=user.item_id, server_ip=incoming_json['services']['ip'], server_dns=incoming_json['services']['website']) try: db.insert(server) except Exception as e: errors = [e] finally: if server.item_id is None: log("[API][RegisterHandler] Could not insert the server into the database, contact the server " "administrator: {} ".format(errors), LogLevel.INFO, self.post) return 0 users_services = create_services_object(user_id=user.item_id, incoming_json=incoming_json, server_id=server.item_id) try: db.insert(users_services) # TODO: Royi this is Duplicate code (just copy past from register user) except Exception as e: errors = [str(e)] finally: if users_services.item_id is None: log("[API][AddNewWebsiteHandler] Could not insert the services into the database, contact the server " "administrator: {} ".format(errors), LogLevel.INFO, self.post) return 0 return 1
def request_handler(self, parsed_request, original_request): self._request_data = DetectorRequestData( from_ip=parsed_request.from_ip) self._request = parsed_request session = db.get_session() # Get The Server id from DB log( "Looking for the server on the DataBase {}".format( parsed_request.host_name), LogLevel.DEBUG, self.request_handler) self._server = session.query(Server).filter_by( server_dns=parsed_request.host_name).first() if self._server is None: log( "Server not found at the DataBase {}".format( parsed_request.host_name), LogLevel.DEBUG, self.request_handler) return ControllerResponseCode.Failed, RedirectAnswerTo.Client, original_request, parsed_request # check if authorized requester. self._request_data.to_server_id = self._server.item_id log("Activate _is_authorized method", LogLevel.DEBUG, self.request_handler) is_authorized = self._is_authorized(parsed_request.from_ip) if is_authorized == IsAuthorized.Yes: log("_is_authorized method results is Yes", LogLevel.DEBUG, self.request_handler) self._request_data.detected = "white_list" return ControllerResponseCode.Valid, RedirectAnswerTo.Server, original_request, parsed_request elif is_authorized == IsAuthorized.No: log("_is_authorized method results is No", LogLevel.DEBUG, self.request_handler) self._request_data.detected = "black_list" return ControllerResponseCode.NotValid, RedirectAnswerTo.Client, original_request, parsed_request # Get list of detectors for the server log("_is_authorized method results is NoConclusions", LogLevel.DEBUG, self.request_handler) parsed_request.to_server_id = self._server.item_id if str(original_request.headers.get('sec-fetch-dest', "")) in self.kb["white_content"]: self._is_white_content = True self._request_data.detected = "none" return ControllerResponseCode.Valid, RedirectAnswerTo.Server, original_request, parsed_request log("Activate _list_of_detectors method", LogLevel.DEBUG, self.request_handler) detectors = self._list_of_detectors(self._server.item_id) log("_list_of_detectors results is {}".format(detectors), LogLevel.DEBUG, self.request_handler) for detector_constructor in detectors: detector = detector_constructor() validate = detector.detect(parsed_request) if detector.name in self.kb["non_blocking_detectors"] and validate: # Detected => Removing cookies. original_request.headers.replace_header("Cookie", "") elif detector.name in self.kb["non_blocking_detectors"]: # Creating new token self.response_cookie = CookiesToken( dns_name=parsed_request.host_name, ip=parsed_request.from_ip, active=True, token=secrets.token_hex(256)) elif validate: log( " ************* Detector {} is detected unusual activity for {} ************" .format(detector.name, original_request.url), LogLevel.INFO, self.request_handler) self._request_data.detected = detector.name log("Insert Information to database".format(detector.name), LogLevel.DEBUG, self.request_handler) return ControllerResponseCode.NotValid, RedirectAnswerTo.Client, original_request, parsed_request log("Nothing unusual detected by the detectors.", LogLevel.INFO, self.request_handler) self._request_data.detected = "none" log("Insert Information to database", LogLevel.DEBUG, self.request_handler) return ControllerResponseCode.Valid, RedirectAnswerTo.Server, original_request, parsed_request
def count_server_records(server_id, key): return db.get_session().query(DetectorRequestData).filter_by(detected=key, to_server_id=server_id).count()
def count_total_records(key): return db.get_session().query(DetectorRequestData).filter_by(detected=key).count()