class DeployKey(db.Model):
__tablename__ = 'deploy_key'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(32), nullable=False)
deploy_key = db.Column(db.String(10), unique=True, nullable=False)
created_at = db.Column(db.DateTime(timezone=True),
default=current_datetime())
updated_at = db.Column(db.DateTime(timezone=True),
onupdate=current_datetime())
expired_at = db.Column(db.DateTime(timezone=True),
onupdate=(current_datetime() +
datetime.timedelta(days=7)))
status = db.Column(db.Integer, default=1)
user_id = db.Column(db.Integer, db.ForeignKey("users.id"))
def __str__(self):
return "DeployKey: {}".format(self.deploy_key)
def __repr__(self):
return "<DeployKey of {}>".format(self.user.email)
def check_expired(self):
return current_datetime().replace(
tzinfo=None) > self.expired_at.replace(tzinfo=None)
def show_date(self, date):
return date.strftime('%d/%m/%Y')
def to_iso_date(self, date):
return date.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
def generate_script(self, host_url, api_key):
script = "wget {0}/api/v1/deploy/script/?api_key={1} -O deploy.sh && sudo bash deploy.sh "\
"{0} {1} {2};sudo rm -rf deploy.sh".format(host_url, api_key, self.deploy_key )
return script
def _statusToString(self):
if self.status == 0:
return 'Deploy key are expired'
elif self.status == 1:
return 'Deploy key is active'
else:
return 'Deploy key already used'
def to_dict(self):
return dict(name=self.name,
deploy_key=self.deploy_key,
expired_at=self.expired_at,
identifier=self.user.identifier,
status=self.status,
msg=self._statusToString())
class ApiKey(db.Model):
__tablename__ = 'api_key'
id = db.Column(db.Integer, primary_key=True)
api_key = db.Column(db.String(64), unique=True)
user_id = db.Column(db.Integer, db.ForeignKey("users.id"))
created_at = db.Column(db.DateTime(timezone=True),
default=current_datetime())
def __str__(self):
return "ApiKey: {}".format(self.api_key)
def __repr__(self):
return "<ApiKey of {}>".format(self.user.email)
class OldAgents(db.Model):
__tablename__ = "old_agents"
id = db.Column(db.Integer, primary_key=True)
string_id = db.Column(db.String(20))
container_id = db.Column(db.String(100))
name = db.Column(db.String(64), nullable=False)
uptime = db.Column(db.Integer, default=1)
ipaddr = db.Column(db.String(64), nullable=False)
registered_at = db.Column(db.DateTime(timezone=True))
deleted_at = db.Column(db.DateTime(timezone=True), default= current_datetime())
updated_at = db.Column(db.DateTime(timezone=True))
status = db.Column(db.String(10), default="exited")
user_id = db.Column(db.Integer, db.ForeignKey("users.id"))
condition_id = db.Column(db.Integer, db.ForeignKey("conditions.id"), default=5)
def __repr__(self):
return '<Agent {}>'.format(self.ipaddr)
def show_info(self):
return '{0} ({1})'.format(self.name, self.ipaddr)
def display_uptime(self):
intervals = (
('weeks', 604800),
('days', 86400),
('hours', 3600),
('minutes', 60),
('seconds', 1)
)
seconds = self.uptime
for name, count in intervals:
value = seconds // count
if value:
seconds = seconds - value * count
if value == 1:
name = name.rstrip('s')
return "{0} {1}".format(int(value), name)
def to_dict(self):
return dict(
id = self.string_id,
name = self.name,
ipaddr = self.ipaddr,
userid = self.user_id
)
class Agents(db.Model):
__tablename__ = "agents"
id = db.Column(db.Integer, primary_key=True)
string_id = db.Column(db.String(20))
container_id = db.Column(db.String(100))
name = db.Column(db.String(64), nullable=False)
uptime = db.Column(db.Integer, default=1)
ipaddr = db.Column(db.String(64), nullable=False)
registered_at = db.Column(db.DateTime(timezone=True), default= current_datetime())
updated_at = db.Column(db.DateTime(timezone=True), default= current_datetime(), onupdate= current_datetime())
status = db.Column(db.String(10), default="exited")
user_id = db.Column(db.Integer, db.ForeignKey("users.id"))
condition_id = db.Column(db.Integer, db.ForeignKey("conditions.id"), default=5)
sensor = db.relationship('Sensor', backref='agent', lazy='dynamic', cascade="all, delete, delete-orphan")
def __repr__(self):
return '<Agent {}>'.format(self.ipaddr)
def show_info(self):
return '{0} ({1})'.format(self.name, self.ipaddr)
def display_uptime(self):
intervals = (
('weeks', 604800),
('days', 86400),
('hours', 3600),
('minutes', 60),
('seconds', 1)
)
seconds = self.uptime
for name, count in intervals:
value = seconds // count
if value:
seconds = seconds - value * count
if value == 1:
name = name.rstrip('s')
return "{0} {1}".format(int(value), name)
def update(self):
if self.condition_id != 1:
try:
if self.string_id is None:
url = "http://{0}:5000/api/v1/sensor/".format(self.ipaddr)
req = requests.get(url, {'name_container': 'fipro-agent'}, timeout=5)
else:
url = "http://{0}:5000/api/v1/sensor/{1}".format(self.ipaddr, self.string_id)
req = requests.get(url, timeout=5)
resp = req.json()
print (resp)
if req.status_code == 404:
self.condition_id = 5
self.status = "exited"
setattr(self, 'attack_count', 0)
setattr(self, 'not_found', True)
if resp.get('status'):
self._set_uptime(resp.get('sensor').get('state').get('StartedAt'))
self._set_condition(**resp.get('sensor').get('state'))
self.string_id = resp.get('sensor').get('short_id')
self.container_id = resp.get('sensor').get('id')
self.status = resp.get('sensor').get('status')
moi = MoI()
count = moi.logs.count(identifier= self.user.identifier, agent_ip= self.ipaddr)
setattr(self, 'attack_count', count)
self.attack_count = "{:,}".format(self.attack_count).replace(",",".")
except Exception as e:
print ("Error Found: {}".format(e))
self.condition_id = 5
self.status = "exited"
setattr(self, 'attack_count', 0)
setattr(self, 'error', True)
return self
def destroy(self):
self.condition_id = 1
self.status = "dead"
try:
url = "http://{0}:5000/api/v1/sensor/{1}/destroy".format(self.ipaddr, self.string_id)
requests.get(url, timeout=10)
except requests.exceptions.ConnectionError:
return self
return self
def to_dict(self):
return dict(
id = self.string_id,
name = self.name,
ipaddr = self.ipaddr
)
def to_archieved(self):
return dict(
name = self.name,
string_id = self.string_id,
container_id = self.container_id,
uptime = self.uptime,
ipaddr = self.ipaddr,
registered_at = self.registered_at,
updated_at = self.updated_at,
status = self.status,
user_id = self.user_id,
condition_id = self.container_id
)
def _set_condition(self, **kwargs):
print (kwargs)
if kwargs:
expected_conditon = ('Dead', 'Paused', 'Restarting', 'Running')
exited = True
for cond in expected_conditon:
if kwargs.get(cond):
self.condition_id = expected_conditon.index(cond) + 1
exited = False
if exited:
self.condition_id = 5
else:
raise ValueError
def _set_uptime(self, started_at):
dt_start = dateparser.parse(started_at).replace(tzinfo=pytz.utc)
dt_now = datetime.datetime.utcnow().replace(tzinfo=pytz.utc)
uptime = dt_now - dt_start
self.uptime = uptime.total_seconds()
class Sensor(db.Model):
__tablename__ = "sensor"
id = db.Column(db.Integer, primary_key=True)
string_id = db.Column(db.String(20))
container_id = db.Column(db.String(100))
uptime = db.Column(db.Integer, default=1)
name = db.Column(db.String(64), nullable=False)
type = db.Column(db.String(64), nullable=False)
status = db.Column(db.String(20), default="exited")
registered_at = db.Column(db.DateTime(timezone=True),
default=current_datetime())
updated_at = db.Column(db.DateTime(timezone=True),
default=current_datetime(),
onupdate=current_datetime())
agent_id = db.Column(db.Integer, db.ForeignKey("agents.id"))
user_id = db.Column(db.Integer, db.ForeignKey("users.id"))
condition_id = db.Column(db.Integer,
db.ForeignKey("conditions.id"),
default=0)
def __repr__(self):
return '<Sensor {}-{1}>'.format(self.id, self.type)
def display_uptime(self):
intervals = (('weeks', 604800), ('days', 86400), ('hours', 3600),
('minutes', 60), ('seconds', 1))
seconds = self.uptime
for name, count in intervals:
value = seconds // count
if value:
seconds = seconds - value * count
if value == 1:
name = name.rstrip('s')
return "{0} {1}".format(int(value), name)
def update(self):
if self.condition_id != 1:
try:
url = "http://{0}:5000/api/v1/sensor/{1}".format(
self.agent.ipaddr, self.string_id)
req = requests.get(url, timeout=5)
resp = req.json()
if req.status_code == 404:
self.condition_id = 1
self.status = "dead"
setattr(self, 'attack_count', 0)
setattr(self, 'not_found', True)
if resp.get('status', False):
print(resp.get('sensor').get('state').get('StartedAt'))
if resp.get('sensor').get('status') == "restarting":
self.uptime = 1
else:
self._set_uptime(
resp.get('sensor').get('state').get('StartedAt'))
self._set_condition(**resp.get('sensor').get('state'))
self.status = resp.get('sensor').get('status')
moi = MoI()
count = moi.logs.count(identifier=self.user.identifier,
agent_ip=self.agent.ipaddr,
sensor=self.type)
setattr(self, 'attack_count', count)
self.attack_count = "{:,}".format(
self.attack_count).replace(",", ".")
except Exception as e:
print("Error Found: {}".format(e))
self.condition_id = 5
self.status = "exited"
setattr(self, 'attack_count', 0)
setattr(self, 'error', True)
return self
def destroy(self):
if self.condition_id != 1:
try:
url = "http://{0}:5000/api/v1/sensor/{1}/destroy".format(
self.agent.ipaddr, self.string_id)
req = requests.get(url, timeout=10)
except requests.exceptions.ConnectionError:
return self
else:
print('Sensor {} already destroyed or dead!'.format(self.name))
return self
def _set_condition(self, **kwargs):
if kwargs:
expected_conditon = ('Dead', 'Paused', 'Restarting', 'Running')
exited = True
for cond in expected_conditon:
if kwargs.get(cond):
self.condition_id = expected_conditon.index(cond) + 1
exited = False
if exited:
self.condition_id = 5
else:
raise ValueError
def _set_uptime(self, started_at):
dt_start = dateparser.parse(started_at).replace(tzinfo=pytz.utc)
dt_now = datetime.datetime.utcnow().replace(tzinfo=pytz.utc)
uptime = dt_now - dt_start
sec = 1 if abs(uptime.total_seconds()) < 1 else abs(
uptime.total_seconds())
self.uptime = sec
class User(UserMixin, db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
firstname = db.Column(db.String(64), nullable=True, index=True)
lastname = db.Column(db.String(64), index=True)
email = db.Column(db.String(100), unique=True, index=True)
password_hash = db.Column(db.String(128))
registered_at = db.Column(db.DateTime(timezone=True),
default=current_datetime())
updated_at = db.Column(db.DateTime(timezone=True),
default=current_datetime(),
onupdate=current_datetime())
identifier = db.Column(db.String(32))
role_id = db.Column(db.Integer, db.ForeignKey('roles.id'))
agents = db.relationship('Agents',
backref='user',
lazy='dynamic',
cascade="all, delete, delete-orphan")
old_agents = db.relationship('OldAgents', backref='user', lazy='dynamic')
sensor = db.relationship('Sensor',
backref='user',
lazy='dynamic',
cascade="all, delete, delete-orphan")
api_key = db.relationship('ApiKey',
backref='user',
lazy='dynamic',
cascade="all, delete, delete-orphan")
deploykey = db.relationship('DeployKey',
backref='user',
lazy='dynamic',
cascade="all, delete, delete-orphan")
def __init__(self, **kwargs):
super(User, self).__init__(**kwargs)
if self.role is None:
if self.email == "*****@*****.**":
self.role = Role.query.filter_by(
permission=Permission.ADMINISTER).first()
if self.role is None:
self.role = Role.query.filter_by(default=True).first()
def fullname(self):
return "%s %s" % (self.firstname, self.lastname)
def get_apikey(self):
return self.APIKey
def can(self, permissions):
return self.role is not None and \
(self.role.permissions & permissions) == permissions
def is_admin(self):
return self.can(Permission.ADMINISTER)
@property
def password(self):
raise AttributeError('Password is not readable attribute')
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
def verify_password(self, password):
return check_password_hash(self.password_hash, password)
def reset_password(self, token, new_password):
"""Verify the new password for this user."""
s = Serializer(current_app.config['SECRET_KEY'])
try:
data = s.loads(token)
except (BadSignature, SignatureExpired):
return False
if data.get('reset') != self.id:
return False
self.password = new_password
db.session.add(self)
db.session.commit()
return True
def check_expired(self):
return current_datetime().replace(
tzinfo=None) > self.expired_at.replace(tzinfo=None)