def get_scanners(
self,
*,
filter_string: Optional[str] = None,
filter_id: Optional[str] = None,
trash: Optional[bool] = None,
details: Optional[bool] = None,
) -> Any:
"""Request a list of scanners
Arguments:
filter_string: Filter term to use for the query
filter_id: UUID of an existing filter to use for the query
trash: Whether to get the trashcan scanners instead
details: Whether to include extra details like tasks using this
scanner
Returns:
The response. See :py:meth:`send_command` for details.
"""
cmd = XmlCommand("get_scanners")
add_filter(cmd, filter_string, filter_id)
if trash is not None:
cmd.set_attribute("trash", to_bool(trash))
if details is not None:
cmd.set_attribute("details", to_bool(details))
return self._send_xml_command(cmd)
def get_notes(
self,
*,
filter_string: Optional[str] = None,
filter_id: Optional[str] = None,
details: Optional[bool] = None,
result: Optional[bool] = None,
) -> Any:
"""Request a list of notes
Arguments:
filter_string: Filter term to use for the query
filter_id: UUID of an existing filter to use for the query
details: Add info about connected results and tasks
result: Return the details of possible connected results.
Returns:
The response. See :py:meth:`send_command` for details.
"""
cmd = XmlCommand("get_notes")
add_filter(cmd, filter_string, filter_id)
if details is not None:
cmd.set_attribute("details", to_bool(details))
if result is not None:
cmd.set_attribute("result", to_bool(result))
return self._send_xml_command(cmd)
def get_alerts(
self,
*,
filter_string: Optional[str] = None,
filter_id: Optional[str] = None,
trash: Optional[bool] = None,
tasks: Optional[bool] = None,
) -> Any:
"""Request a list of alerts
Arguments:
filter: Filter term to use for the query
filter_id: UUID of an existing filter to use for the query
trash: True to request the alerts in the trashcan
tasks: Whether to include the tasks using the alerts
Returns:
The response. See :py:meth:`send_command` for details.
"""
cmd = XmlCommand("get_alerts")
add_filter(cmd, filter_string, filter_id)
if trash is not None:
cmd.set_attribute("trash", to_bool(trash))
if tasks is not None:
cmd.set_attribute("tasks", to_bool(tasks))
return self._send_xml_command(cmd)
def get_filters(
self,
*,
filter_string: Optional[str] = None,
filter_id: Optional[str] = None,
trash: Optional[bool] = None,
alerts: Optional[bool] = None,
) -> Any:
"""Request a list of filters
Arguments:
filter_string: Filter term to use for the query
filter_id: UUID of an existing filter to use for the query
trash: Whether to get the trashcan filters instead
alerts: Whether to include list of alerts that use the filter.
Returns:
The response. See :py:meth:`send_command` for details.
"""
cmd = XmlCommand("get_filters")
add_filter(cmd, filter_string, filter_id)
if trash is not None:
cmd.set_attribute("trash", to_bool(trash))
if alerts is not None:
cmd.set_attribute("alerts", to_bool(alerts))
return self._send_xml_command(cmd)
def get_port_lists(
self,
*,
filter_string: Optional[str] = None,
filter_id: Optional[str] = None,
details: Optional[bool] = None,
targets: Optional[bool] = None,
trash: Optional[bool] = None,
) -> Any:
"""Request a list of port lists
Arguments:
filter_string: Filter term to use for the query
filter_id: UUID of an existing filter to use for the query
details: Whether to include full port list details
targets: Whether to include targets using this port list
trash: Whether to get port lists in the trashcan instead
Returns:
The response. See :py:meth:`send_command` for details.
"""
cmd = XmlCommand("get_port_lists")
add_filter(cmd, filter_string, filter_id)
if details is not None:
cmd.set_attribute("details", to_bool(details))
if targets is not None:
cmd.set_attribute("targets", to_bool(targets))
if trash is not None:
cmd.set_attribute("trash", to_bool(trash))
return self._send_xml_command(cmd)
def modify_policy_set_family_selection(
self,
policy_id: str,
families: List[Tuple[str, bool, bool]],
*,
auto_add_new_families: Optional[bool] = True,
) -> Any:
"""
Selected the NVTs of a policy at a family level.
Arguments:
policy_id: UUID of policy to modify.
families: A list of tuples with the first entry being the name
of the NVT family selected, second entry a boolean indicating
whether new NVTs should be added to the family automatically,
and third entry a boolean indicating whether all nvts from
the family should be included.
auto_add_new_families: Whether new families should be added to the
policy automatically. Default: True.
"""
if not policy_id:
raise RequiredArgument(
function=self.modify_policy_set_family_selection.__name__,
argument="policy_id",
)
if not is_list_like(families):
raise InvalidArgumentType(
function=self.modify_policy_set_family_selection.__name__,
argument="families",
arg_type="list",
)
cmd = XmlCommand("modify_config")
cmd.set_attribute("config_id", str(policy_id))
_xmlfamsel = cmd.add_element("family_selection")
_xmlfamsel.add_element("growing", to_bool(auto_add_new_families))
for family in families:
_xmlfamily = _xmlfamsel.add_element("family")
_xmlfamily.add_element("name", family[0])
if len(family) != 3:
raise InvalidArgument(
"Family must be a tuple of 3. (str, bool, bool)")
if not isinstance(family[1], bool) or not isinstance(
family[2], bool):
raise InvalidArgumentType(
function=(
self.modify_policy_set_family_selection.__name__),
argument="families",
arg_type="[tuple(str, bool, bool)]",
)
_xmlfamily.add_element("all", to_bool(family[2]))
_xmlfamily.add_element("growing", to_bool(family[1]))
return self._send_xml_command(cmd)
def get_tls_certificates(
self,
*,
filter_string: Optional[str] = None,
filter_id: Optional[str] = None,
include_certificate_data: Optional[bool] = None,
details: Optional[bool] = None,
) -> Any:
"""Request a list of TLS certificates
Arguments:
filter_string: Filter term to use for the query
filter_id: UUID of an existing filter to use for the query
include_certificate_data: Whether to include the certificate data in
the response
details: Whether to include additional details of the
tls certificates
Returns:
The response. See :py:meth:`send_command` for details.
"""
cmd = XmlCommand("get_tls_certificates")
add_filter(cmd, filter_string, filter_id)
if details is not None:
cmd.set_attribute("details", to_bool(details))
if include_certificate_data is not None:
cmd.set_attribute("include_certificate_data",
to_bool(include_certificate_data))
return self._send_xml_command(cmd)
def get_tags(
self,
*,
filter_string: Optional[str] = None,
filter_id: Optional[str] = None,
trash: Optional[bool] = None,
names_only: Optional[bool] = None,
) -> Any:
"""Request a list of tags
Arguments:
filter_string: Filter term to use for the query
filter_id: UUID of an existing filter to use for the query
trash: Whether to get tags from the trashcan instead
names_only: Whether to get only distinct tag names
Returns:
The response. See :py:meth:`send_command` for details.
"""
cmd = XmlCommand("get_tags")
add_filter(cmd, filter_string, filter_id)
if trash is not None:
cmd.set_attribute("trash", to_bool(trash))
if names_only is not None:
cmd.set_attribute("names_only", to_bool(names_only))
return self._send_xml_command(cmd)
def get_scan_config_nvts(
self,
*,
details: Optional[bool] = None,
preferences: Optional[bool] = None,
preference_count: Optional[bool] = None,
timeout: Optional[bool] = None,
config_id: Optional[str] = None,
preferences_config_id: Optional[str] = None,
family: Optional[str] = None,
sort_order: Optional[str] = None,
sort_field: Optional[str] = None,
):
"""Request a list of nvts
Arguments:
details: Whether to include full details
preferences: Whether to include nvt preferences
preference_count: Whether to include preference count
timeout: Whether to include the special timeout preference
config_id: UUID of scan config to which to limit the NVT listing
preferences_config_id: UUID of scan config to use for preference
values
family: Family to which to limit NVT listing
sort_order: Sort order
sort_field: Sort field
Returns:
The response. See :py:meth:`send_command` for details.
"""
cmd = XmlCommand("get_nvts")
if details is not None:
cmd.set_attribute("details", to_bool(details))
if preferences is not None:
cmd.set_attribute("preferences", to_bool(preferences))
if preference_count is not None:
cmd.set_attribute("preference_count", to_bool(preference_count))
if timeout is not None:
cmd.set_attribute("timeout", to_bool(timeout))
if config_id:
cmd.set_attribute("config_id", config_id)
if preferences_config_id:
cmd.set_attribute("preferences_config_id", preferences_config_id)
if family:
cmd.set_attribute("family", family)
if sort_order:
cmd.set_attribute("sort_order", sort_order)
if sort_field:
cmd.set_attribute("sort_field", sort_field)
return self._send_xml_command(cmd)
def get_overrides(
self,
*,
filter_string: Optional[str] = None,
filter_id: Optional[str] = None,
details: Optional[bool] = None,
result: Optional[bool] = None,
) -> Any:
"""Request a list of overrides
Arguments:
filter_string: Filter term to use for the query
filter_id: UUID of an existing filter to use for the query
details: Whether to include full details
result: Whether to include results using the override
Returns:
The response. See :py:meth:`send_command` for details.
"""
cmd = XmlCommand("get_overrides")
add_filter(cmd, filter_string, filter_id)
if details is not None:
cmd.set_attribute("details", to_bool(details))
if result is not None:
cmd.set_attribute("result", to_bool(result))
return self._send_xml_command(cmd)
def modify_scan_config_set_family_selection(
self,
config_id: str,
families: List[Tuple[str, bool, bool]],
*,
auto_add_new_families: Optional[bool] = True,
) -> Any:
"""
Selected the NVTs of a scan config at a family level.
Arguments:
config_id: UUID of scan config to modify.
families: A list of tuples (str, bool, bool):
str: the name of the NVT family selected,
bool: add new NVTs to the family automatically,
bool: include all NVTs from the family
auto_add_new_families: Whether new families should be added to the
scan config automatically. Default: True.
"""
if not config_id:
raise RequiredArgument(
function=self.modify_scan_config_set_family_selection.__name__,
argument="config_id",
)
if not is_list_like(families):
raise InvalidArgumentType(
function=self.modify_scan_config_set_family_selection.__name__,
argument="families",
arg_type="list",
)
cmd = XmlCommand("modify_config")
cmd.set_attribute("config_id", str(config_id))
_xmlfamsel = cmd.add_element("family_selection")
_xmlfamsel.add_element("growing", to_bool(auto_add_new_families))
for family in families:
_xmlfamily = _xmlfamsel.add_element("family")
_xmlfamily.add_element("name", family[0])
if len(family) != 3:
raise InvalidArgument(
"Family must be a tuple of 3. (str, bool, bool)")
if not isinstance(family[1], bool) or not isinstance(
family[2], bool):
raise InvalidArgumentType(
function=(
self.modify_scan_config_set_family_selection.__name__),
argument="families",
arg_type="[tuple(str, bool, bool)]",
)
_xmlfamily.add_element("all", to_bool(family[2]))
_xmlfamily.add_element("growing", to_bool(family[1]))
return self._send_xml_command(cmd)
def create_user(
self,
name: str,
*,
password: Optional[str] = None,
hosts: Optional[List[str]] = None,
hosts_allow: Optional[bool] = False,
ifaces: Optional[List[str]] = None,
ifaces_allow: Optional[bool] = False,
role_ids: Optional[List[str]] = None,
) -> Any:
"""Create a new user
Arguments:
name: Name of the user
password: Password of the user
hosts: A list of host addresses (IPs, DNS names)
hosts_allow: If True allow only access to passed hosts otherwise
deny access. Default is False for deny hosts.
ifaces: A list of interface names
ifaces_allow: If True allow only access to passed interfaces
otherwise deny access. Default is False for deny interfaces.
role_ids: A list of role UUIDs for the user
Returns:
The response. See :py:meth:`send_command` for details.
"""
if not name:
raise RequiredArgument(function=self.create_user.__name__,
argument="name")
cmd = XmlCommand("create_user")
cmd.add_element("name", name)
if password:
cmd.add_element("password", password)
if hosts:
cmd.add_element(
"hosts",
to_comma_list(hosts),
attrs={"allow": to_bool(hosts_allow)},
)
if ifaces:
cmd.add_element(
"ifaces",
to_comma_list(ifaces),
attrs={"allow": to_bool(ifaces_allow)},
)
if role_ids:
for role in role_ids:
cmd.add_element("role", attrs={"id": role})
return self._send_xml_command(cmd)
def get_report(
self,
report_id: str,
*,
filter_string: Optional[str] = None,
filter_id: Optional[str] = None,
delta_report_id: Optional[str] = None,
report_format_id: Optional[Union[str, ReportFormatType]] = None,
ignore_pagination: Optional[bool] = None,
details: Optional[bool] = True,
) -> Any:
"""Request a single report
Arguments:
report_id: UUID of an existing report
filter_string: Filter term to use to filter results in the report
filter_id: UUID of filter to use to filter results in the report
delta_report_id: UUID of an existing report to compare report to.
report_format_id: UUID of report format to use
or ReportFormatType (enum)
ignore_pagination: Whether to ignore the filter terms "first" and
"rows".
details: Request additional report information details
defaults to True
Returns:
The response. See :py:meth:`send_command` for details.
"""
cmd = XmlCommand("get_reports")
if not report_id:
raise RequiredArgument(function=self.get_report.__name__,
argument="report_id")
cmd.set_attribute("report_id", report_id)
add_filter(cmd, filter_string, filter_id)
if delta_report_id:
cmd.set_attribute("delta_report_id", delta_report_id)
if report_format_id:
if isinstance(report_format_id, ReportFormatType):
report_format_id = report_format_id.value
cmd.set_attribute("format_id", report_format_id)
if ignore_pagination is not None:
cmd.set_attribute("ignore_pagination", to_bool(ignore_pagination))
cmd.set_attribute("details", to_bool(details))
return self._send_xml_command(cmd)
def get_scan_configs(
self,
*,
filter_string: Optional[str] = None,
filter_id: Optional[str] = None,
trash: Optional[bool] = None,
details: Optional[bool] = None,
families: Optional[bool] = None,
preferences: Optional[bool] = None,
tasks: Optional[bool] = None,
) -> Any:
"""Request a list of scan configs
Arguments:
filter_string: Filter term to use for the query
filter_id: UUID of an existing filter to use for the query
trash: Whether to get the trashcan scan configs instead
details: Whether to get config families, preferences, nvt selectors
and tasks.
families: Whether to include the families if no details are
requested
preferences: Whether to include the preferences if no details are
requested
tasks: Whether to get tasks using this config
Returns:
The response. See :py:meth:`send_command` for details.
"""
cmd = XmlCommand("get_configs")
cmd.set_attribute("usage_type", "scan")
add_filter(cmd, filter_string, filter_id)
if trash is not None:
cmd.set_attribute("trash", to_bool(trash))
if details is not None:
cmd.set_attribute("details", to_bool(details))
if families is not None:
cmd.set_attribute("families", to_bool(families))
if preferences is not None:
cmd.set_attribute("preferences", to_bool(preferences))
if tasks is not None:
cmd.set_attribute("tasks", to_bool(tasks))
return self._send_xml_command(cmd)
def get_filter(
self, filter_id: str, *, alerts: Optional[bool] = None
) -> Any:
"""Request a single filter
Arguments:
filter_id: UUID of an existing filter
alerts: Whether to include list of alerts that use the filter.
Returns:
The response. See :py:meth:`send_command` for details.
"""
cmd = XmlCommand("get_filters")
if not filter_id:
raise RequiredArgument(
function=self.get_filter.__name__, argument="filter_id"
)
cmd.set_attribute("filter_id", filter_id)
if alerts is not None:
cmd.set_attribute("alerts", to_bool(alerts))
return self._send_xml_command(cmd)
def get_policy(self,
policy_id: str,
*,
audits: Optional[bool] = None) -> Any:
"""Request a single policy
Arguments:
policy_id: UUID of an existing policy
audits: Whether to get audits using this policy
Returns:
The response. See :py:meth:`send_command` for details.
"""
if not policy_id:
raise RequiredArgument(function=self.get_policy.__name__,
argument="policy_id")
cmd = XmlCommand("get_configs")
cmd.set_attribute("config_id", policy_id)
cmd.set_attribute("usage_type", "policy")
if audits is not None:
cmd.set_attribute("tasks", to_bool(audits))
# for single entity always request all details
cmd.set_attribute("details", "1")
return self._send_xml_command(cmd)
def get_scan_config(self,
config_id: str,
*,
tasks: Optional[bool] = None) -> Any:
"""Request a single scan config
Arguments:
config_id: UUID of an existing scan config
tasks: Whether to get tasks using this config
Returns:
The response. See :py:meth:`send_command` for details.
"""
if not config_id:
raise RequiredArgument(function=self.get_scan_config.__name__,
argument="config_id")
cmd = XmlCommand("get_configs")
cmd.set_attribute("config_id", config_id)
cmd.set_attribute("usage_type", "scan")
if tasks is not None:
cmd.set_attribute("tasks", to_bool(tasks))
# for single entity always request all details
cmd.set_attribute("details", "1")
return self._send_xml_command(cmd)
def get_permissions(
self,
*,
filter_string: Optional[str] = None,
filter_id: Optional[str] = None,
trash: Optional[bool] = None,
) -> Any:
"""Request a list of permissions
Arguments:
filter_string: Filter term to use for the query
filter_id: UUID of an existing filter to use for the query
trash: Whether to get permissions in the trashcan instead
Returns:
The response. See :py:meth:`send_command` for details.
"""
cmd = XmlCommand("get_permissions")
add_filter(cmd, filter_string, filter_id)
if trash is not None:
cmd.set_attribute("trash", to_bool(trash))
return self._send_xml_command(cmd)
def get_target(self,
target_id: str,
*,
tasks: Optional[bool] = None) -> Any:
"""Request a single target
Arguments:
target_id: UUID of an existing target
tasks: Whether to include list of tasks that use the target
Returns:
The response. See :py:meth:`send_command` for details.
"""
cmd = XmlCommand("get_targets")
if not target_id:
raise RequiredArgument(function=self.get_target.__name__,
argument="target_id")
cmd.set_attribute("target_id", target_id)
if tasks is not None:
cmd.set_attribute("tasks", to_bool(tasks))
return self._send_xml_command(cmd)
def get_schedule(self,
schedule_id: str,
*,
tasks: Optional[bool] = None) -> Any:
"""Request a single schedule
Arguments:
schedule_id: UUID of an existing schedule
tasks: Whether to include tasks using the schedules
Returns:
The response. See :py:meth:`send_command` for details.
"""
cmd = XmlCommand("get_schedules")
if not schedule_id:
raise RequiredArgument(function=self.get_schedule.__name__,
argument="schedule_id")
cmd.set_attribute("schedule_id", schedule_id)
if tasks is not None:
cmd.set_attribute("tasks", to_bool(tasks))
return self._send_xml_command(cmd)
def create_user(
self,
name: str,
*,
password: Optional[str] = None,
hosts: Optional[List[str]] = None,
hosts_allow: Optional[bool] = False,
ifaces: Any = None,
ifaces_allow: Any = None,
role_ids: Optional[List[str]] = None,
) -> Any:
"""Create a new user
Arguments:
name: Name of the user
password: Password of the user
hosts: A list of host addresses (IPs, DNS names)
hosts_allow: If True allow only access to passed hosts otherwise
deny access. Default is False for deny hosts.
ifaces: deprecated
ifaces_allow: deprecated
role_ids: A list of role UUIDs for the user
Returns:
The response. See :py:meth:`send_command` for details.
"""
if not name:
raise RequiredArgument(function=self.create_user.__name__,
argument="name")
cmd = XmlCommand("create_user")
cmd.add_element("name", name)
if password:
cmd.add_element("password", password)
if hosts:
cmd.add_element(
"hosts",
to_comma_list(hosts),
attrs={"allow": to_bool(hosts_allow)},
)
if ifaces is not None:
major, minor = self.get_protocol_version()
deprecation("The ifaces parameter has been removed in GMP"
f" version {major}{minor}")
if ifaces_allow is not None:
major, minor = self.get_protocol_version()
deprecation("The ifaces_allow parameter has been removed in GMP"
f" version {major}{minor}")
if role_ids:
for role in role_ids:
cmd.add_element("role", attrs={"id": role})
return self._send_xml_command(cmd)
def get_credential(
self,
credential_id: str,
*,
scanners: Optional[bool] = None,
targets: Optional[bool] = None,
credential_format: Optional[CredentialFormat] = None,
) -> Any:
"""Request a single credential
Arguments:
credential_id: UUID of an existing credential
scanners: Whether to include a list of scanners using the
credentials
targets: Whether to include a list of targets using the credentials
credential_format: One of "key", "rpm", "deb", "exe" or "pem"
Returns:
The response. See :py:meth:`send_command` for details.
"""
if not credential_id:
raise RequiredArgument(function=self.get_credential.__name__,
argument="credential_id")
cmd = XmlCommand("get_credentials")
cmd.set_attribute("credential_id", credential_id)
if credential_format:
if not isinstance(credential_format, CredentialFormat):
raise InvalidArgumentType(
function=self.get_credential.__name__,
argument="credential_format",
arg_type=CredentialFormat.__name__,
)
cmd.set_attribute("format", credential_format.value)
if scanners is not None:
cmd.set_attribute("scanners", to_bool(scanners))
if targets is not None:
cmd.set_attribute("targets", to_bool(targets))
return self._send_xml_command(cmd)
def get_reports(
self,
*,
filter_string: Optional[str] = None,
filter_id: Optional[str] = None,
note_details: Optional[bool] = None,
override_details: Optional[bool] = None,
details: Optional[bool] = None,
) -> Any:
"""Request a list of reports
Arguments:
filter_string: Filter term to use for the query
filter_id: UUID of an existing filter to use for the query
note_details: If notes are included, whether to include note details
override_details: If overrides are included, whether to include
override details
details: Whether to exclude results
Returns:
The response. See :py:meth:`send_command` for details.
"""
cmd = XmlCommand("get_reports")
if filter_string:
cmd.set_attribute("report_filter", filter_string)
if filter_id:
cmd.set_attribute("report_filt_id", filter_id)
if note_details is not None:
cmd.set_attribute("note_details", to_bool(note_details))
if override_details is not None:
cmd.set_attribute("override_details", to_bool(override_details))
if details is not None:
cmd.set_attribute("details", to_bool(details))
cmd.set_attribute("ignore_pagination", "1")
return self._send_xml_command(cmd)
def get_results(
self,
*,
filter_string: Optional[str] = None,
filter_id: Optional[str] = None,
task_id: Optional[str] = None,
note_details: Optional[bool] = None,
override_details: Optional[bool] = None,
details: Optional[bool] = None,
) -> Any:
"""Request a list of results
Arguments:
filter_string: Filter term to use for the query
filter_id: UUID of an existing filter to use for the query
task_id: UUID of task for note and override handling
note_details: If notes are included, whether to include note details
override_details: If overrides are included, whether to include
override details
details: Whether to include additional details of the results
Returns:
The response. See :py:meth:`send_command` for details.
"""
cmd = XmlCommand("get_results")
add_filter(cmd, filter_string, filter_id)
if task_id:
cmd.set_attribute("task_id", task_id)
if details is not None:
cmd.set_attribute("details", to_bool(details))
if note_details is not None:
cmd.set_attribute("note_details", to_bool(note_details))
if override_details is not None:
cmd.set_attribute("override_details", to_bool(override_details))
return self._send_xml_command(cmd)
def get_system_reports(
self,
*,
name: Optional[str] = None,
duration: Optional[int] = None,
start_time: Optional[str] = None,
end_time: Optional[str] = None,
brief: Optional[bool] = None,
slave_id: Optional[str] = None,
) -> Any:
"""Request a list of system reports
Arguments:
name: A string describing the required system report
duration: The number of seconds into the past that the system report
should include
start_time: The start of the time interval the system report should
include in ISO time format
end_time: The end of the time interval the system report should
include in ISO time format
brief: Whether to include the actual system reports
slave_id: UUID of GMP scanner from which to get the system reports
Returns:
The response. See :py:meth:`send_command` for details.
"""
cmd = XmlCommand("get_system_reports")
if name:
cmd.set_attribute("name", name)
if duration is not None:
if not isinstance(duration, Integral):
raise InvalidArgument("duration needs to be an integer number")
cmd.set_attribute("duration", str(duration))
if start_time:
cmd.set_attribute("start_time", str(start_time))
if end_time:
cmd.set_attribute("end_time", str(end_time))
if brief is not None:
cmd.set_attribute("brief", to_bool(brief))
if slave_id:
cmd.set_attribute("slave_id", slave_id)
return self._send_xml_command(cmd)
def get_tasks(
self,
*,
filter_string: Optional[str] = None,
filter_id: Optional[str] = None,
trash: Optional[bool] = None,
details: Optional[bool] = None,
schedules_only: Optional[bool] = None,
) -> Any:
"""Request a list of tasks
Arguments:
filter_string: Filter term to use for the query
filter_id: UUID of an existing filter to use for the query
trash: Whether to get the trashcan tasks instead
details: Whether to include full task details
schedules_only: Whether to only include id, name and schedule
details
Returns:
The response. See :py:meth:`send_command` for details.
"""
cmd = XmlCommand("get_tasks")
cmd.set_attribute("usage_type", "scan")
add_filter(cmd, filter_string, filter_id)
if trash is not None:
cmd.set_attribute("trash", to_bool(trash))
if details is not None:
cmd.set_attribute("details", to_bool(details))
if schedules_only is not None:
cmd.set_attribute("schedules_only", to_bool(schedules_only))
return self._send_xml_command(cmd)
def get_credentials(
self,
*,
filter_string: Optional[str] = None,
filter_id: Optional[str] = None,
scanners: Optional[bool] = None,
trash: Optional[bool] = None,
targets: Optional[bool] = None,
) -> Any:
"""Request a list of credentials
Arguments:
filter_string: Filter term to use for the query
filter_id: UUID of an existing filter to use for the query
scanners: Whether to include a list of scanners using the
credentials
trash: Whether to get the trashcan credentials instead
targets: Whether to include a list of targets using the credentials
Returns:
The response. See :py:meth:`send_command` for details.
"""
cmd = XmlCommand("get_credentials")
add_filter(cmd, filter_string, filter_id)
if scanners is not None:
cmd.set_attribute("scanners", to_bool(scanners))
if trash is not None:
cmd.set_attribute("trash", to_bool(trash))
if targets is not None:
cmd.set_attribute("targets", to_bool(targets))
return self._send_xml_command(cmd)
def get_info_list(
self,
info_type: InfoType,
*,
filter_string: Optional[str] = None,
filter_id: Optional[str] = None,
name: Optional[str] = None,
details: Optional[bool] = None,
) -> Any:
"""Request a list of security information
Arguments:
info_type: Type must be either CERT_BUND_ADV, CPE, CVE,
DFN_CERT_ADV, OVALDEF or NVT
filter_string: Filter term to use for the query
filter_id: UUID of an existing filter to use for the query
name: Name or identifier of the requested information
details: Whether to include information about references to this
information
Returns:
The response. See :py:meth:`send_command` for details.
"""
if not info_type:
raise RequiredArgument(function=self.get_info_list.__name__,
argument="info_type")
if not isinstance(info_type, InfoType):
raise InvalidArgumentType(
function=self.get_info_list.__name__,
argument="info_type",
arg_type=InfoType.__name__,
)
cmd = XmlCommand("get_info")
cmd.set_attribute("type", info_type.value)
add_filter(cmd, filter_string, filter_id)
if name:
cmd.set_attribute("name", name)
if details is not None:
cmd.set_attribute("details", to_bool(details))
return self._send_xml_command(cmd)
def delete_policy(self,
policy_id: str,
*,
ultimate: Optional[bool] = False) -> Any:
"""Deletes an existing policy
Arguments:
policy_id: UUID of the policy to be deleted.
ultimate: Whether to remove entirely, or to the trashcan.
"""
if not policy_id:
raise RequiredArgument(function=self.delete_policy.__name__,
argument="policy_id")
cmd = XmlCommand("delete_config")
cmd.set_attribute("config_id", policy_id)
cmd.set_attribute("ultimate", to_bool(ultimate))
return self._send_xml_command(cmd)
def delete_role(self,
role_id: str,
*,
ultimate: Optional[bool] = False) -> Any:
"""Deletes an existing role
Arguments:
role_id: UUID of the role to be deleted.
ultimate: Whether to remove entirely, or to the trashcan.
"""
if not role_id:
raise RequiredArgument(function=self.delete_role.__name__,
argument="role_id")
cmd = XmlCommand("delete_role")
cmd.set_attribute("role_id", role_id)
cmd.set_attribute("ultimate", to_bool(ultimate))
return self._send_xml_command(cmd)
