def to_dict(self, prefered_format='yearfirst'):
"""
Serialize to dict
:param prefered_format: string with prefered time format
:returns: dictionary
"""
if prefered_format == 'timestamp':
expires = int(datetime.timestamp(self.expires))
created = int(datetime.timestamp(self.expires))
else:
expires = utils.datetime_to_webpicker(self.expires,
prefered_format)
created = utils.datetime_to_webpicker(self.created,
prefered_format)
return {
"id": str(self.id),
"source": self.source,
"source_mask": self.source_mask,
"source_port": self.source_port,
"dest": self.dest,
"dest_mask": self.dest_mask,
"dest_port": self.dest_port,
"next_header": self.next_header,
"flags": self.flags,
"packet_len": self.packet_len,
"comment": self.comment,
"expires": expires,
"created": created,
"action": self.action.name,
"user": self.user.uuid,
"rstate": self.rstate.description
}
def to_table_source(self):
"""
Serialize to dict / user for rendering in React table
:return: dictionary
"""
s_source = self.ipv4
s_slash = ''
d_slash = ''
s_mask = ''
d_mask = ''
if self.ipv4_mask:
s_slash = '/' if self.ipv4_mask >= 0 else ''
s_mask = self.ipv4_mask if self.ipv4_mask >= 0 else ''
d_source = self.ipv6
if self.ipv6_mask:
d_slash = '/' if self.ipv6_mask >= 0 else ''
d_mask = self.ipv6_mask if self.ipv6_mask >= 0 else ''
return {
"id": "{}".format(self.id),
"ipv4": "{}{}{}".format(s_source, s_slash, s_mask),
"ipv6": "{}{}{}".format(d_source, d_slash, d_mask),
"community": self.community.name,
"comment": self.comment,
"expires": utils.datetime_to_webpicker(self.expires),
"created": utils.datetime_to_webpicker(self.created),
"user": "******".format(self.user.name),
"rstate": self.rstate.description
}
def to_dict(self, prefered_format='yearfirst'):
"""
Serialize to dict used in API
:param prefered_format: string with prefered time format
:return: dictionary
"""
if prefered_format == 'timestamp':
expires = int(datetime.timestamp(self.expires))
created = int(datetime.timestamp(self.expires))
else:
expires = utils.datetime_to_webpicker(self.expires,
prefered_format)
created = utils.datetime_to_webpicker(self.created,
prefered_format)
return {
"id": self.id,
"ipv4": self.ipv4,
"ipv4_mask": self.ipv4_mask,
"ipv6": self.ipv6,
"ipv6_mask": self.ipv6_mask,
"community": self.community.name,
"comment": self.comment,
"expires": expires,
"created": created,
"user": self.user.uuid,
"rstate": self.rstate.description
}
def ipv4_rule():
net_ranges = get_user_nets(session['user_id'])
form = IPv4Form(request.form)
# add values to form instance
form.action.choices = get_user_actions(session['user_role_ids'])
form.net_ranges = net_ranges
if request.method == 'POST' and form.validate():
model = get_ipv4_model_if_exists(form.data, 1)
if model:
model.expires = round_to_ten_minutes(webpicker_to_datetime(form.expires.data))
flash_message = u'Existing IPv4 Rule found. Expiration time was updated to new value.'
else:
model = Flowspec4(
source=form.source.data,
source_mask=form.source_mask.data,
source_port=form.source_port.data,
destination=form.dest.data,
destination_mask=form.dest_mask.data,
destination_port=form.dest_port.data,
protocol=form.protocol.data,
flags=";".join(form.flags.data),
packet_len=form.packet_len.data,
expires=round_to_ten_minutes(webpicker_to_datetime(form.expires.data)),
comment=quote_to_ent(form.comment.data),
action_id=form.action.data,
user_id=session['user_id'],
rstate_id=get_state_by_time(webpicker_to_datetime(form.expires.data))
)
flash_message = u'IPv4 Rule saved'
db.session.add(model)
db.session.commit()
flash(flash_message, 'alert-success')
# announce route if model is in active state
if model.rstate_id == 1:
route = messages.create_ipv4(model, constants.ANNOUNCE)
announce_route(route)
# log changes
log_route(session['user_id'], model, RULE_TYPES['IPv4'])
return redirect(url_for('index'))
else:
for field, errors in form.errors.items():
for error in errors:
print(u"Error in the %s field - %s" % (
getattr(form, field).label.text,
error
))
default_expires = datetime.now() + timedelta(days=7)
form.expires.data = datetime_to_webpicker(default_expires)
return render_template('forms/ipv4_rule.j2', form=form, action_url=url_for('rules.ipv4_rule'))
def rtbh_rule():
all_com = db.session.query(Community).all()
if not all_com:
insert_initial_communities()
net_ranges = get_user_nets(session['user_id'])
form = RTBHForm(request.form)
form.community.choices = get_user_communities(session['user_role_ids'])
form.net_ranges = net_ranges
if request.method == 'POST' and form.validate():
model = get_rtbh_model_if_exists(form.data, 1)
if model:
model.expires = round_to_ten_minutes(webpicker_to_datetime(form.expires.data))
flash_message = u'Existing RTBH Rule found. Expiration time was updated to new value.'
else:
model = RTBH(
ipv4=form.ipv4.data,
ipv4_mask=form.ipv4_mask.data,
ipv6=form.ipv6.data,
ipv6_mask=form.ipv6_mask.data,
community_id=form.community.data,
expires=round_to_ten_minutes(webpicker_to_datetime(form.expires.data)),
comment=quote_to_ent(form.comment.data),
user_id=session['user_id'],
rstate_id=get_state_by_time(webpicker_to_datetime(form.expires.data))
)
db.session.add(model)
db.session.commit()
flash_message = u'RTBH Rule saved'
flash(flash_message, 'alert-success')
# announce routes
if model.rstate_id == 1:
route = messages.create_rtbh(model, constants.ANNOUNCE)
announce_route(route)
# log changes
log_route(session['user_id'], model, RULE_TYPES['RTBH'])
return redirect(url_for('index'))
else:
for field, errors in form.errors.items():
for error in errors:
print(u"Error in the %s field - %s" % (
getattr(form, field).label.text,
error
))
default_expires = datetime.now() + timedelta(days=7)
form.expires.data = datetime_to_webpicker(default_expires)
return render_template('forms/rtbh_rule.j2', form=form, action_url=url_for('rules.rtbh_rule'))
def to_table_source(self):
"""
Serialize to dict
:return: dictionary
"""
s_slash = ''
d_slash = ''
s_mask = ''
d_mask = ''
s_source = self.source
if self.source_mask:
s_slash = '/' if self.source_mask >= 0 else ''
s_mask = self.source_mask if self.source_mask >= 0 else ''
d_source = self.dest
if self.dest_mask:
d_slash = '/' if self.dest_mask >= 0 else ''
d_mask = self.dest_mask if self.dest_mask >= 0 else ''
return {
"id": self.id,
"source": "{}{}{}".format(s_source, s_slash, s_mask),
"source_port": self.source_port,
"dest": "{}{}{}".format(d_source, d_slash, d_mask),
"dest_port": self.dest_port,
"protocol": self.next_header,
"flags": self.flags,
"packet_len": self.packet_len,
"comment": self.comment,
"expires": utils.datetime_to_webpicker(self.expires),
"created": utils.datetime_to_webpicker(self.created),
"action": self.action.name,
"user": self.user.uuid,
"rstate": self.rstate.description
}
def group_update():
"""
update rules
"""
rule_type = session[constants.TYPE_ARG]
model_name = DATA_MODELS_NAMED[rule_type]
form_name = DATA_FORMS_NAMED[rule_type]
to_update = request.form.getlist('delete-id')
rules_dict = session[constants.RULES_KEY]
rule_type = session[constants.TYPE_ARG]
rule_type_int = constants.RULE_TYPES[rule_type]
rules = [str(rule) for rule in rules_dict[str(rule_type_int)]]
# redirect bad request
if not set(to_update).issubset(set(rules)):
flash(u'You can edit these rules!', 'alert-danger')
return redirect(
url_for('dashboard.index',
rtype=session[constants.TYPE_ARG],
rstate=session[constants.RULE_ARG],
sort=session[constants.SORT_ARG],
squery=session[constants.SEARCH_ARG],
order=session[constants.ORDER_ARG]))
# populate the form
session['group-update'] = to_update
form = form_name(request.form)
form.net_ranges = get_user_nets(session['user_id'])
if rule_type_int > 2:
form.action.choices = [
(g.id, g.name) for g in db.session.query(Action).order_by('name')
]
if rule_type_int == 1:
form.community.choices = get_user_communities(session['user_role_ids'])
form.expires.data = datetime_to_webpicker(datetime.now())
for field in form:
if field.name not in ['expires', 'csrf_token', 'comment']:
field.render_kw = {'disabled': 'disabled'}
action_url = url_for('rules.group_update_save', rule_type=rule_type_int)
return render_template(DATA_TEMPLATES[rule_type_int],
form=form,
action_url=action_url,
editing=True,
title="Group Update")
def reactivate_rule(rule_type, rule_id):
"""
Set new time for the rule of given type identified by id
:param rule_type: string - type of rule
:param rule_id: integer - id of the rule
"""
model_name = DATA_MODELS[rule_type]
form_name = DATA_FORMS[rule_type]
model = db.session.query(model_name).get(rule_id)
form = form_name(request.form, obj=model)
form.net_ranges = get_user_nets(session['user_id'])
if rule_type > 2:
form.action.choices = [(g.id, g.name)
for g in db.session.query(Action).order_by('name')]
form.action.data = model.action_id
if rule_type == 1:
form.community.choices = get_user_communities(session['user_role_ids'])
form.community.data = model.community_id
if rule_type == 4:
form.protocol.data = model.protocol
if rule_type == 6:
form.next_header.data = model.next_header
# do not need to validate - all is readonly
if request.method == 'POST':
# set new expiration date
model.expires = round_to_ten_minutes(webpicker_to_datetime(form.expires.data))
# set again the active state
model.rstate_id = get_state_by_time(webpicker_to_datetime(form.expires.data))
model.comment = form.comment.data
db.session.commit()
flash(u'Rule successfully updated', 'alert-success')
route_model = ROUTE_MODELS[rule_type]
if model.rstate_id == 1:
# announce route
route = route_model(model, constants.ANNOUNCE)
announce_route(route)
# log changes
log_route(session['user_id'], model, rule_type)
else:
# withdraw route
route = route_model(model, constants.WITHDRAW)
announce_route(route)
# log changes
log_withdraw(session['user_id'], route, rule_type, model.id)
return redirect(url_for('dashboard.index',
rtype=session[constants.TYPE_ARG],
rstate=session[constants.RULE_ARG],
sort=session[constants.SORT_ARG],
squery=session[constants.SEARCH_ARG],
order=session[constants.ORDER_ARG]))
else:
flash_errors(form)
form.expires.data = datetime_to_webpicker(model.expires)
for field in form:
if field.name not in ['expires', 'csrf_token', 'comment']:
field.render_kw = {'disabled': 'disabled'}
action_url = url_for('rules.reactivate_rule', rule_type=rule_type, rule_id=rule_id)
return render_template(DATA_TEMPLATES[rule_type], form=form, action_url=action_url, editing=True, title="Update")
