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_filter_type_from_string( filter_type: Optional[str]) -> Optional[FilterType]: """ Convert a filter type string to an actual FilterType instance Arguments: filter_type (str): Filter type string to convert to a FilterType """ if not filter_type: return None if filter_type == 'vuln': return FilterType.VULNERABILITY if filter_type == 'os': return FilterType.OPERATING_SYSTEM if filter_type == 'config': return FilterType.SCAN_CONFIG if filter_type == 'secinfo': return FilterType.ALL_SECINFO try: return FilterType[filter_type.upper()] except KeyError: raise InvalidArgument( argument='filter_type', function=get_filter_type_from_string.__name__, )
def get_alert_event_from_string( alert_event: Optional[str], ) -> Optional[AlertEvent]: """Convert an alert event string into a AlertEvent instance """ if not alert_event: return None alert_event = alert_event.lower() if alert_event == 'task run status changed': return AlertEvent.TASK_RUN_STATUS_CHANGED if alert_event == 'updated secinfo arrived': return AlertEvent.UPDATED_SECINFO_ARRIVED if alert_event == 'new secinfo arrived': return AlertEvent.NEW_SECINFO_ARRIVED if alert_event == 'ticket received': return AlertEvent.TICKET_RECEIVED if alert_event == 'assigned ticket changed': return AlertEvent.ASSIGNED_TICKET_CHANGED if alert_event == 'owned ticket changed': return AlertEvent.OWNED_TICKET_CHANGED raise InvalidArgument( argument='alert_event', function=get_alert_event_from_string.__name__ )
def from_string( cls, scanner_type: Optional[str], ) -> Optional["ScannerType"]: """Convert a scanner type string to an actual ScannerType instance Arguments: scanner_type: Scanner type string to convert to a ScannerType """ if not scanner_type: return None scanner_type = scanner_type.lower() if scanner_type == cls.OSP_SCANNER_TYPE.value or scanner_type == "osp": return cls.OSP_SCANNER_TYPE if (scanner_type == cls.OPENVAS_SCANNER_TYPE.value or scanner_type == "openvas"): return cls.OPENVAS_SCANNER_TYPE if scanner_type == cls.CVE_SCANNER_TYPE.value or scanner_type == "cve": return cls.CVE_SCANNER_TYPE if (scanner_type == cls.GREENBONE_SENSOR_SCANNER_TYPE.value or scanner_type == "greenbone"): return cls.GREENBONE_SENSOR_SCANNER_TYPE raise InvalidArgument(argument="scanner_type", function=cls.from_string.__name__)
def get_scanner_type_from_string( scanner_type: Optional[str], ) -> Optional[ScannerType]: """ Convert a scanner type string to an actual ScannerType instance Arguments: scanner_type: Scanner type string to convert to a ScannerType """ if not scanner_type: return None scanner_type = scanner_type.lower() if (scanner_type == ScannerType.OSP_SCANNER_TYPE.value or scanner_type == 'osp'): return ScannerType.OSP_SCANNER_TYPE if (scanner_type == ScannerType.OPENVAS_SCANNER_TYPE.value or scanner_type == 'openvas'): return ScannerType.OPENVAS_SCANNER_TYPE if (scanner_type == ScannerType.CVE_SCANNER_TYPE.value or scanner_type == 'cve'): return ScannerType.CVE_SCANNER_TYPE if (scanner_type == ScannerType.GMP_SCANNER_TYPE.value or scanner_type == 'gmp'): return ScannerType.GMP_SCANNER_TYPE raise InvalidArgument(argument='scanner_type', function=get_scanner_type_from_string.__name__)
def get_alert_condition_from_string( alert_condition: Optional[str], ) -> Optional[AlertCondition]: """Convert an alert condition string into a AlertCondition instance """ if not alert_condition: return None alert_condition = alert_condition.lower() if alert_condition == 'error': return AlertCondition.ERROR if alert_condition == 'always': return AlertCondition.ALWAYS if alert_condition == 'filter count changed': return AlertCondition.FILTER_COUNT_CHANGED if alert_condition == 'filter count at least': return AlertCondition.FILTER_COUNT_AT_LEAST if alert_condition == 'severity at least': return AlertCondition.SEVERITY_AT_LEAST if alert_condition == 'severity changed': return AlertCondition.SEVERITY_CHANGED raise InvalidArgument( argument='alert_condition', function=get_alert_condition_from_string.__name__, )
def test_raise_with_function(self): with self.assertRaises(InvalidArgument) as cm: raise InvalidArgument(function="foo") ex = cm.exception self.assertEqual(ex.function, "foo") self.assertIsNone(ex.argument)
def test_raise_with_argument_and_function(self): with self.assertRaises(InvalidArgument) as cm: raise InvalidArgument(argument="foo", function="bar") ex = cm.exception self.assertEqual(ex.argument, "foo") self.assertEqual(ex.function, "bar")
def get_entity_type_from_string( entity_type: Optional[str]) -> Optional[EntityType]: """ Convert a entity type string to an actual EntityType instance Arguments: entity_type: Entity type string to convert to a EntityType """ if not entity_type: return None if entity_type == 'vuln': return EntityType.VULNERABILITY if entity_type == 'os': return EntityType.OPERATING_SYSTEM if entity_type == 'config': return EntityType.SCAN_CONFIG try: return EntityType[entity_type.upper()] except KeyError: raise InvalidArgument( argument='entity_type', function=get_entity_type_from_string.__name__, )
def test_raise_with_argument_and_function(self): with self.assertRaises(InvalidArgument) as cm: raise InvalidArgument(argument='foo', function='bar') ex = cm.exception self.assertEqual(ex.argument, 'foo') self.assertEqual(ex.function, 'bar')
def get_alert_method_from_string( alert_method: Optional[str], ) -> Optional[AlertMethod]: """ Convert an alert method string into a AlertCondition instance """ if not alert_method: return None alert_method = alert_method.upper() if alert_method == 'START TASK': return AlertMethod.START_TASK if alert_method == 'HTTP GET': return AlertMethod.HTTP_GET if alert_method == 'SOURCEFIRE CONNECTOR': return AlertMethod.SOURCEFIRE_CONNECTOR if alert_method == 'VERINICE CONNECTOR': return AlertMethod.VERINICE_CONNECTOR try: return AlertMethod[alert_method] except KeyError: raise InvalidArgument( argument='alert_method', function=get_alert_method_from_string.__name__, )
def test_raise_with_argument(self): with self.assertRaises(InvalidArgument) as cm: raise InvalidArgument(argument='foo') ex = cm.exception self.assertEqual(ex.argument, 'foo') self.assertIsNone(ex.function)
def from_string( cls, filter_type: Optional[str], ) -> Optional["FilterType"]: """Convert a filter type string to an actual FilterType instance Arguments: filter_type (str): Filter type string to convert to a FilterType """ if not filter_type: return None if filter_type == "vuln": return cls.VULNERABILITY if filter_type == "os": return cls.OPERATING_SYSTEM if filter_type == "config": return cls.SCAN_CONFIG if filter_type == "secinfo": return cls.ALL_SECINFO try: return cls[filter_type.upper()] except KeyError: raise InvalidArgument( argument="filter_type", function=cls.from_string.__name__, ) from None
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 test_message_precedence(self): with self.assertRaisesRegex(InvalidArgument, "^foo bar$") as cm: raise InvalidArgument("foo bar", argument="foo", function="bar") ex = cm.exception self.assertEqual(ex.argument, "foo") self.assertEqual(ex.function, "bar") self.assertEqual(str(ex), "foo bar")
def test_message_precedence(self): with self.assertRaisesRegex(InvalidArgument, '^foo bar$') as cm: raise InvalidArgument('foo bar', argument='foo', function='bar') ex = cm.exception self.assertEqual(ex.argument, 'foo') self.assertEqual(ex.function, 'bar') self.assertEqual(str(ex), 'foo bar')
def get_feed_type_from_string(feed_type: Optional[str]) -> Optional[FeedType]: """ Convert a feed type string into a FeedType instance """ if not feed_type: return None try: return FeedType[feed_type.upper()] except KeyError: raise InvalidArgument(argument='feed_type', function=get_feed_type_from_string.__name__)
def get_time_unit_from_string(time_unit: Optional[str]) -> Optional[TimeUnit]: """ Convert a time unit string into a TimeUnit instance """ if not time_unit: return None try: return TimeUnit[time_unit.upper()] except KeyError: raise InvalidArgument( argument='severity_level', function=get_severity_level_from_string.__name__, )
def get_credential_format_from_string( credential_format: Optional[str], ) -> Optional[CredentialFormat]: if not credential_format: return None try: return CredentialFormat[credential_format.upper()] except KeyError: raise InvalidArgument( argument='credential_format', function=get_credential_format_from_string.__name__, )
def get_info_type_from_string(info_type: Optional[str]) -> Optional[InfoType]: """ Convert a info type string to an actual InfoType instance Arguments: info_type: Info type string to convert to a InfoType """ if not info_type: return None try: return InfoType[info_type.upper()] except KeyError: raise InvalidArgument(argument='info_type', function=get_info_type_from_string.__name__)
def get_credential_type_from_string( credential_type: Optional[str], ) -> Optional[CredentialType]: """Convert a credential type string into a CredentialType instance""" if not credential_type: return None try: return CredentialType[credential_type.upper()] except KeyError: raise InvalidArgument( argument='credential_type', function=get_credential_type_from_string.__name__, ) from None
def get_asset_type_from_string( asset_type: Optional[str], ) -> Optional[AssetType]: if not asset_type: return None if asset_type == 'os': return AssetType.OPERATING_SYSTEM try: return AssetType[asset_type.upper()] except KeyError: raise InvalidArgument(argument='asset_type', function=get_asset_type_from_string.__name__)
def get_snmp_auth_algorithm_from_string( algorithm: Optional[str], ) -> Optional[SnmpAuthAlgorithm]: """Convert a SNMP auth algorithm string into a SnmpAuthAlgorithm instance""" if not algorithm: return None try: return SnmpAuthAlgorithm[algorithm.upper()] except KeyError: raise InvalidArgument( argument='algorithm', function=get_snmp_auth_algorithm_from_string.__name__, ) from None
def get_user_auth_type_from_string( user_auth_type: Optional[str], ) -> Optional[UserAuthType]: """ Convert a user auth type string into a UserAuthType instance """ if not user_auth_type: return None try: return UserAuthType[user_auth_type.upper()] except KeyError: raise InvalidArgument( argument='user_auth_type', function=get_user_auth_type_from_string.__name__, ) from None
def from_string(cls, info_type: Optional[str]) -> Optional["InfoType"]: """Convert a info type string to an actual InfoType instance Arguments: info_type: Info type string to convert to a InfoType """ if not info_type: return None try: return cls[info_type.upper()] except KeyError: raise InvalidArgument(argument="info_type", function=cls.from_string.__name__) from None
def get_severity_level_from_string( severity_level: Optional[str], ) -> Optional[SeverityLevel]: """ Convert a severity level string into a SeverityLevel instance """ if not severity_level: return None try: return SeverityLevel[severity_level.upper()] except KeyError: raise InvalidArgument( argument='severity_level', function=get_severity_level_from_string.__name__, )
def get_ticket_status_from_string( ticket_status: Optional[str], ) -> Optional[TicketStatus]: """Convert a ticket status string into a TicketStatus instance""" if not ticket_status: return None try: return TicketStatus[ticket_status.upper()] except KeyError: raise InvalidArgument( argument='ticket_status', function=get_ticket_status_from_string.__name__, ) from None
def from_string( cls, alert_condition: Optional[str]) -> Optional["AlertCondition"]: """Convert an alert condition string into a AlertCondition instance""" if not alert_condition: return None try: return cls[alert_condition.replace(" ", "_").upper()] except KeyError: raise InvalidArgument( argument="alert_condition", function=cls.from_string.__name__, ) from None
def from_string( cls, credential_format: Optional[str], ) -> Optional["CredentialFormat"]: if not credential_format: return None try: return cls[credential_format.upper()] except KeyError: raise InvalidArgument( argument="credential_format", function=cls.from_string.__name__, ) from None
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)