|
|
#!/usr/bin/env python3
|
|
|
# -*- coding: utf-8 -*-
|
|
|
import funct
|
|
|
|
|
|
mysql_enable = funct.get_config_var('mysql', 'enable')
|
|
|
|
|
|
if mysql_enable == '1':
|
|
|
import mysql.connector as sqltool
|
|
|
else:
|
|
|
db = "haproxy-wi.db"
|
|
|
import sqlite3 as sqltool
|
|
|
|
|
|
|
|
|
def get_cur():
|
|
|
try:
|
|
|
if mysql_enable == '0':
|
|
|
con = sqltool.connect(db, isolation_level=None)
|
|
|
else:
|
|
|
mysql_user = funct.get_config_var('mysql', 'mysql_user')
|
|
|
mysql_password = funct.get_config_var('mysql', 'mysql_password')
|
|
|
mysql_db = funct.get_config_var('mysql', 'mysql_db')
|
|
|
mysql_host = funct.get_config_var('mysql', 'mysql_host')
|
|
|
mysql_port = funct.get_config_var('mysql', 'mysql_port')
|
|
|
con = sqltool.connect(user=mysql_user, password=mysql_password,
|
|
|
host=mysql_host, port=mysql_port,
|
|
|
database=mysql_db)
|
|
|
cur = con.cursor()
|
|
|
except sqltool.Error as e:
|
|
|
funct.logging('DB ', ' '+e, haproxywi=1, login=1)
|
|
|
else:
|
|
|
return con, cur
|
|
|
|
|
|
|
|
|
def add_user(user, email, password, role, activeuser):
|
|
|
con, cur = get_cur()
|
|
|
if password != 'aduser':
|
|
|
sql = """INSERT INTO user (username, email, password, role, activeuser) VALUES ('%s', '%s', '%s', '%s', '%s')""" % (user, email, funct.get_hash(password), role, activeuser)
|
|
|
else:
|
|
|
sql = """INSERT INTO user (username, email, role, ldap_user, activeuser) VALUES ('%s', '%s', '%s', '1', '%s')""" % (user, email, role, activeuser)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
return False
|
|
|
else:
|
|
|
return True
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def update_user(user, email, role, id, activeuser):
|
|
|
con, cur = get_cur()
|
|
|
sql = """update user set username = '%s',
|
|
|
email = '%s',
|
|
|
role = '%s',
|
|
|
activeuser = '%s'
|
|
|
where id = '%s'""" % (user, email, role, activeuser, id)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
return False
|
|
|
else:
|
|
|
return True
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def update_user_groups(groups, id):
|
|
|
con, cur = get_cur()
|
|
|
sql = """insert into user_groups(user_id, user_group_id) values('%s', '%s')""" % (id, groups)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
return False
|
|
|
else:
|
|
|
return True
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def delete_user_groups(id):
|
|
|
con, cur = get_cur()
|
|
|
sql = """delete from user_groups
|
|
|
where user_id = '%s'""" % (id)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
return False
|
|
|
else:
|
|
|
return True
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def update_user_password(password, id):
|
|
|
con, cur = get_cur()
|
|
|
sql = """update user set password = '%s'
|
|
|
where id = '%s'""" % (funct.get_hash(password), id)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
return False
|
|
|
else:
|
|
|
return True
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def delete_user(id):
|
|
|
con, cur = get_cur()
|
|
|
sql = """delete from user where id = '%s'""" % (id)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
return False
|
|
|
else:
|
|
|
return True
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
def add_group(name, description):
|
|
|
con, cur = get_cur()
|
|
|
sql = """INSERT INTO groups (name, description) VALUES ('%s', '%s')""" % (name, description)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
return False
|
|
|
else:
|
|
|
return True
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def delete_group(id):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ delete from groups where id = '%s'""" % (id)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
else:
|
|
|
return True
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def update_group(name, descript, id):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ update groups set
|
|
|
name = '%s',
|
|
|
description = '%s'
|
|
|
where id = '%s';
|
|
|
""" % (name, descript, id)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
return False
|
|
|
else:
|
|
|
return True
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def add_server(hostname, ip, group, typeip, enable, master, cred, port, desc, haproxy, nginx):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ INSERT INTO servers (hostname, ip, groups, type_ip, enable, master, cred, port, `desc`, haproxy, nginx)
|
|
|
VALUES ('%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s')
|
|
|
""" % (hostname, ip, group, typeip, enable, master, cred, port, desc, haproxy, nginx)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
return True
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
return False
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def delete_server(id):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ delete from servers where id = '%s'""" % (id)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
else:
|
|
|
return True
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def update_hapwi_server(id, alert, metrics, active):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ update servers set
|
|
|
alert = '%s',
|
|
|
metrics = '%s',
|
|
|
active = '%s'
|
|
|
where id = '%s'""" % (alert, metrics, active, id)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def update_server(hostname, group, typeip, enable, master, id, cred, port, desc, haproxy, nginx):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ update servers set
|
|
|
hostname = '%s',
|
|
|
groups = '%s',
|
|
|
type_ip = '%s',
|
|
|
enable = '%s',
|
|
|
master = '%s',
|
|
|
cred = '%s',
|
|
|
port = '%s',
|
|
|
`desc` = '%s',
|
|
|
haproxy = '%s',
|
|
|
nginx = '%s'
|
|
|
where id = '%s'""" % (hostname, group, typeip, enable, master, cred, port, desc, haproxy, nginx, id)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def update_server_master(master, slave):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ select id from servers where ip = '%s' """ % master
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
for id in cur.fetchall():
|
|
|
sql = """ update servers set master = '%s' where ip = '%s' """ % (id[0], slave)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def select_users(**kwargs):
|
|
|
con, cur = get_cur()
|
|
|
sql = """select * from user ORDER BY id"""
|
|
|
if kwargs.get("user") is not None:
|
|
|
sql = """select * from user where username='%s' """ % kwargs.get("user")
|
|
|
if kwargs.get("id") is not None:
|
|
|
sql = """select * from user where id='%s' """ % kwargs.get("id")
|
|
|
if kwargs.get("group") is not None:
|
|
|
sql = """ select user.* from user left join user_groups as groups on user.id = groups.user_id where groups.user_group_id = '%s' group by id;
|
|
|
""" % kwargs.get("group")
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
return cur.fetchall()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def select_user_groups(id, **kwargs):
|
|
|
con, cur = get_cur()
|
|
|
sql = """select user_group_id from user_groups where user_id = '%s' """ % id
|
|
|
if kwargs.get("limit") is not None:
|
|
|
sql = """select user_group_id from user_groups where user_id = '%s' limit 1 """ % id
|
|
|
if kwargs.get("check_id") is not None:
|
|
|
sql = """select * from user_groups where user_id='%s' and user_group_id = '%s' """ % (id, kwargs.get("check_id"))
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
if kwargs.get("check_id") is not None:
|
|
|
for g in cur.fetchall():
|
|
|
if g[0] is None:
|
|
|
return False
|
|
|
else:
|
|
|
return True
|
|
|
elif kwargs.get("limit") is not None:
|
|
|
for g in cur.fetchall():
|
|
|
return g[0]
|
|
|
else:
|
|
|
return cur.fetchall()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def select_user_groups_with_names(id, **kwargs):
|
|
|
con, cur = get_cur()
|
|
|
if kwargs.get("all") is not None:
|
|
|
sql = """select user_groups.user_id, groups.name from user_groups
|
|
|
left join groups as groups on user_groups.user_group_id = groups.id """
|
|
|
else:
|
|
|
sql = """select user_groups.user_group_id, groups.name from user_groups
|
|
|
left join groups as groups on user_groups.user_group_id = groups.id
|
|
|
where user_groups.user_id = '%s' """ % id
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
if kwargs.get("limit") is not None:
|
|
|
for g in cur.fetchall():
|
|
|
return g[0]
|
|
|
else:
|
|
|
return cur.fetchall()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def select_groups(**kwargs):
|
|
|
con, cur = get_cur()
|
|
|
sql = """select * from groups ORDER BY id"""
|
|
|
if kwargs.get("group") is not None:
|
|
|
sql = """select * from groups where name='%s' """ % kwargs.get("group")
|
|
|
if kwargs.get("id") is not None:
|
|
|
sql = """select * from groups where id='%s' """ % kwargs.get("id")
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
return cur.fetchall()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def select_server_by_name(name):
|
|
|
con, cur = get_cur()
|
|
|
sql = """select ip from servers where hostname='%s' """ % name
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
for name in cur.fetchone():
|
|
|
return name
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def select_servers(**kwargs):
|
|
|
con, cur = get_cur()
|
|
|
sql = """select * from servers where enable = '1' ORDER BY groups """
|
|
|
|
|
|
if kwargs.get("server") is not None:
|
|
|
sql = """select * from servers where ip='%s' """ % kwargs.get("server")
|
|
|
if kwargs.get("full") is not None:
|
|
|
sql = """select * from servers ORDER BY hostname """
|
|
|
if kwargs.get("get_master_servers") is not None:
|
|
|
sql = """select id,hostname from servers where master = 0 and type_ip = 0 and enable = 1 ORDER BY groups """
|
|
|
if kwargs.get("get_master_servers") is not None and kwargs.get('uuid') is not None:
|
|
|
sql = """ select servers.id, servers.hostname from servers
|
|
|
left join user as user on servers.groups = user.groups
|
|
|
left join uuid as uuid on user.id = uuid.user_id
|
|
|
where uuid.uuid = '%s' and servers.master = 0 and servers.type_ip = 0 and servers.enable = 1 ORDER BY servers.groups
|
|
|
""" % kwargs.get('uuid')
|
|
|
if kwargs.get("id"):
|
|
|
sql = """select * from servers where id='%s' """ % kwargs.get("id")
|
|
|
if kwargs.get("hostname"):
|
|
|
sql = """select * from servers where hostname='%s' """ % kwargs.get("hostname")
|
|
|
if kwargs.get("id_hostname"):
|
|
|
sql = """select * from servers where hostname='%s' or id = '%s' or ip = '%s'""" % (kwargs.get("id_hostname"), kwargs.get("id_hostname"), kwargs.get("id_hostname"))
|
|
|
if kwargs.get("server") and kwargs.get("keep_alive"):
|
|
|
sql = """select active from servers where ip='%s' """ % kwargs.get("server")
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
return cur.fetchall()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
def write_user_uuid(login, user_uuid):
|
|
|
con, cur = get_cur()
|
|
|
session_ttl = get_setting('session_ttl')
|
|
|
session_ttl = int(session_ttl)
|
|
|
sql = """ select id from user where username = '%s' """ % login
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
for id in cur.fetchall():
|
|
|
if mysql_enable == '1':
|
|
|
sql = """ insert into uuid (user_id, uuid, exp) values('%s', '%s', now()+ INTERVAL '%s' day) """ % (id[0], user_uuid, session_ttl)
|
|
|
else:
|
|
|
sql = """ insert into uuid (user_id, uuid, exp) values('%s', '%s', datetime('now', '+%s days')) """ % (id[0], user_uuid, session_ttl)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
def write_user_token(login, user_token):
|
|
|
con, cur = get_cur()
|
|
|
token_ttl = get_setting('token_ttl')
|
|
|
sql = """ select id from user where username = '%s' """ % login
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
for id in cur.fetchall():
|
|
|
if mysql_enable == '1':
|
|
|
sql = """ insert into token (user_id, token, exp) values('%s', '%s', now()+ INTERVAL %s day) """ % (id[0], user_token, token_ttl)
|
|
|
else:
|
|
|
sql = """ insert into token (user_id, token, exp) values('%s', '%s', datetime('now', '+%s days')) """ % (id[0], user_token, token_ttl)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
def get_token(uuid):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ select token.token from token left join uuid as uuid on uuid.user_id = token.user_id where uuid.uuid = '%s' """ % uuid
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
for token in cur.fetchall():
|
|
|
return token[0]
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def delete_uuid(uuid):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ delete from uuid where uuid = '%s' """ % uuid
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
pass
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def delete_old_uuid():
|
|
|
con, cur = get_cur()
|
|
|
if mysql_enable == '1':
|
|
|
sql = """ delete from uuid where exp < now() or exp is NULL """
|
|
|
sql1 = """ delete from token where exp < now() or exp is NULL """
|
|
|
else:
|
|
|
sql = """ delete from uuid where exp < datetime('now') or exp is NULL"""
|
|
|
sql1 = """ delete from token where exp < datetime('now') or exp is NULL"""
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
cur.execute(sql1)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def update_last_act_user(uuid):
|
|
|
con, cur = get_cur()
|
|
|
session_ttl = get_setting('session_ttl')
|
|
|
|
|
|
if mysql_enable == '1':
|
|
|
sql = """ update uuid set exp = now()+ INTERVAL %s day where uuid = '%s' """ % (session_ttl, uuid)
|
|
|
else:
|
|
|
sql = """ update uuid set exp = datetime('now', '+%s days') where uuid = '%s' """ % (session_ttl, uuid)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def get_user_name_by_uuid(uuid):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ select user.username from user left join uuid as uuid on user.id = uuid.user_id where uuid.uuid = '%s' """ % uuid
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
for user_id in cur.fetchall():
|
|
|
return user_id[0]
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def get_user_id_by_uuid(uuid):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ select user.id from user left join uuid as uuid on user.id = uuid.user_id where uuid.uuid = '%s' """ % uuid
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
for user_id in cur.fetchall():
|
|
|
return user_id[0]
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def get_user_role_by_uuid(uuid):
|
|
|
con, cur = get_cur()
|
|
|
try:
|
|
|
if mysql_enable == '1':
|
|
|
cur.execute( """ select role.id from user left join uuid as uuid on user.id = uuid.user_id left join role on role.name = user.role where uuid.uuid = '%s' """ % uuid )
|
|
|
else:
|
|
|
cur.execute("select role.id from user left join uuid as uuid on user.id = uuid.user_id left join role on role.name = user.role where uuid.uuid = ?", (uuid,))
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
for user_id in cur.fetchall():
|
|
|
return int(user_id[0])
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def get_role_id_by_name(name):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ select id from role where name = '%s' """ % name
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
for user_id in cur.fetchall():
|
|
|
return user_id[0]
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def get_user_telegram_by_group(group):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ select telegram.* from telegram where groups = '%s' """ % group
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
return cur.fetchall()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def get_telegram_by_ip(ip):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ select telegram.* from telegram left join servers as serv on serv.groups = telegram.groups where serv.ip = '%s' """ % ip
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
return cur.fetchall()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def get_telegram_by_id(id):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ select * from telegram where id = '%s' """ % id
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
return cur.fetchall()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def get_dick_permit(**kwargs):
|
|
|
import http.cookies
|
|
|
import os
|
|
|
if kwargs.get('username'):
|
|
|
user = kwargs.get('username')
|
|
|
grp = '1'
|
|
|
else:
|
|
|
cookie = http.cookies.SimpleCookie(os.environ.get("HTTP_COOKIE"))
|
|
|
user_id = cookie.get('uuid')
|
|
|
group = cookie.get('group')
|
|
|
grp = group.value
|
|
|
user = get_user_id_by_uuid(user_id.value)
|
|
|
disable = ''
|
|
|
haproxy = ''
|
|
|
nginx = ''
|
|
|
keepalived = ''
|
|
|
ip = ''
|
|
|
|
|
|
if kwargs.get('virt'):
|
|
|
type_ip = ""
|
|
|
else:
|
|
|
type_ip = "and type_ip = 0"
|
|
|
if kwargs.get('disable') == 0:
|
|
|
disable = 'or enable = 0'
|
|
|
if kwargs.get('ip'):
|
|
|
ip = "and ip = '%s'" % kwargs.get('ip')
|
|
|
if kwargs.get('haproxy'):
|
|
|
haproxy = "and haproxy = 1"
|
|
|
if kwargs.get('nginx'):
|
|
|
nginx = "and nginx = 1"
|
|
|
if kwargs.get('keepalived'):
|
|
|
nginx = "and keepalived = 1"
|
|
|
|
|
|
if select_user_groups(user, check_id=grp):
|
|
|
con, cur = get_cur()
|
|
|
if grp == '1':
|
|
|
sql = """ select * from servers where enable = 1 %s %s %s order by pos""" % (disable, type_ip, nginx)
|
|
|
else:
|
|
|
sql = """ select * from servers where groups = '{group}' and (enable = 1 {disable}) {type_ip} {ip} {haproxy} {nginx} {keepalived} order by pos
|
|
|
""".format(group=grp, disable=disable, type_ip=type_ip, ip=ip, haproxy=haproxy, nginx=nginx, keepalived=keepalived)
|
|
|
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
return cur.fetchall()
|
|
|
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
else:
|
|
|
print('Atata!')
|
|
|
|
|
|
|
|
|
|
|
|
def is_master(ip, **kwargs):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ select slave.ip, slave.hostname from servers as master left join servers as slave on master.id = slave.master where master.ip = '%s' """ % ip
|
|
|
if kwargs.get('master_slave'):
|
|
|
sql = """ select master.hostname, master.ip, slave.hostname, slave.ip from servers as master left join servers as slave on master.id = slave.master where slave.master > 0 """
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
return cur.fetchall()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def select_ssh(**kwargs):
|
|
|
con, cur = get_cur()
|
|
|
sql = """select * from cred """
|
|
|
if kwargs.get("name") is not None:
|
|
|
sql = """select * from cred where name = '%s' """ % kwargs.get("name")
|
|
|
if kwargs.get("id") is not None:
|
|
|
sql = """select * from cred where id = '%s' """ % kwargs.get("id")
|
|
|
if kwargs.get("serv") is not None:
|
|
|
sql = """select serv.cred, cred.* from servers as serv left join cred on cred.id = serv.cred where serv.ip = '%s' """ % kwargs.get("serv")
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
return cur.fetchall()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def insert_new_ssh(name, enable, group, username, password):
|
|
|
con, cur = get_cur()
|
|
|
sql = """insert into cred(name, enable, groups, username, password) values ('%s', '%s', '%s', '%s', '%s') """ % (name, enable, group, username, password)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
else:
|
|
|
return True
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def delete_ssh(id):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ delete from cred where id = %s """ % (id)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
else:
|
|
|
return True
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def update_ssh(id, name, enable, group, username, password):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ update cred set
|
|
|
name = '%s',
|
|
|
enable = '%s',
|
|
|
groups = %s,
|
|
|
username = '%s',
|
|
|
password = '%s' where id = '%s' """ % (name, enable, group, username, password, id)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def insert_backup_job(server, rserver, rpath, type, time, cred, description):
|
|
|
con, cur = get_cur()
|
|
|
sql = """insert into backups(server, rhost, rpath, `type`, `time`, `cred`, `description`)
|
|
|
values ('%s', '%s', '%s', '%s', '%s', '%s', '%s') """ % (server, rserver, rpath, type, time, cred, description)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
print('error: '+str(e))
|
|
|
con.rollback()
|
|
|
return False
|
|
|
else:
|
|
|
return True
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def select_backups(**kwargs):
|
|
|
con, cur = get_cur()
|
|
|
sql = """select * from backups ORDER BY id"""
|
|
|
if kwargs.get("server") is not None and kwargs.get("rserver") is not None:
|
|
|
sql = """select * from backups where server='%s' and rhost = '%s' """ % (kwargs.get("server"), kwargs.get("rserver"))
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
return cur.fetchall()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def update_backup(server, rserver, rpath, type, time, cred, description, id):
|
|
|
con, cur = get_cur()
|
|
|
sql = """update backups set server = '%s',
|
|
|
rhost = '%s',
|
|
|
rpath = '%s',
|
|
|
type = '%s',
|
|
|
time = '%s',
|
|
|
cred = '%s',
|
|
|
description = '%s' where id = '%s' """ % (server, rserver, rpath, type, time, cred, description, id)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
return False
|
|
|
else:
|
|
|
return True
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def delete_backups(id):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ delete from backups where id = %s """ % (id)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
else:
|
|
|
return True
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def check_exists_backup(server):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ select id from backups where server = '%s' """ % server
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
for s in cur.fetchall():
|
|
|
if s[0] is not None:
|
|
|
return True
|
|
|
else:
|
|
|
return False
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def insert_new_telegram(token, chanel, group):
|
|
|
con, cur = get_cur()
|
|
|
sql = """insert into telegram(`token`, `chanel_name`, `groups`) values ('%s', '%s', '%s') """ % (token, chanel, group)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
print('<span class="alert alert-danger" id="error">An error occurred: ' + e.args[0] + ' <a title="Close" id="errorMess"><b>X</b></a></span>')
|
|
|
con.rollback()
|
|
|
else:
|
|
|
return True
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def delete_telegram(id):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ delete from telegram where id = %s """ % (id)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
else:
|
|
|
return True
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def select_telegram(**kwargs):
|
|
|
con, cur = get_cur()
|
|
|
sql = """select * from telegram """
|
|
|
if kwargs.get('group'):
|
|
|
sql = """select * from telegram where groups = '%s' """ % kwargs.get('group')
|
|
|
if kwargs.get('token'):
|
|
|
sql = """select * from telegram where token = '%s' """ % kwargs.get('token')
|
|
|
if kwargs.get('id'):
|
|
|
sql = """select * from telegram where id = '%s' """ % kwargs.get('id')
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
return cur.fetchall()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def insert_new_telegram(token, chanel, group):
|
|
|
con, cur = get_cur()
|
|
|
sql = """insert into telegram(`token`, `chanel_name`, `groups`) values ('%s', '%s', '%s') """ % (token, chanel, group)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
print('<span class="alert alert-danger" id="error">An error occurred: ' + e.args[0] + ' <a title="Close" id="errorMess"><b>X</b></a></span>')
|
|
|
con.rollback()
|
|
|
else:
|
|
|
return True
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def update_telegram(token, chanel, group, id):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ update telegram set
|
|
|
`token` = '%s',
|
|
|
`chanel_name` = '%s',
|
|
|
`groups` = '%s'
|
|
|
where id = '%s' """ % (token, chanel, group, id)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def insert_new_option(option, group):
|
|
|
con, cur = get_cur()
|
|
|
sql = """insert into options(`options`, `groups`) values ('%s', '%s') """ % (option, group)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
else:
|
|
|
return True
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def select_options(**kwargs):
|
|
|
con, cur = get_cur()
|
|
|
sql = """select * from options """
|
|
|
if kwargs.get('option'):
|
|
|
sql = """select * from options where options = '%s' """ % kwargs.get('option')
|
|
|
if kwargs.get('group'):
|
|
|
sql = """select options from options where groups = '{}' and options like '{}%' """.format(kwargs.get('group'), kwargs.get('term'))
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
return cur.fetchall()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def update_options(option, id):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ update options set
|
|
|
options = '%s'
|
|
|
where id = '%s' """ % (option, id)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def delete_option(id):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ delete from options where id = %s """ % (id)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
else:
|
|
|
return True
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def insert_new_savedserver(server, description, group):
|
|
|
con, cur = get_cur()
|
|
|
sql = """insert into saved_servers(`server`, `description`, `groups`) values ('%s', '%s', '%s') """ % (server, description, group)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
else:
|
|
|
return True
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def select_saved_servers(**kwargs):
|
|
|
con, cur = get_cur()
|
|
|
sql = """select * from saved_servers """
|
|
|
if kwargs.get('server'):
|
|
|
sql = """select * from saved_servers where server = '%s' """ % kwargs.get('server')
|
|
|
if kwargs.get('group'):
|
|
|
sql = """select server,description from saved_servers where groups = '{}' and server like '{}%' """.format(kwargs.get('group'), kwargs.get('term'))
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
return cur.fetchall()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def update_savedserver(server, description, id):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ update saved_servers set
|
|
|
server = '%s',
|
|
|
description = '%s'
|
|
|
where id = '%s' """ % (server, description, id)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def delete_savedserver(id):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ delete from saved_servers where id = %s """ % (id)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
else:
|
|
|
return True
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def insert_mentrics(serv, curr_con, cur_ssl_con, sess_rate, max_sess_rate):
|
|
|
con, cur = get_cur()
|
|
|
if mysql_enable == '1':
|
|
|
sql = """ insert into metrics (serv, curr_con, cur_ssl_con, sess_rate, max_sess_rate, date) values('%s', '%s', '%s', '%s', '%s', now()) """ % (serv, curr_con, cur_ssl_con, sess_rate, max_sess_rate)
|
|
|
else:
|
|
|
sql = """ insert into metrics (serv, curr_con, cur_ssl_con, sess_rate, max_sess_rate, date) values('%s', '%s', '%s', '%s', '%s', datetime('now', 'localtime')) """ % (serv, curr_con, cur_ssl_con, sess_rate, max_sess_rate)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def select_waf_metrics_enable(id):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ select waf.metrics from waf left join servers as serv on waf.server_id = serv.id where server_id = '%s' """ % id
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
return cur.fetchall()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def select_waf_metrics_enable_server(ip):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ select waf.metrics from waf left join servers as serv on waf.server_id = serv.id where ip = '%s' """ % ip
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
for enable in cur.fetchall():
|
|
|
return enable[0]
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
def select_waf_servers(serv):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ select serv.ip from waf left join servers as serv on waf.server_id = serv.id where serv.ip = '%s' """ % serv
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
return cur.fetchall()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def select_all_waf_servers():
|
|
|
con, cur = get_cur()
|
|
|
sql = """ select serv.ip from waf left join servers as serv on waf.server_id = serv.id """
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
return cur.fetchall()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def select_waf_servers_metrics(uuid, **kwargs):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ select * from user where username = '%s' """ % get_user_name_by_uuid(uuid)
|
|
|
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
print("An error occurred:", e)
|
|
|
else:
|
|
|
for group in cur:
|
|
|
if group[5] == '1':
|
|
|
sql = """ select servers.ip from servers left join waf as waf on waf.server_id = servers.id where servers.enable = 1 and waf.metrics = '1' """
|
|
|
else:
|
|
|
sql = """ select servers.ip from servers left join waf as waf on waf.server_id = servers.id where servers.enable = 1 and waf.metrics = '1' and servers.groups like '%{group}%' """.format(group=group[5])
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
return cur.fetchall()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def select_waf_metrics(serv, **kwargs):
|
|
|
con, cur = get_cur()
|
|
|
if mysql_enable == '1':
|
|
|
sql = """ select * from waf_metrics where serv = '%s' order by `date` desc limit 60 """ % serv
|
|
|
else:
|
|
|
sql = """ select * from (select * from waf_metrics where serv = '%s' order by `date` desc limit 60) order by `date`""" % serv
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
return cur.fetchall()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def insert_waf_metrics_enable(serv, enable):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ insert into waf (server_id, metrics) values((select id from servers where ip = '%s'), '%s') """ % (serv, enable)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
def insert_waf_rules(serv):
|
|
|
con, cur = get_cur()
|
|
|
sql = list()
|
|
|
sql.append("INSERT INTO waf_rules (serv, rule_name, rule_file, `desc`) values('%s', 'Ignore static', 'modsecurity_crs_10_ignore_static.conf', 'This ruleset will skip all tests for media files, but will skip only the request body phase (phase 2) for text files. To skip the outbound stage for text files, add file 47 (skip_outbound_checks) to your configuration, in addition to this fileth/aws/login');" % serv)
|
|
|
sql.append("INSERT INTO waf_rules (serv, rule_name, rule_file, `desc`) values('%s', 'Brute force protection', 'modsecurity_crs_11_brute_force.conf', 'Anti-Automation Rule for specific Pages (Brute Force Protection) This is a rate-limiting rule set and does not directly correlate whether the authentication attempt was successful or not');" % serv)
|
|
|
sql.append("INSERT INTO waf_rules (serv, rule_name, rule_file, `desc`) values('%s', 'DOS Protections', 'modsecurity_crs_11_dos_protection.conf', 'Enforce an existing IP address block and log only 1-time/minute. We do not want to get flooded by alerts during an attack or scan so we are only triggering an alert once/minute. You can adjust how often you want to receive status alerts by changing the expirevar setting below');" % serv)
|
|
|
sql.append("INSERT INTO waf_rules (serv, rule_name, rule_file, `desc`) values('%s', 'Proxy abuse', 'modsecurity_crs_11_proxy_abuse.conf', 'Rule set for detecting Open Proxy Abuse/Chaining');" % serv)
|
|
|
sql.append("INSERT INTO waf_rules (serv, rule_name, rule_file, `desc`) values('%s', 'Slow DOS protection', 'modsecurity_crs_11_slow_dos_protection.conf', 'Rule set for detecting Slow HTTP Denial of Service Attacks');" % serv)
|
|
|
sql.append("INSERT INTO waf_rules (serv, rule_name, rule_file, `desc`) values('%s', 'XML enabler', 'modsecurity_crs_13_xml_enabler.conf', 'The rules in this file will trigger the XML parser upon an XML request');" % serv)
|
|
|
sql.append("INSERT INTO waf_rules (serv, rule_name, rule_file, `desc`) values('%s', 'Session hijacking', 'modsecurity_crs_16_session_hijacking.conf', 'This rule file will identify outbound Set-Cookie/Set-Cookie2 response headers and then initiate the proper ModSecurity session persistent collection (setsid). The rules in this file are required if you plan to run other checks such as Session Hijacking, Missing HTTPOnly flag, etc...');" % serv)
|
|
|
sql.append("INSERT INTO waf_rules (serv, rule_name, rule_file, `desc`) values('%s', 'Protocol violations', 'modsecurity_crs_20_protocol_violations.conf', 'Some protocol violations are common in application layer attacks. Validating HTTP requests eliminates a large number of application layer attacks. The purpose of this rules file is to enforce HTTP RFC requirements that state how the client is supposed to interact with the server. http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html');" % serv)
|
|
|
sql.append("INSERT INTO waf_rules (serv, rule_name, rule_file, `desc`) values('%s', 'Protocol anomalies', 'modsecurity_crs_21_protocol_anomalies.conf', 'Some common HTTP usage patterns are indicative of attacks but may also be used by non-browsers for legitimate uses. Do not accept requests without common headers. All normal web browsers include Host, User-Agent and Accept headers. Implies either an attacker or a legitimate automation client');" % serv)
|
|
|
sql.append("INSERT INTO waf_rules (serv, rule_name, rule_file, `desc`) values('%s', 'Detect CC#', 'modsecurity_crs_25_cc_known.conf', 'Detect CC# in input, log transaction and sanitize');" % serv)
|
|
|
sql.append("INSERT INTO waf_rules (serv, rule_name, rule_file, `desc`) values('%s', 'CC traker', 'modsecurity_crs_25_cc_track_pan.conf', 'Credit Card Track 1 and 2 and PAN Leakage Checks');" % serv)
|
|
|
sql.append("INSERT INTO waf_rules (serv, rule_name, rule_file, `desc`) values('%s', 'HTTP policy', 'modsecurity_crs_30_http_policy.conf', 'HTTP policy enforcement The HTTP policy enforcement rule set sets limitations on the use of HTTP by clients. Few applications require the breadth and depth of the HTTP protocol. On the other hand many attacks abuse valid but rare HTTP use patterns. Restricting HTTP protocol usage is effective in therefore effective in blocking many application layer attacks');" % serv)
|
|
|
sql.append("INSERT INTO waf_rules (serv, rule_name, rule_file, `desc`) values('%s', 'Bad robots', 'modsecurity_crs_35_bad_robots.conf', 'Bad robots detection is based on checking elements easily controlled by the client. As such a determined attacked can bypass those checks. Therefore bad robots detection should not be viewed as a security mechanism against targeted attacks but rather as a nuisance reduction, eliminating most of the random attacks against your web site');" % serv)
|
|
|
sql.append("INSERT INTO waf_rules (serv, rule_name, rule_file, `desc`) values('%s', 'OS Injection Attacks', 'modsecurity_crs_40_generic_attacks.conf', 'OS Command Injection Attacks');" % serv)
|
|
|
sql.append("INSERT INTO waf_rules (serv, rule_name, rule_file, `desc`) values('%s', 'SQL injection', 'modsecurity_crs_41_sql_injection_attacks.conf', 'SQL injection protection');" % serv)
|
|
|
sql.append("INSERT INTO waf_rules (serv, rule_name, rule_file, `desc`) values('%s', 'XSS Protections', 'modsecurity_crs_41_xss_attacks.conf', 'XSS attacks protection');" % serv)
|
|
|
sql.append("INSERT INTO waf_rules (serv, rule_name, rule_file, `desc`) values('%s', 'Comment spam', 'modsecurity_crs_42_comment_spam.conf', 'Comment spam is an attack against blogs, guestbooks, wikis and other types of interactive web sites that accept and display hyperlinks submitted by visitors. The spammers automatically post specially crafted random comments which include links that point to the spammer\'s web site. The links artificially increas the site's search engine ranking and may make the site more noticable in search results.');" % serv)
|
|
|
sql.append("INSERT INTO waf_rules (serv, rule_name, rule_file, `desc`) values('%s', 'CSP enforcement', 'modsecurity_crs_42_csp_enforcement.conf', 'The purpose of these settings is to send CSP response headers to Mozilla FireFox users so that you can enforce how dynamic content is used. CSP usage helps to prevent XSS attacks against your users.');" % serv)
|
|
|
sql.append("INSERT INTO waf_rules (serv, rule_name, rule_file, `desc`) values('%s', 'CSRF Protections', 'modsecurity_crs_43_csrf_protection.conf', 'You must have also activated the session hijacking conf file as it initiates the Session Collection and creates the CSRF token');" % serv)
|
|
|
sql.append("INSERT INTO waf_rules (serv, rule_name, rule_file, `desc`) values('%s', 'Trojans Protections', 'modsecurity_crs_45_trojans.conf ', 'The trojan access detection rules detects access to known Trojans already installed on a server. Uploading of Trojans is part of the Anti-Virus rules and uses external Anti Virus program when uploading files. Detection of Trojans access is especially important in a hosting environment where the actual Trojan upload may be done through valid methods and not through hacking');" % serv)
|
|
|
sql.append("INSERT INTO waf_rules (serv, rule_name, rule_file, `desc`) values('%s', 'Joomla Protections', 'modsecurity_crs_46_slr_et_joomla_attacks.conf', 'Use this if you have Joomla CMS');" % serv)
|
|
|
sql.append("INSERT INTO waf_rules (serv, rule_name, rule_file, `desc`) values('%s', 'RFI Protections', 'modsecurity_crs_46_slr_et_lfi_attacks.conf', 'Remote file inclusion is an attack targeting vulnerabilities in web applications that dynamically reference external scripts. The perpetrator’s goal is to exploit the referencing function in an application to upload malware (e.g., backdoor shells) from a remote URL located within a different domain');" % serv)
|
|
|
sql.append("INSERT INTO waf_rules (serv, rule_name, rule_file, `desc`) values('%s', 'phpBB Protections', 'modsecurity_crs_46_slr_et_phpbb_attacks.conf', 'Use this if you have phpBB forum');" % serv)
|
|
|
sql.append("INSERT INTO waf_rules (serv, rule_name, rule_file, `desc`) values('%s', 'RFI Protections 2', 'modsecurity_crs_46_slr_et_rfi_attacks.conf', 'Remote file inclusion is an attack targeting vulnerabilities in web applications that dynamically reference external scripts. The perpetrator’s goal is to exploit the referencing function in an application to upload malware (e.g., backdoor shells) from a remote URL located within a different domain');" % serv)
|
|
|
sql.append("INSERT INTO waf_rules (serv, rule_name, rule_file, `desc`) values('%s', 'SQLi Protections', ' modsecurity_crs_46_slr_et_sqli_attacks.conf', 'SQLi injection attacks protection');" % serv)
|
|
|
sql.append("INSERT INTO waf_rules (serv, rule_name, rule_file, `desc`) values('%s', 'Wordpress Protections', 'modsecurity_crs_46_slr_et_wordpress_attacks.conf', 'Use this if you have Wordpess CMS');" % serv)
|
|
|
sql.append("INSERT INTO waf_rules (serv, rule_name, rule_file, `desc`) values('%s', 'XSS Protections 2', 'modsecurity_crs_46_slr_et_xss_attacks.conf', 'XSS attacks protection');" % serv)
|
|
|
sql.append("INSERT INTO waf_rules (serv, rule_name, rule_file, `desc`) values('%s', 'Common exceptions', 'modsecurity_crs_47_common_exceptions.conf', 'This file is used as an exception mechanism to remove common false positives that may be encountered');" % serv)
|
|
|
sql.append("INSERT INTO waf_rules (serv, rule_name, rule_file, `desc`) values('%s', 'Hader tagging', 'modsecurity_crs_49_header_tagging.conf', 'This file will add Request Header Tagging which allows ModSecurity to communicate any event/rule matches it finds with the downstream application server. The concept is similar to that of Anti-SPAM apps for Email (such as SpamAssassin). The idea is that if the WAF is in a DetectionOnly mode, it can still share data with the destination app server and then the app server may choose to inspect the new WAF request headers and factor in this data into a possible blocking decision. This concept is tremendously useful in a distributed architecture and/or when there are Fraud Detection Systems at the app server layer that can correlate the WAF data into the overall Fraud Score. This is also useful in Hosting Environments where the decision to block may not be as clear');" % serv)
|
|
|
for i in sql:
|
|
|
try:
|
|
|
cur.execute(i)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
pass
|
|
|
else:
|
|
|
if kwargs.get('silent') != 1:
|
|
|
print('Updating... one more for version 4.0.0')
|
|
|
return True
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def select_waf_rules(serv):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ select id, rule_name, en, `desc` from waf_rules where serv = '%s' """ % serv
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
return cur.fetchall()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def delete_waf_server(id):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ delete from waf where server_id = '%s' """ % id
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def insert_waf_mentrics(serv, conn):
|
|
|
con, cur = get_cur()
|
|
|
if mysql_enable == '1':
|
|
|
sql = """ insert into waf_metrics (serv, conn, date) values('%s', '%s', now()) """ % (serv, conn)
|
|
|
else:
|
|
|
sql = """ insert into waf_metrics (serv, conn, date) values('%s', '%s', datetime('now', 'localtime')) """ % (serv, conn)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def delete_waf_mentrics():
|
|
|
con, cur = get_cur()
|
|
|
if mysql_enable == '1':
|
|
|
sql = """ delete from metrics where date < now() - INTERVAL 3 day """
|
|
|
else:
|
|
|
sql = """ delete from metrics where date < datetime('now', '-3 days') """
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def update_waf_metrics_enable(name, enable):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ update waf set metrics = %s where server_id = (select id from servers where hostname = '%s') """ % (enable, name)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def delete_mentrics():
|
|
|
con, cur = get_cur()
|
|
|
if mysql_enable == '1':
|
|
|
sql = """ delete from metrics where date < now() - INTERVAL 3 day """
|
|
|
else:
|
|
|
sql = """ delete from metrics where date < datetime('now', '-3 days') """
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def select_metrics(serv, **kwargs):
|
|
|
con, cur = get_cur()
|
|
|
if mysql_enable == '1':
|
|
|
sql = """ select * from metrics where serv = '%s' order by `date` desc limit 60 """ % serv
|
|
|
else:
|
|
|
sql = """ select * from (select * from metrics where serv = '%s' order by `date` desc limit 60) order by `date` """ % serv
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
return cur.fetchall()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def select_servers_metrics_for_master():
|
|
|
con, cur = get_cur()
|
|
|
sql = """select ip from servers where metrics = 1 """
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
return cur.fetchall()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def select_servers_metrics(uuid, **kwargs):
|
|
|
con, cur = get_cur()
|
|
|
import http.cookies
|
|
|
import os
|
|
|
cookie = http.cookies.SimpleCookie(os.environ.get("HTTP_COOKIE"))
|
|
|
user_id = cookie.get('uuid')
|
|
|
group = cookie.get('group')
|
|
|
group = group.value
|
|
|
id = get_user_id_by_uuid(user_id.value)
|
|
|
if select_user_groups(id, check_id=group) is not None:
|
|
|
if group == '1':
|
|
|
sql = """ select ip from servers where enable = 1 and metrics = '1' """
|
|
|
else:
|
|
|
sql = """ select ip from servers where groups = '{group}' and metrics = '1'""".format(group=group)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
return cur.fetchall()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def select_table_metrics(uuid):
|
|
|
con, cur = get_cur()
|
|
|
import http.cookies
|
|
|
import os
|
|
|
cookie = http.cookies.SimpleCookie(os.environ.get("HTTP_COOKIE"))
|
|
|
user_id = cookie.get('uuid')
|
|
|
group = cookie.get('group')
|
|
|
group = group.value
|
|
|
id = get_user_id_by_uuid(user_id.value)
|
|
|
if select_user_groups(id, check_id=group) is not None:
|
|
|
if group == '1':
|
|
|
groups = ""
|
|
|
else:
|
|
|
groups = "and servers.groups like '%{group}%' ".format(group=group)
|
|
|
if mysql_enable == '1':
|
|
|
sql = """
|
|
|
select ip.ip, hostname, avg_sess_1h, avg_sess_24h, avg_sess_3d, max_sess_1h, max_sess_24h, max_sess_3d, avg_cur_1h, avg_cur_24h, avg_cur_3d, max_con_1h, max_con_24h, max_con_3d from
|
|
|
(select servers.ip from servers where metrics = 1 ) as ip,
|
|
|
|
|
|
(select servers.ip, servers.hostname as hostname from servers left join metrics as metr on servers.ip = metr.serv where servers.metrics = 1 %s) as hostname,
|
|
|
|
|
|
(select servers.ip,round(avg(metr.sess_rate), 1) as avg_sess_1h from servers
|
|
|
left join metrics as metr on metr.serv = servers.ip
|
|
|
where servers.metrics = 1 and
|
|
|
metr.date <= now() and metr.date >= DATE_ADD(NOW(), INTERVAL -1 HOUR)
|
|
|
group by servers.ip) as avg_sess_1h,
|
|
|
|
|
|
(select servers.ip,round(avg(metr.sess_rate), 1) as avg_sess_24h from servers
|
|
|
left join metrics as metr on metr.serv = servers.ip
|
|
|
where servers.metrics = 1 and
|
|
|
metr.date <= now() and metr.date >= DATE_ADD(NOW(),INTERVAL -24 HOUR)
|
|
|
group by servers.ip) as avg_sess_24h,
|
|
|
|
|
|
(select servers.ip,round(avg(metr.sess_rate), 1) as avg_sess_3d from servers
|
|
|
left join metrics as metr on metr.serv = servers.ip
|
|
|
where servers.metrics = 1 and
|
|
|
metr.date <= now() and metr.date >= DATE_ADD(NOW(), INTERVAL -3 DAY)
|
|
|
group by servers.ip ) as avg_sess_3d,
|
|
|
|
|
|
(select servers.ip,max(metr.sess_rate) as max_sess_1h from servers
|
|
|
left join metrics as metr on metr.serv = servers.ip
|
|
|
where servers.metrics = 1 and
|
|
|
metr.date <= now() and metr.date >= DATE_ADD(NOW(),INTERVAL -1 HOUR)
|
|
|
group by servers.ip) as max_sess_1h,
|
|
|
|
|
|
(select servers.ip,max(metr.sess_rate) as max_sess_24h from servers
|
|
|
left join metrics as metr on metr.serv = servers.ip
|
|
|
where servers.metrics = 1 and
|
|
|
metr.date <= now() and metr.date >= DATE_ADD(NOW(),INTERVAL -24 HOUR)
|
|
|
group by servers.ip) as max_sess_24h,
|
|
|
|
|
|
(select servers.ip,max(metr.sess_rate) as max_sess_3d from servers
|
|
|
left join metrics as metr on metr.serv = servers.ip
|
|
|
where servers.metrics = 1 and
|
|
|
metr.date <= now() and metr.date >= DATE_ADD(NOW(),INTERVAL -3 DAY)
|
|
|
group by servers.ip ) as max_sess_3d,
|
|
|
|
|
|
(select servers.ip,round(avg(metr.curr_con+metr.cur_ssl_con), 1) as avg_cur_1h from servers
|
|
|
left join metrics as metr on metr.serv = servers.ip
|
|
|
where servers.metrics = 1 and
|
|
|
metr.date <= now() and metr.date >= DATE_ADD(NOW(),INTERVAL -1 HOUR)
|
|
|
group by servers.ip) as avg_cur_1h,
|
|
|
|
|
|
(select servers.ip,round(avg(metr.curr_con+metr.cur_ssl_con), 1) as avg_cur_24h from servers
|
|
|
left join metrics as metr on metr.serv = servers.ip
|
|
|
where servers.metrics = 1 and
|
|
|
metr.date <= now() and metr.date >= DATE_ADD(NOW(),INTERVAL -24 HOUR)
|
|
|
group by servers.ip) as avg_cur_24h,
|
|
|
|
|
|
(select servers.ip,round(avg(metr.curr_con+metr.cur_ssl_con), 1) as avg_cur_3d from servers
|
|
|
left join metrics as metr on metr.serv = servers.ip
|
|
|
where servers.metrics = 1 and
|
|
|
metr.date <= now() and metr.date >= DATE_ADD(NOW(),INTERVAL -3 DAY)
|
|
|
group by servers.ip ) as avg_cur_3d,
|
|
|
|
|
|
(select servers.ip,max(metr.curr_con) as max_con_1h from servers
|
|
|
left join metrics as metr on metr.serv = servers.ip
|
|
|
where servers.metrics = 1 and
|
|
|
metr.date <= now() and metr.date >= DATE_ADD(NOW(),INTERVAL -1 HOUR)
|
|
|
group by servers.ip) as max_con_1h,
|
|
|
|
|
|
(select servers.ip,max(metr.curr_con) as max_con_24h from servers
|
|
|
left join metrics as metr on metr.serv = servers.ip
|
|
|
where servers.metrics = 1 and
|
|
|
metr.date <= now() and metr.date >= DATE_ADD(NOW(),INTERVAL -24 HOUR)
|
|
|
group by servers.ip) as max_con_24h,
|
|
|
|
|
|
(select servers.ip,max(metr.curr_con) as max_con_3d from servers
|
|
|
left join metrics as metr on metr.serv = servers.ip
|
|
|
where servers.metrics = 1 and
|
|
|
metr.date <= now() and metr.date >= DATE_ADD(NOW(),INTERVAL -3 DAY)
|
|
|
group by servers.ip ) as max_con_3d
|
|
|
|
|
|
where ip.ip=hostname.ip
|
|
|
and ip.ip=avg_sess_1h.ip
|
|
|
and ip.ip=avg_sess_24h.ip
|
|
|
and ip.ip=avg_sess_3d.ip
|
|
|
and ip.ip=max_sess_1h.ip
|
|
|
and ip.ip=max_sess_24h.ip
|
|
|
and ip.ip=max_sess_3d.ip
|
|
|
and ip.ip=avg_cur_1h.ip
|
|
|
and ip.ip=avg_cur_24h.ip
|
|
|
and ip.ip=avg_cur_3d.ip
|
|
|
and ip.ip=max_con_1h.ip
|
|
|
and ip.ip=max_con_24h.ip
|
|
|
and ip.ip=max_con_3d.ip
|
|
|
|
|
|
group by hostname.ip """ % groups
|
|
|
|
|
|
|
|
|
else:
|
|
|
sql = """
|
|
|
select ip.ip, hostname, avg_sess_1h, avg_sess_24h, avg_sess_3d, max_sess_1h, max_sess_24h, max_sess_3d, avg_cur_1h, avg_cur_24h, avg_cur_3d, max_con_1h, max_con_24h, max_con_3d from
|
|
|
(select servers.ip from servers where metrics = 1 ) as ip,
|
|
|
|
|
|
(select servers.ip, servers.hostname as hostname from servers left join metrics as metr on servers.ip = metr.serv where servers.metrics = 1 %s) as hostname,
|
|
|
|
|
|
(select servers.ip,round(avg(metr.sess_rate), 1) as avg_sess_1h from servers
|
|
|
left join metrics as metr on metr.serv = servers.ip
|
|
|
where servers.metrics = 1 and
|
|
|
metr.date <= datetime('now', 'localtime') and metr.date >= datetime('now', '-1 hours', 'localtime')
|
|
|
group by servers.ip) as avg_sess_1h,
|
|
|
|
|
|
(select servers.ip,round(avg(metr.sess_rate), 1) as avg_sess_24h from servers
|
|
|
left join metrics as metr on metr.serv = servers.ip
|
|
|
where servers.metrics = 1 and
|
|
|
metr.date <= datetime('now', 'localtime') and metr.date >= datetime('now', '-24 hours', 'localtime')
|
|
|
group by servers.ip) as avg_sess_24h,
|
|
|
|
|
|
(select servers.ip,round(avg(metr.sess_rate), 1) as avg_sess_3d from servers
|
|
|
left join metrics as metr on metr.serv = servers.ip
|
|
|
where servers.metrics = 1 and
|
|
|
metr.date <= datetime('now', 'localtime') and metr.date >= datetime('now', '-3 days', 'localtime')
|
|
|
group by servers.ip ) as avg_sess_3d,
|
|
|
|
|
|
(select servers.ip,max(metr.sess_rate) as max_sess_1h from servers
|
|
|
left join metrics as metr on metr.serv = servers.ip
|
|
|
where servers.metrics = 1 and
|
|
|
metr.date <= datetime('now', 'localtime') and metr.date >= datetime('now', '-1 hours', 'localtime')
|
|
|
group by servers.ip) as max_sess_1h,
|
|
|
|
|
|
(select servers.ip,max(metr.sess_rate) as max_sess_24h from servers
|
|
|
left join metrics as metr on metr.serv = servers.ip
|
|
|
where servers.metrics = 1 and
|
|
|
metr.date <= datetime('now', 'localtime') and metr.date >= datetime('now', '-24 hours', 'localtime')
|
|
|
group by servers.ip) as max_sess_24h,
|
|
|
|
|
|
(select servers.ip,max(metr.sess_rate) as max_sess_3d from servers
|
|
|
left join metrics as metr on metr.serv = servers.ip
|
|
|
where servers.metrics = 1 and
|
|
|
metr.date <= datetime('now', 'localtime') and metr.date >= datetime('now', '-3 days', 'localtime')
|
|
|
group by servers.ip ) as max_sess_3d,
|
|
|
|
|
|
(select servers.ip,round(avg(metr.curr_con+metr.cur_ssl_con), 1) as avg_cur_1h from servers
|
|
|
left join metrics as metr on metr.serv = servers.ip
|
|
|
where servers.metrics = 1 and
|
|
|
metr.date <= datetime('now', 'localtime') and metr.date >= datetime('now', '-1 hours', 'localtime')
|
|
|
group by servers.ip) as avg_cur_1h,
|
|
|
|
|
|
(select servers.ip,round(avg(metr.curr_con+metr.cur_ssl_con), 1) as avg_cur_24h from servers
|
|
|
left join metrics as metr on metr.serv = servers.ip
|
|
|
where servers.metrics = 1 and
|
|
|
metr.date <= datetime('now', 'localtime') and metr.date >= datetime('now', '-24 hours', 'localtime')
|
|
|
group by servers.ip) as avg_cur_24h,
|
|
|
|
|
|
(select servers.ip,round(avg(metr.curr_con+metr.cur_ssl_con), 1) as avg_cur_3d from servers
|
|
|
left join metrics as metr on metr.serv = servers.ip
|
|
|
where servers.metrics = 1 and
|
|
|
metr.date <= datetime('now', 'localtime') and metr.date >= datetime('now', '-3 days', 'localtime')
|
|
|
group by servers.ip ) as avg_cur_3d,
|
|
|
|
|
|
(select servers.ip,max(metr.curr_con) as max_con_1h from servers
|
|
|
left join metrics as metr on metr.serv = servers.ip
|
|
|
where servers.metrics = 1 and
|
|
|
metr.date <= datetime('now', 'localtime') and metr.date >= datetime('now', '-1 hours', 'localtime')
|
|
|
group by servers.ip) as max_con_1h,
|
|
|
|
|
|
(select servers.ip,max(metr.curr_con) as max_con_24h from servers
|
|
|
left join metrics as metr on metr.serv = servers.ip
|
|
|
where servers.metrics = 1 and
|
|
|
metr.date <= datetime('now', 'localtime') and metr.date >= datetime('now', '-24 hours', 'localtime')
|
|
|
group by servers.ip) as max_con_24h,
|
|
|
|
|
|
(select servers.ip,max(metr.curr_con) as max_con_3d from servers
|
|
|
left join metrics as metr on metr.serv = servers.ip
|
|
|
where servers.metrics = 1 and
|
|
|
metr.date <= datetime('now', 'localtime') and metr.date >= datetime('now', '-3 days', 'localtime')
|
|
|
group by servers.ip ) as max_con_3d
|
|
|
|
|
|
where ip.ip=hostname.ip
|
|
|
and ip.ip=avg_sess_1h.ip
|
|
|
and ip.ip=avg_sess_24h.ip
|
|
|
and ip.ip=avg_sess_3d.ip
|
|
|
and ip.ip=max_sess_1h.ip
|
|
|
and ip.ip=max_sess_24h.ip
|
|
|
and ip.ip=max_sess_3d.ip
|
|
|
and ip.ip=avg_cur_1h.ip
|
|
|
and ip.ip=avg_cur_24h.ip
|
|
|
and ip.ip=avg_cur_3d.ip
|
|
|
and ip.ip=max_con_1h.ip
|
|
|
and ip.ip=max_con_24h.ip
|
|
|
and ip.ip=max_con_3d.ip
|
|
|
|
|
|
group by hostname.ip """ % groups
|
|
|
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
return cur.fetchall()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def get_setting(param, **kwargs):
|
|
|
con, cur = get_cur()
|
|
|
sql = """select value from `settings` where param='%s' """ % param
|
|
|
if kwargs.get('all'):
|
|
|
sql = """select * from `settings` order by section desc"""
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
if kwargs.get('all'):
|
|
|
return cur.fetchall()
|
|
|
else:
|
|
|
for value in cur.fetchone():
|
|
|
return value
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def update_setting(param, val):
|
|
|
con, cur = get_cur()
|
|
|
sql = """update `settings` set `value` = '%s' where param = '%s' """ % (val, param)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
return True
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
return False
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def get_ver():
|
|
|
con, cur = get_cur()
|
|
|
sql = """ select * from version; """
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
for ver in cur.fetchall():
|
|
|
return ver[0]
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def select_roles(**kwargs):
|
|
|
con, cur = get_cur()
|
|
|
sql = """select * from role ORDER BY id"""
|
|
|
if kwargs.get("roles") is not None:
|
|
|
sql = """select * from role where name='%s' """ % kwargs.get("roles")
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
return cur.fetchall()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def select_alert(**kwargs):
|
|
|
con, cur = get_cur()
|
|
|
sql = """select ip from servers where alert = 1 """
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
return cur.fetchall()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def select_keep_alive(**kwargs):
|
|
|
con, cur = get_cur()
|
|
|
sql = """select ip from servers where active = 1 """
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
return cur.fetchall()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def select_keealived(serv, **kwargs):
|
|
|
con, cur = get_cur()
|
|
|
sql = """select keepalived from `servers` where ip='%s' """ % serv
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
for value in cur.fetchone():
|
|
|
return value
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def update_keepalived(serv):
|
|
|
con, cur = get_cur()
|
|
|
sql = """update `servers` set `keepalived` = '1' where ip = '%s' """ % serv
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
return True
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
return False
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def select_nginx(serv, **kwargs):
|
|
|
con, cur = get_cur()
|
|
|
sql = """select nginx from `servers` where ip='%s' """ % serv
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
for value in cur.fetchone():
|
|
|
return value
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def update_nginx(serv):
|
|
|
con, cur = get_cur()
|
|
|
sql = """update `servers` set `nginx` = '1' where ip = '%s' """ % serv
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
return True
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
return False
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def update_haproxy(serv):
|
|
|
con, cur = get_cur()
|
|
|
sql = """update `servers` set `haproxy` = '1' where ip = '%s' """ % serv
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
return True
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
return False
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def update_server_pos(pos, id):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ update servers set
|
|
|
pos = '%s'
|
|
|
where id = '%s'""" % (pos, id)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def check_token_exists(token):
|
|
|
try:
|
|
|
import http.cookies
|
|
|
import os
|
|
|
cookie = http.cookies.SimpleCookie(os.environ.get("HTTP_COOKIE"))
|
|
|
user_id = cookie.get('uuid')
|
|
|
if get_token(user_id.value) == token:
|
|
|
return True
|
|
|
else:
|
|
|
try:
|
|
|
funct.logging('localhost', ' tried do action with wrong token', haproxywi=1, login=1)
|
|
|
except:
|
|
|
funct.logging('localhost', ' An action with wrong token', haproxywi=1)
|
|
|
return False
|
|
|
except:
|
|
|
try:
|
|
|
funct.logging('localhost', ' cannot check token', haproxywi=1, login=1)
|
|
|
except:
|
|
|
funct.logging('localhost', ' Cannot check token', haproxywi=1)
|
|
|
return False
|
|
|
|
|
|
|
|
|
def insert_smon(server, port, enable, proto, uri, body, group, desc, telegram, user_group):
|
|
|
try:
|
|
|
http = proto+':'+uri
|
|
|
except:
|
|
|
http = ''
|
|
|
con, cur = get_cur()
|
|
|
sql = """INSERT INTO smon (ip, port, en, `desc`, `group`, http, body, telegram_channel_id, user_group, `status`)
|
|
|
VALUES ('%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '3')
|
|
|
""" % (server, port, enable, desc, group, http, body, telegram, user_group)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
return False
|
|
|
else:
|
|
|
return True
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def select_smon(user_group, **kwargs):
|
|
|
con, cur = get_cur()
|
|
|
|
|
|
if user_group == '1':
|
|
|
user_group = ''
|
|
|
else:
|
|
|
if kwargs.get('ip'):
|
|
|
user_group = "and user_group = '%s'" % user_group
|
|
|
else:
|
|
|
user_group = "where user_group='%s'" % user_group
|
|
|
|
|
|
if kwargs.get('ip'):
|
|
|
try:
|
|
|
http = kwargs.get('proto')+':'+kwargs.get('uri')
|
|
|
except:
|
|
|
http = ''
|
|
|
sql = """select id, ip, port, en, http, body, telegram_channel_id, `desc`, `group`, user_group from smon
|
|
|
where ip='%s' and port='%s' and http='%s' and body='%s' %s
|
|
|
""" % (kwargs.get('ip'), kwargs.get('port'), http, kwargs.get('body'), user_group)
|
|
|
elif kwargs.get('action') == 'add':
|
|
|
sql = """select id, ip, port, en, http, body, telegram_channel_id, `desc`, `group`, user_group from smon
|
|
|
%s order by `group`""" % user_group
|
|
|
else:
|
|
|
sql = """select * from `smon` %s """ % user_group
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
else:
|
|
|
return cur.fetchall()
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def delete_smon(id, user_group):
|
|
|
con, cur = get_cur()
|
|
|
sql = """delete from smon
|
|
|
where id = '%s' and user_group = '%s' """ % (id, user_group)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
return False
|
|
|
else:
|
|
|
return True
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def update_smon(id, ip, port, body, telegram, group, desc, en):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ update smon set
|
|
|
ip = '%s',
|
|
|
port = '%s',
|
|
|
body = '%s',
|
|
|
telegram_channel_id = '%s',
|
|
|
`group` = '%s',
|
|
|
`desc` = '%s',
|
|
|
en = '%s'
|
|
|
where id = '%s'""" % (ip, port, body, telegram, group, desc, en, id)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
con.commit()
|
|
|
return True
|
|
|
except sqltool.Error as e:
|
|
|
funct.out_error(e)
|
|
|
con.rollback()
|
|
|
return False
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def select_en_service():
|
|
|
con, cur = get_cur()
|
|
|
sql = """ select ip, port, telegram_channel_id, id from smon where en = 1"""
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
out_error(e)
|
|
|
else:
|
|
|
return cur.fetchall()
|
|
|
|
|
|
|
|
|
def select_status(id):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ select status from smon where id = '%s' """ % (id)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
print("An error occurred:", e)
|
|
|
else:
|
|
|
for status in cur:
|
|
|
return status[0]
|
|
|
|
|
|
|
|
|
def select_http_status(id):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ select http_status from smon where id = '%s' """ % (id)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
print("An error occurred:", e)
|
|
|
else:
|
|
|
for status in cur:
|
|
|
return status[0]
|
|
|
|
|
|
|
|
|
def select_body_status(id):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ select body_status from smon where id = '%s' """ % (id)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
print("An error occurred:", e)
|
|
|
else:
|
|
|
for status in cur:
|
|
|
return status[0]
|
|
|
|
|
|
|
|
|
def select_script(id):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ select script from smon where id = '%s' """ % (id)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
print("An error occurred:", e)
|
|
|
else:
|
|
|
for script in cur:
|
|
|
return script[0]
|
|
|
|
|
|
|
|
|
def select_http(id):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ select http from smon where id = '%s' """ % (id)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
print("An error occurred:", e)
|
|
|
else:
|
|
|
for script in cur:
|
|
|
return script[0]
|
|
|
|
|
|
|
|
|
def select_body(id):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ select body from smon where id = '%s' """ % (id)
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
print("An error occurred:", e)
|
|
|
else:
|
|
|
for script in cur:
|
|
|
return script[0]
|
|
|
|
|
|
|
|
|
def change_status(status, id):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ update smon set status = '%s' where id = '%s' """ % (status, id)
|
|
|
try:
|
|
|
cur.executescript(sql)
|
|
|
except sqltool.Error as e:
|
|
|
print("An error occurred:", e)
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def change_http_status(status, id):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ update smon set http_status = '%s' where id = '%s' """ % (status, id)
|
|
|
try:
|
|
|
cur.executescript(sql)
|
|
|
except sqltool.Error as e:
|
|
|
print("An error occurred:", e)
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def change_body_status(status, id):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ update smon set body_status = '%s' where id = '%s' """ % (status, id)
|
|
|
try:
|
|
|
cur.executescript(sql)
|
|
|
except sqltool.Error as e:
|
|
|
print("An error occurred:", e)
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def add_sec_to_state_time(time, id):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ update smon set time_state = '%s' where id = '%s' """ % (time, id)
|
|
|
try:
|
|
|
cur.executescript(sql)
|
|
|
except sqltool.Error as e:
|
|
|
print("An error occurred:", e)
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def set_to_zero_time_state(id):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ update smon set time_state = 0 where id = '%s' """ % (id)
|
|
|
try:
|
|
|
cur.executescript(sql)
|
|
|
except sqltool.Error as e:
|
|
|
print("An error occurred:", e)
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def response_time(time, id):
|
|
|
con, cur = get_cur()
|
|
|
sql = """ update smon set response_time = '%s' where id = '%s' """ % (time, id)
|
|
|
try:
|
|
|
cur.executescript(sql)
|
|
|
except sqltool.Error as e:
|
|
|
print("An error occurred:", e)
|
|
|
cur.close()
|
|
|
con.close()
|
|
|
|
|
|
|
|
|
def smon_list(user_group):
|
|
|
con, cur = get_cur()
|
|
|
|
|
|
if user_group == '1':
|
|
|
user_group = ''
|
|
|
else:
|
|
|
user_group = "where user_group='%s'" % user_group
|
|
|
|
|
|
sql = """ select ip,port,status,en,`desc`,response_time,time_state,`group`,script,http,http_status,body,body_status
|
|
|
from smon %s order by `group` desc """ % user_group
|
|
|
try:
|
|
|
cur.execute(sql)
|
|
|
except sqltool.Error as e:
|
|
|
out_error(e)
|
|
|
else:
|
|
|
return cur.fetchall()
|
|
|
|
|
|
|
|
|
form = funct.form
|
|
|
error_mess = 'error: All fields must be completed'
|
|
|
|
|
|
|
|
|
def check_token():
|
|
|
if not check_token_exists(form.getvalue('token')):
|
|
|
print('Content-type: text/html\n')
|
|
|
print("error: Your token has been expired")
|
|
|
import sys
|
|
|
sys.exit()
|
|
|
|
|
|
|
|
|
def show_update_option(option):
|
|
|
from jinja2 import Environment, FileSystemLoader
|
|
|
env = Environment(loader=FileSystemLoader('templates/ajax'), autoescape=True)
|
|
|
template = env.get_template('/new_option.html')
|
|
|
|
|
|
print('Content-type: text/html\n')
|
|
|
template = template.render(options=select_options(option=option))
|
|
|
print(template)
|
|
|
|
|
|
|
|
|
def show_update_savedserver(server):
|
|
|
from jinja2 import Environment, FileSystemLoader
|
|
|
env = Environment(loader=FileSystemLoader('templates/ajax'), autoescape=True)
|
|
|
template = env.get_template('/new_saved_servers.html')
|
|
|
|
|
|
print('Content-type: text/html\n')
|
|
|
template = template.render(server=select_saved_servers(server=server))
|
|
|
print(template)
|
|
|
|
|
|
|
|
|
if form.getvalue('getoption'):
|
|
|
group = form.getvalue('getoption')
|
|
|
term = form.getvalue('term')
|
|
|
print('Content-type: application/json\n')
|
|
|
check_token()
|
|
|
options = select_options(group=group,term=term)
|
|
|
|
|
|
a = {}
|
|
|
v = 0
|
|
|
for i in options:
|
|
|
a[v] = i[0]
|
|
|
v = v + 1
|
|
|
import json
|
|
|
print(json.dumps(a))
|
|
|
|
|
|
|
|
|
if form.getvalue('newtoption'):
|
|
|
option = form.getvalue('newtoption')
|
|
|
group = form.getvalue('newoptiongroup')
|
|
|
print('Content-type: text/html\n')
|
|
|
check_token()
|
|
|
if option is None or group is None:
|
|
|
print(error_mess)
|
|
|
else:
|
|
|
if insert_new_option(option, group):
|
|
|
show_update_option(option)
|
|
|
|
|
|
|
|
|
if form.getvalue('updateoption') is not None:
|
|
|
option = form.getvalue('updateoption')
|
|
|
id = form.getvalue('id')
|
|
|
check_token()
|
|
|
if option is None or id is None:
|
|
|
print('Content-type: text/html\n')
|
|
|
print(error_mess)
|
|
|
else:
|
|
|
update_options(option, id)
|
|
|
|
|
|
|
|
|
if form.getvalue('optiondel') is not None:
|
|
|
print('Content-type: text/html\n')
|
|
|
check_token()
|
|
|
if delete_option(form.getvalue('optiondel')):
|
|
|
print("Ok")
|
|
|
|
|
|
|
|
|
if form.getvalue('getsavedserver'):
|
|
|
group = form.getvalue('getsavedserver')
|
|
|
term = form.getvalue('term')
|
|
|
print('Content-type: application/json\n')
|
|
|
check_token()
|
|
|
servers = select_saved_servers(group=group,term=term)
|
|
|
|
|
|
a = {}
|
|
|
v = 0
|
|
|
for i in servers:
|
|
|
a[v] = {}
|
|
|
a[v]['value'] = {}
|
|
|
a[v]['desc'] = {}
|
|
|
a[v]['value'] = i[0]
|
|
|
a[v]['desc'] = i[1]
|
|
|
v = v + 1
|
|
|
import json
|
|
|
print(json.dumps(a))
|
|
|
|
|
|
|
|
|
if form.getvalue('newsavedserver'):
|
|
|
savedserver = form.getvalue('newsavedserver')
|
|
|
description = form.getvalue('newsavedserverdesc')
|
|
|
group = form.getvalue('newsavedservergroup')
|
|
|
print('Content-type: text/html\n')
|
|
|
check_token()
|
|
|
if savedserver is None or group is None:
|
|
|
print(error_mess)
|
|
|
else:
|
|
|
if insert_new_savedserver(savedserver, description, group):
|
|
|
show_update_savedserver(savedserver)
|
|
|
|
|
|
|
|
|
if form.getvalue('updatesavedserver') is not None:
|
|
|
savedserver = form.getvalue('updatesavedserver')
|
|
|
description = form.getvalue('description')
|
|
|
id = form.getvalue('id')
|
|
|
print('Content-type: text/html\n')
|
|
|
check_token()
|
|
|
if savedserver is None or id is None:
|
|
|
print(error_mess)
|
|
|
else:
|
|
|
update_savedserver(savedserver, description, id)
|
|
|
|
|
|
|
|
|
if form.getvalue('savedserverdel') is not None:
|
|
|
print('Content-type: text/html\n')
|
|
|
check_token()
|
|
|
if delete_savedserver(form.getvalue('savedserverdel')):
|
|
|
print("Ok")
|
