def build(cls, name, array, dim_names=None):
"""
Construct a LIGO Light Weight XML Array document subtree
from a numpy array object.
Example:
>>> import numpy, sys
>>> a = numpy.arange(12, dtype = "double")
>>> a.shape = (4, 3)
>>> Array.build(u"test", a).write(sys.stdout) # doctest: +NORMALIZE_WHITESPACE
<Array Type="real_8" Name="test:array">
<Dim>3</Dim>
<Dim>4</Dim>
<Stream Delimiter=" " Type="Local">
0 3 6 9
1 4 7 10
2 5 8 11
</Stream>
</Array>
"""
# Type must be set for .__init__(); easier to set Name
# afterwards to take advantage of encoding handled by
# attribute proxy
elem = cls(
Attributes({u"Type": ligolwtypes.FromNumPyType[str(array.dtype)]}))
elem.Name = name
if dim_names is None:
dim_names = [None] * len(array.shape)
elif len(dim_names) != len(array.shape):
raise ValueError(
"dim_names must be same length as number of dimensions")
for name, n in reversed(zip(dim_names, array.shape)):
child = elem.appendChild(ligolw.Dim())
if name is not None:
child.Name = name
child.n = n
elem.appendChild(
ArrayStream(
Attributes({
u"Type": ArrayStream.Type.default,
u"Delimiter": ArrayStream.Delimiter.default
})))
elem.array = array
return elem
def _write_scaninfo(self):
for scan in self.scaninfo:
if type(scan) == type({}):
self.write_parser.startElement("scaninfo",
Attributes(dict(type = scan.get("type", ""),
protocol = scan.get("protocol", ""),
numservices = scan.get("numservices", ""),
services = scan.get("services", ""))))
self.write_parser.endElement("scaninfo")
def _write_permissions(self):
permissions = self.permissions
self.writer.startElement("permissions", Attributes({}))
for perm in permissions:
attrs = Attributes({'id': perm.id,
'type': perm.type})
self.writer.startElement("permission", attrs)
if perm.description:
self.writer.startElement("description", Attributes({}))
self.writer.characters(perm.description)
self.writer.endElement("description")
for constraint in perm.constraints:
self.writer.startElement("constraint",
Attributes({'type': constraint.type}))
self.writer.characters(constraint.content)
self.writer.endElement("constraint")
self.writer.endElement("permission")
self.writer.endElement("permissions")
def _write_runstats(self):
##################
# Runstats element
self.write_parser.startElement("runstats", Attributes(dict()))
## Finished element
self.write_parser.startElement("finished",
Attributes(dict(time = str(self.finish_epoc_time))))
self.write_parser.endElement("finished")
## Hosts element
self.write_parser.startElement("hosts",
Attributes(dict(up = str(self.hosts_up),
down = str(self.hosts_down),
total = str(self.hosts_scanned))))
self.write_parser.endElement("hosts")
self.write_parser.endElement("runstats")
def startElement(self, name, attrs):
if name == "record" and self.processed > 0 \
and self.processed % self.groups_of == 0:
self.new_handler()
XMLFilterBase.startDocument(self)
XMLFilterBase.startPrefixMapping(self, "", self.uri)
XMLFilterBase.startElement(self, "collection", Attributes({}))
if name != "collection":
XMLFilterBase.startElement(self, name, attrs)
def _write_roles(self):
roles = self.roles
self.writer.startElement("roles", Attributes({}))
for role in roles:
self.writer.startElement("role",
Attributes({'id': role.id}))
if role.description:
self.writer.startElement("description", Attributes({}))
self.writer.characters(role.description)
self.writer.endElement("description")
if role.permissions:
self.writer.startElement("permissions", Attributes({}))
for p in role.permissions:
self.writer.startElement("permission",
Attributes({"ref": p.id}))
self.writer.endElement("permission")
self.writer.endElement("permissions")
self.writer.endElement("role")
self.writer.endElement("roles")
def from_array(name, array, dim_names=None):
"""
Construct a LIGO Light Weight XML Array document subtree from a
numpy array object.
Example:
>>> import numpy, sys
>>> a = numpy.arange(12, dtype = "double")
>>> a.shape = (4, 3)
>>> from_array(u"test", a).write(sys.stdout) # doctest: +NORMALIZE_WHITESPACE
<Array Type="real_8" Name="test:array">
<Dim>3</Dim>
<Dim>4</Dim>
<Stream Delimiter=" " Type="Local">
0 3 6 9
1 4 7 10
2 5 8 11
</Stream>
</Array>
"""
# Type must be set for .__init__(); easier to set Name afterwards
# to take advantage of encoding handled by attribute proxy
doc = Array(
Attributes({u"Type": ligolwtypes.FromNumPyType[str(array.dtype)]}))
doc.Name = name
for n, dim in enumerate(reversed(array.shape)):
child = ligolw.Dim()
if dim_names is not None:
child.Name = dim_names[n]
child.pcdata = unicode(dim)
doc.appendChild(child)
child = ArrayStream(
Attributes({
u"Type": ArrayStream.Type.default,
u"Delimiter": ArrayStream.Delimiter.default
}))
doc.appendChild(child)
doc.array = array
return doc
def write_xml_node(self, root):
"""
"""
for child in root:
self.startElement(child.get_name(), Attributes(child.get_attrs()))
if child.get_text() != "":
self.characters(child.get_text())
self.write_xml_node(child.get_children())
self.endElement(child.get_name())
def _write_nmaprun(self):
self.write_parser.startElement("nmaprun",
Attributes(dict(annotation = str(self.profile_annotation),
args = str(self.nmap_command),
description = str(self.profile_description),
hint = str(self.profile_hint),
nmap_output = str(self.nmap_output),
options = str(self.profile_options),
profile = str(self.profile),
profile_name = str(self.profile_name),
scanner = str(self.scanner),
start = str(self.start),
startstr = str(self.formated_date),
target = str(self.target),
version = str(self.scanner_version),
scan_name = str(self.scan_name))))
def _write_nmaprun(self, writer):
writer.startElement("nmaprun",
Attributes(dict(args = str(self.nmap_command),
description = str(self.profile_description),
nmap_output = self.nmap_output,
# Note that option arguments are discarded. This
# is incorrect behavior.
options = str(",".join(self.profile_options.keys())),
profile = str(self.profile),
profile_name = str(self.profile_name),
scanner = str(self.scanner),
start = str(self.start),
startstr = str(self.formated_date),
target = str(self.target),
version = str(self.scanner_version),
scan_name = str(self.scan_name))))
def startElement(self, name, attrs):
if self.in_universe >= 0:
self.in_universe += 1
if name == "zml_file":
if attrs.getValue("version") != "0.1":
raise FilterError, "Only format 0.1 is supported in this handler."
attrs = Attributes({"version": "0.2"})
elif name == "model_object" and attrs["class"] == "Universe":
self.in_universe = 0
elif self.in_universe == 1:
if name == "array" and attrs["label"] == "cell":
self.recording = "cell"
self.cell = []
elif name == "array" and attrs["label"] == "cell_active":
self.recording = "cell_active"
self.cell_active = []
if self.recording is None:
XMLFilterBase.startElement(self, name, attrs)
def endElement(self, name):
if self.in_universe >= 0:
self.in_universe -= 1
if self.in_universe == -1:
# send the recorded tags in the new format
if not (self.cell is None and self.cell_active is None):
if self.cell is None:
self.cell = numpy.identity(3, float)*20.0
if self.cell_active is None:
self.cell_active = numpy.zeros(3, bool)
XMLFilterBase.startElement(self, "unit_cell", Attributes({"label": "cell"}))
# matrix
XMLFilterBase.startElement(self, "array", Attributes({"label": "matrix"}))
XMLFilterBase.startElement(self, "shape", Attributes({}))
XMLFilterBase.characters(self, "3 3")
XMLFilterBase.endElement(self, "shape")
XMLFilterBase.startElement(self, "cells", Attributes({}))
XMLFilterBase.characters(self, " ".join(str(v) for v in self.cell.ravel()))
XMLFilterBase.endElement(self, "cells")
XMLFilterBase.endElement(self, "array")
# matrix
XMLFilterBase.startElement(self, "array", Attributes({"label": "active"}))
XMLFilterBase.startElement(self, "shape", Attributes({}))
XMLFilterBase.characters(self, "3")
XMLFilterBase.endElement(self, "shape")
XMLFilterBase.startElement(self, "cells", Attributes({}))
XMLFilterBase.characters(self, " ".join(str(v) for v in self.cell_active))
XMLFilterBase.endElement(self, "cells")
XMLFilterBase.endElement(self, "array")
# end unit cell
XMLFilterBase.endElement(self, "unit_cell")
if self.recording is None:
XMLFilterBase.endElement(self, name)
else:
if name == "array" and self.recording == "cell":
self.recording = None
words = (" ".join(self.cell)).split()[2:]
self.cell = numpy.array([float(v) for v in words])
self.cell.shape = (3,3)
if name == "array" and self.recording == "cell_active":
self.recording = None
words = (" ".join(self.cell_active)).split()[1:]
self.cell_active = numpy.array([eval(v) for v in words])
self.cell_active.shape = (3,)
def write_xml(self, xml_file=None):
xml_file = xml_file or SECURITY_FILE
if self._locked:
raise ResourceBusyError
else:
self._locked = True
xml = open(xml_file, "w", 1)
xml.flush()
xml.seek(0)
self.writer = XMLGenerator(xml)
self.writer.startDocument()
self.writer.startElement("security", Attributes({}))
self._write_permissions()
self._write_roles()
self._write_users()
self.writer.endElement("security")
self.writer.endDocument()
xml.flush()
xml.close()
del xml
self._locked = False
def _write_users(self):
users = self.users
self.writer.startElement("users", Attributes({}))
for user in users:
attrs = Attributes({'login': user.login,
'superuser': user.superuser and "yes" or "no"})
self.writer.startElement("user", attrs)
if user.name:
self.writer.startElement("name", Attributes({}))
self.writer.characters(user.name)
self.writer.endElement("name")
self.writer.startElement("password", Attributes({}))
self.writer.characters(user.password)
self.writer.endElement("password")
if user.roles:
self.writer.startElement("roles", Attributes({}))
for r in user.roles:
self.writer.startElement("role",
Attributes({'ref': r.id}))
self.writer.endElement("role")
self.writer.endElement("roles")
self.writer.endElement("user")
self.writer.endElement("users")
def _write_verbose(self, writer):
writer.startElement("verbose", Attributes(dict(
level=str(self.verbose_level))))
writer.endElement("verbose")
def _write_verbose(self):
self.write_parser.startElement("verbose", Attributes(dict(
level=str(self.verbose_level))))
self.write_parser.endElement("verbose")
def _write_debugging(self):
self.write_parser.startElement("debugging", Attributes(dict(
level=str(self.debugging_level))))
self.write_parser.endElement("debugging")
def _write_hosts(self):
for host in self.hosts:
# Start host element
self.write_parser.startElement("host",
Attributes(dict(comment=host.comment)))
# Status element
self.write_parser.startElement("status",
Attributes(dict(state=host.state)))
self.write_parser.endElement("status")
##################
# Address elements
## IPv4
if type(host.ip) == type({}):
self.write_parser.startElement("address",
Attributes(dict(addr=host.ip.get("addr", ""),
vendor=host.ip.get("vendor", ""),
addrtype=host.ip.get("type", ""))))
self.write_parser.endElement("address")
## IPv6
if type(host.ipv6) == type({}):
self.write_parser.startElement("address",
Attributes(dict(addr=host.ipv6.get("addr", ""),
vendor=host.ipv6.get("vendor", ""),
addrtype=host.ipv6.get("type", ""))))
self.write_parser.endElement("address")
## MAC
if type(host.mac) == type({}):
self.write_parser.startElement("address",
Attributes(dict(addr=host.mac.get("addr", ""),
vendor=host.mac.get("vendor", ""),
addrtype=host.mac.get("type", ""))))
self.write_parser.endElement("address")
# End of Address elements
#########################
###################
# Hostnames element
self.write_parser.startElement("hostnames", Attributes({}))
for hname in host.hostnames:
if type(hname) == type({}):
self.write_parser.startElement("hostname",
Attributes(dict(name = hname.get("hostname", ""),
type = hname.get("hostname_type", ""))))
self.write_parser.endElement("hostname")
self.write_parser.endElement("hostnames")
# End of Hostnames element
##########################
###############
# Ports element
self.write_parser.startElement("ports", Attributes({}))
for ps in host.ports:
## Extraports elements
for ext in ps["extraports"]:
if type(ext) == type({}):
self.write_parser.startElement("extraports",
Attributes(dict(count = ext.get("count", ""),
state = ext.get("state", ""))))
self.write_parser.endElement("extraports")
## Port elements
for p in ps["port"]:
if type(p) == type({}):
self.write_parser.startElement("port",
Attributes(dict(portid = p.get("portid", ""),
protocol = p.get("protocol", ""))))
### Port state
self.write_parser.startElement("state",
Attributes(dict(state=p.get("port_state", ""))))
self.write_parser.endElement("state")
### Port service info
self.write_parser.startElement("service",
Attributes(dict(conf = p.get("service_conf", ""),
method = p.get("service_method", ""),
name = p.get("service_name", ""),
product = p.get("service_product", ""),
version = p.get("service_version", ""),
extrainfo = p.get("service_extrainfo", "")\
)))
self.write_parser.endElement("service")
self.write_parser.endElement("port")
self.write_parser.endElement("ports")
# End of Ports element
######################
############
# OS element
self.write_parser.startElement("os", Attributes({}))
## Ports used elements
for pu in host.ports_used:
if type(pu) == type({}):
self.write_parser.startElement("portused",
Attributes(dict(state = pu.get("state", ""),
proto = pu.get("proto", ""),
portid = pu.get("portid", ""))))
self.write_parser.endElement("portused")
## Osclass elements
for oc in host.osclasses:
if type(oc) == type({}):
self.write_parser.startElement("osclass",
Attributes(dict(vendor = oc.get("vendor", ""),
osfamily = oc.get("osfamily", ""),
type = oc.get("type", ""),
osgen = oc.get("osgen", ""),
accuracy = oc.get("accuracy", ""))))
self.write_parser.endElement("osclass")
## Osmatch elements
if type(host.osmatch) == type({}):
self.write_parser.startElement("osmatch",
Attributes(dict(name = host.osmatch.get("name", ""),
accuracy = host.osmatch.get("accuracy", ""))))
self.write_parser.endElement("osmatch")
self.write_parser.endElement("os")
# End of OS element
###################
# Uptime element
if type(host.uptime) == type({}):
self.write_parser.startElement("uptime",
Attributes(dict(seconds = host.uptime.get("seconds", ""),
lastboot = host.uptime.get("lastboot", ""))))
self.write_parser.endElement("uptime")
#####################
# Sequences elementes
## TCP Sequence element
# Cannot use dict() here, because of the 'class' attribute.
if type(host.tcpsequence) == type({}):
self.write_parser.startElement("tcpsequence",
Attributes({"index":host.tcpsequence.get("index", ""),
"class":host.tcpsequence.get("class", ""),
"difficulty":host.tcpsequence.get("difficulty", ""),
"values":host.tcpsequence.get("values", "")}))
self.write_parser.endElement("tcpsequence")
## IP ID Sequence element
if type(host.ipidsequence) == type({}):
self.write_parser.startElement("ipidsequence",
Attributes({"class":host.ipidsequence.get("class", ""),
"values":host.ipidsequence.get("values", "")}))
self.write_parser.endElement("ipidsequence")
## TCP TS Sequence element
if type(host.tcptssequence) == type({}):
self.write_parser.startElement("tcptssequence",
Attributes({"class":host.tcptssequence.get("class", ""),
"values":host.tcptssequence.get("values", "")}))
self.write_parser.endElement("tcptssequence")
# End of sequences elements
###########################
# End host element
self.write_parser.endElement("host")
def _write_debugging(self, writer):
writer.startElement("debugging", Attributes(dict(
level=str(self.debugging_level))))
writer.endElement("debugging")
