def _itemFromValue(self, value):
if isinstance(value, tuple):
return value
return value, None
if self._support_link:
return value[0], utils.escape_html_string(value[1])
else:
return value[0]
def render(self):
cmd = self.parameters["command"]
try:
command = self.env.host_commands[cmd]
except KeyError:
raise Error("Attempt to execute unregistered command '%s'" % cmd)
command = command.replace("$host", self.parameters["host"]).split(" ")
output = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, close_fds=True).communicate()[0]
output = utils.toUnicode(output)
output = utils.escape_html_string(output).replace(" ", " ").replace("\n", "<br/>")
self.dataset["command_output"] = output
def addLabelValuesPair(self, label, values, total_link):
empty = True
for i in values.values():
if i != 0:
empty = False
break
if not self._got_value and empty:
# do not add 0 only values at the beginning of the chart
return
if self._support_link and total_link:
total_link = utils.escape_html_string(total_link)
self._labels.append(label)
clen = 0
if self._values:
clen = len(self._values.values()[0])
total = 0
for name in values.keys():
if not self._values.has_key(name):
if clen > 0:
self._values[name] = [(0, None) for i in range(0, clen)]
else:
self._values[name] = []
value = self._itemFromValue(values[name])
self._values[name].append(value)
total += value[0]
self._total.append((total, total_link))
for name in self._values.keys():
if not values.has_key(name):
self._values[name].append(self._itemFromValue(0))
self._got_value = True
def _setupDataSet(self, dataset, request, user, view=None, parameters={}):
init_dataset(dataset, self._env.config, request)
sections = confutatis.views.events_section, confutatis.views.agents_section, confutatis.views.stats_section, confutatis.views.settings_section, \
confutatis.views.about_section
section_to_tabs = { }
dataset["interface.sections"] = [ ]
for section_name, tabs in sections:
first_tab = None
for tab_name, views in tabs:
view_name = views[0]
if not user or user.has(self._views[view_name]["permissions"]):
if not first_tab:
first_tab = view_name
section_to_tabs[section_name] = []
section_to_tabs[section_name] += [ ((tab_name, utils.create_link(views[0]))) ]
if first_tab:
dataset["interface.sections"].append( (section_name, utils.create_link(first_tab)) )
if isinstance(parameters, confutatis.view.RelativeViewParameters) and parameters.has_key("origin"):
view_name = parameters["origin"]
elif view:
view_name = view["name"]
else:
view_name = None
if view_name and self._view_to_section.has_key(view_name):
active_section = self._view_to_section[view_name]
active_tab = self._view_to_tab[view_name]
tabs = section_to_tabs.get(active_section, [])
else:
active_section, tabs, active_tab = "", [ ], ""
dataset["interface.tabs"] = tabs
dataset["confutatis.user"] = user
if user:
dataset["confutatis.userlink"] = "<b><a href=\"%s\">%s</a></b>" % (utils.create_link("user_settings_display"), utils.escape_html_string(user.login))
dataset["interface.active_tab"] = active_tab
dataset["interface.active_section"] = active_section
dataset["confutatis.logout_link"] = (user and self._env.auth.canLogout()) and utils.create_link("logout") or None
def addLabelValuePair(self, label, value, link=None):
self._labels.append(label)
if self._support_link:
self._values.append((value, utils.escape_html_string(link)))
else:
self._values.append(value)
def escape_value(value):
if type(value) is str:
return escape_html_string(value)
return value
def filter(self, val, **kw):
s = Filter.filter(self, val, **kw)
return utils.escape_html_string(s)
def render(self):
criteria = getUriCriteria(self.parameters)
if criteria is not None:
ident = self.env.idmef_db.getAlertIdents(criteria)[0]
else:
ident = self.parameters["ident"]
alert = self.env.idmef_db.getAlert(ident, htmlsafe=True)
self.dataset["sections"] = [ ]
self.beginSection(self.getSectionName(alert))
self.buildTime(alert)
self.beginTable()
self.newTableEntry(_("MessageID"), alert["messageid"])
self.endTable()
self.beginTable()
self.buildClassification(alert)
self.buildImpact(alert)
self.endTable()
self.beginSection(_("Actions"))
for action in alert["assessment.action"]:
self.buildAction(action)
self.endSection()
self.buildCorrelationAlert(alert)
self.buildToolAlert(alert)
self.buildReference(alert)
self.beginSection(_("Analyzer #%d") % (len(alert["analyzer"]) - 1))
self.buildAnalyzer(alert["analyzer(-1)"])
self.buildAnalyzerList(alert)
self.endSection()
self.endSection()
self.buildSourceTarget(alert)
ip = self.buildIpHeaderTable(alert)
tcp = self.buildTcpHeaderTable(alert)
udp = self.buildUdpHeaderTable(alert)
icmp = self.buildIcmpHeaderTable(alert)
data = self.buildPayloadTable(alert)
ignored_value = {}
ip_options = []
tcp_options = []
group = ip.field_list + tcp.field_list + udp.field_list + icmp.field_list + data.field_list
self.buildAdditionalData(alert, ignore=group, ignored=ignored_value, ip_options=ip_options, tcp_options=tcp_options)
if len(ignored_value.keys()) > 0:
def blah(b):
if b >= 32 and b < 127:
return chr(b)
else:
return "."
self.beginSection(_("Network centric information"))
self.beginTable(cl="message_summary_no_border")
ip.render_table(self, "IP", ignored_value)
self.ipOptionRender(ip_options)
tcp.render_table(self, "TCP", ignored_value)
self.tcpOptionRender(tcp_options)
udp.render_table(self, "UDP", ignored_value)
icmp.render_table(self, "ICMP", ignored_value)
if ignored_value.has_key("payload"):
val = {}
payload = utils.escape_html_string(utils.hexdump(ignored_value["payload"])).replace(" ", " ")
val["payload"] = "<span class='fixed'>%s</span>" % payload
data.render_table(self, _("Payload"), val)
val["payload"] = "<div style='overflow: auto;'>%s</div>" % utils.escape_html_string(utils.toUnicode(ignored_value["payload"])).replace("\n", "<br/>")
data.render_table(self, _("ASCII Payload"), val)
self.endTable()
self.endSection()
