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()
