diff --git a/docs/api/gmpnext.md b/docs/api/gmpnext.md index ec1a7a45e..d8c0e7925 100644 --- a/docs/api/gmpnext.md +++ b/docs/api/gmpnext.md @@ -16,6 +16,27 @@ ## Enums +```{eval-rst} +.. autoclass:: gvm.protocols.gmp.requests.next.ActiveDirectoryObjectType + :members: + :undoc-members: + :no-index: +``` + +```{eval-rst} +.. autoclass:: gvm.protocols.gmp.requests.next.ActiveDirectorySearchScope + :members: + :undoc-members: + :no-index: +``` + +```{eval-rst} +.. autoclass:: gvm.protocols.gmp.requests.next.ActiveDirectoryTlsMode + :members: + :undoc-members: + :no-index: +``` + ```{eval-rst} .. autoclass:: gvm.protocols.gmp.requests.next.AlertCondition :members: diff --git a/gvm/protocols/gmp/_gmpnext.py b/gvm/protocols/gmp/_gmpnext.py index 7e21c966a..d7cc70ee4 100644 --- a/gvm/protocols/gmp/_gmpnext.py +++ b/gvm/protocols/gmp/_gmpnext.py @@ -11,6 +11,10 @@ from .._protocol import T from ._gmp227 import GMPv227 from .requests.next import ( + ActiveDirectory, + ActiveDirectoryObjectType, + ActiveDirectorySearchScope, + ActiveDirectoryTlsMode, AgentGroups, AgentInstallerInstructionLanguageType, AgentInstallerInstructions, @@ -367,7 +371,7 @@ def create_active_directory_credential( bind_dn: str, base_dn: str, bind_password: str, - tls_mode: str, + tls_mode: ActiveDirectoryTlsMode | str, comment: str | None = None, port: int | None = None, ca_certificate: str | None = None, @@ -411,7 +415,7 @@ def modify_active_directory_credential( bind_dn: str | None = None, base_dn: str | None = None, bind_password: str | None = None, - tls_mode: str | None = None, + tls_mode: ActiveDirectoryTlsMode | str | None = None, port: int | str | None = None, ca_certificate: str | None = None, ) -> T: @@ -457,7 +461,7 @@ def verify_active_directory_credential( bind_dn: str | None = None, bind_password: str | None = None, base_dn: str | None = None, - tls_mode: str | None = None, + tls_mode: ActiveDirectoryTlsMode | str | None = None, port: int | None = None, ca_certificate: str | None = None, ) -> T: @@ -472,7 +476,7 @@ def verify_active_directory_credential( bind_dn: Distinguished name used to bind to the directory. bind_password: Password used for the bind. base_dn: Base distinguished name for directory searches. - tls_mode: Either "ldaps" or "starttls". + tls_mode: TLS mode, either "ldaps" or "starttls". port: Optional server port, from 1 to 65535. ca_certificate: Optional CA certificate in PEM format. """ @@ -489,6 +493,68 @@ def verify_active_directory_credential( ) ) + def get_active_directory_objects( + self, + credential_id: EntityID, + *, + base_dn: str | None = None, + group_dn: str | None = None, + scope: ActiveDirectorySearchScope | str | None = None, + object_types: Sequence[ActiveDirectoryObjectType | str] | None = None, + max_results: int | None = None, + include_disabled_computers: bool | None = None, + targets: bool | None = None, + tasks: bool | None = None, + details: bool | None = None, + ) -> T: + """Search Active Directory using a saved AD credential. + + Requires AD integration to be enabled in gvmd and a saved AD + credential. Options set to None are omitted from the request so that + gvmd applies its defaults. + + The response includes per-type counts for the fetched subset and an + objects truncated attribute indicating whether more objects were + available. + + Args: + credential_id: UUID of a saved AD credential. + base_dn: Nonempty search base within the credential's base DN. + Defaults to the credential's base DN. + group_dn: Nonempty DN selecting explicit direct group members + within the search base and scope. Must be within the + credential's base DN. + scope: Search scope, either "base", "onelevel", or "subtree". + Defaults to "onelevel", searching immediately below base_dn. Use + "subtree" to search at all directory depths. + object_types: Nonempty selection of "ou", "container", "computer", + or "group". Defaults to "ou", "computer", and "group". + Duplicates are ignored, preserving first-occurrence order. + max_results: Maximum number of objects to fetch after LDAP + filtering, from 1 to 1000. Omit to use the server default. + include_disabled_computers: Include disabled computers. Defaults + to True. + targets: Include matching targets for computers. Defaults to False. + tasks: Include tasks and readable configurations for matching + targets. Requires targets=True. Defaults to False. + details: Include computer OS version and service principal names. + Defaults to False. + """ + return self._send_request_and_transform_response( + ActiveDirectory.get_active_directory_objects( + credential_id=credential_id, + base_dn=base_dn, + group_dn=group_dn, + scope=scope, + object_types=object_types, + max_results=max_results, + include_disabled_computers=include_disabled_computers, + targets=targets, + tasks=tasks, + details=details, + ) + ) + def create_credential_store_credential( self, name: str, diff --git a/gvm/protocols/gmp/requests/next/__init__.py b/gvm/protocols/gmp/requests/next/__init__.py index d251ec9c6..611bb9a2e 100644 --- a/gvm/protocols/gmp/requests/next/__init__.py +++ b/gvm/protocols/gmp/requests/next/__init__.py @@ -2,6 +2,11 @@ # # SPDX-License-Identifier: GPL-3.0-or-later +from gvm.protocols.gmp.requests.next._active_directory import ( + ActiveDirectory, + ActiveDirectoryObjectType, + ActiveDirectorySearchScope, +) from gvm.protocols.gmp.requests.next._agent_groups import AgentGroups from gvm.protocols.gmp.requests.next._agent_installer_instructions import ( AgentInstallerInstructionLanguageType, @@ -11,6 +16,7 @@ from gvm.protocols.gmp.requests.next._audit_report import AuditReport from gvm.protocols.gmp.requests.next._credential_stores import CredentialStores from gvm.protocols.gmp.requests.next._credentials import ( + ActiveDirectoryTlsMode, Credentials, CredentialStoreCredentialType, CredentialType, @@ -130,6 +136,10 @@ ) __all__ = ( + "ActiveDirectory", + "ActiveDirectoryObjectType", + "ActiveDirectorySearchScope", + "ActiveDirectoryTlsMode", "AgentGroups", "AgentInstallerInstructionLanguageType", "AgentInstallerInstructions", diff --git a/gvm/protocols/gmp/requests/next/_active_directory.py b/gvm/protocols/gmp/requests/next/_active_directory.py new file mode 100644 index 000000000..103cad631 --- /dev/null +++ b/gvm/protocols/gmp/requests/next/_active_directory.py @@ -0,0 +1,176 @@ +# SPDX-FileCopyrightText: 2026 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +from collections.abc import Sequence + +from gvm._enum import Enum +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.core import Request +from gvm.utils import to_bool +from gvm.xml import XmlCommand + +from .._entity_id import EntityID + + +class ActiveDirectorySearchScope(Enum): + """Enum for Active Directory search scopes""" + + BASE = "base" + ONELEVEL = "onelevel" + SUBTREE = "subtree" + + +class ActiveDirectoryObjectType(Enum): + """Enum for Active Directory object types""" + + OU = "ou" + CONTAINER = "container" + COMPUTER = "computer" + GROUP = "group" + + +class ActiveDirectory: + @classmethod + def get_active_directory_objects( + cls, + credential_id: EntityID, + *, + base_dn: str | None = None, + group_dn: str | None = None, + scope: ActiveDirectorySearchScope | str | None = None, + object_types: Sequence[ActiveDirectoryObjectType | str] | None = None, + max_results: int | None = None, + include_disabled_computers: bool | None = None, + targets: bool | None = None, + tasks: bool | None = None, + details: bool | None = None, + ) -> Request: + """Search Active Directory using a saved AD credential. + + Requires AD integration to be enabled in gvmd and a saved AD + credential. Options set to None are omitted from the request so that + gvmd applies its defaults. + + Args: + credential_id: UUID of a saved AD credential. + base_dn: Nonempty search base within the credential's base DN. + Defaults to the credential's base DN. + group_dn: Nonempty DN selecting explicit direct group members + within the search base and scope. Must be within the + credential's base DN. + scope: Search scope, either "base", "onelevel", or "subtree". + Defaults to "onelevel", searching immediately below base_dn. Use + "subtree" to search at all directory depths. + object_types: Nonempty selection of "ou", "container", "computer", + or "group". Defaults to "ou", "computer", and "group". + Duplicates are ignored, preserving first-occurrence order. + max_results: Maximum number of objects to fetch after LDAP + filtering, from 1 to 1000. Omit to use the server default. + include_disabled_computers: Include disabled computers. Defaults + to True. + targets: Include matching targets for computers. Defaults to False. + tasks: Include tasks and readable configurations for matching + targets. Requires targets=True. Defaults to False. + details: Include computer OS version and service principal names. + Defaults to False. + """ + if not credential_id: + raise RequiredArgument( + function=cls.get_active_directory_objects.__name__, + argument="credential_id", + ) + if base_dn is not None and not base_dn: + raise RequiredArgument( + function=cls.get_active_directory_objects.__name__, + argument="base_dn", + ) + if group_dn is not None and not group_dn: + raise RequiredArgument( + function=cls.get_active_directory_objects.__name__, + argument="group_dn", + ) + if scope is not None and not scope: + raise RequiredArgument( + function=cls.get_active_directory_objects.__name__, + argument="scope", + ) + if scope is not None and not isinstance( + scope, ActiveDirectorySearchScope + ): + try: + scope = ActiveDirectorySearchScope(scope) + except InvalidArgument as error: + raise InvalidArgument( + str(error), + function=cls.get_active_directory_objects.__name__, + argument="scope", + ) from None + if object_types is not None and ( + isinstance(object_types, str) + or not object_types + or any(not object_type for object_type in object_types) + ): + raise InvalidArgument( + function=cls.get_active_directory_objects.__name__, + argument="object_types", + ) + try: + normalized_object_types = ( + list( + dict.fromkeys( + ActiveDirectoryObjectType(t) for t in object_types + ) + ) + if object_types is not None + else None + ) + except InvalidArgument as error: + raise InvalidArgument( + str(error), + function=cls.get_active_directory_objects.__name__, + argument="object_types", + ) from None + if max_results is not None and ( + isinstance(max_results, bool) + or not isinstance(max_results, int) + or not 1 <= max_results <= 1000 + ): + raise InvalidArgument( + function=cls.get_active_directory_objects.__name__, + argument="max_results", + ) + if tasks and not targets: + raise InvalidArgument( + function=cls.get_active_directory_objects.__name__, + argument="tasks", + ) + + cmd = XmlCommand("get_active_directory_objects") + cmd.set_attribute("credential_id", str(credential_id)) + if scope is not None: + cmd.set_attribute("scope", scope.value) + if max_results is not None: + cmd.set_attribute("max_results", str(max_results)) + if include_disabled_computers is not None: + cmd.set_attribute( + "include_disabled_computers", + to_bool(include_disabled_computers), + ) + if targets is not None: + cmd.set_attribute("targets", to_bool(targets)) + if tasks is not None: + cmd.set_attribute("tasks", to_bool(tasks)) + if details is not None: + cmd.set_attribute("details", to_bool(details)) + + if base_dn is not None: + cmd.add_element("base_dn", base_dn) + if group_dn is not None: + cmd.add_element("group_dn", group_dn) + if normalized_object_types is not None: + types_element = cmd.add_element("object_types") + for object_type in normalized_object_types: + types_element.add_element("object_type", object_type.value) + + return cmd diff --git a/gvm/protocols/gmp/requests/next/_credentials.py b/gvm/protocols/gmp/requests/next/_credentials.py index a24bf5d10..cf52afee7 100644 --- a/gvm/protocols/gmp/requests/next/_credentials.py +++ b/gvm/protocols/gmp/requests/next/_credentials.py @@ -14,6 +14,13 @@ ) +class ActiveDirectoryTlsMode(Enum): + """Enum for Active Directory TLS modes""" + + LDAPS = "ldaps" + STARTTLS = "starttls" + + class CredentialStoreCredentialType(Enum): """Enum for credential store credential types""" @@ -49,7 +56,7 @@ def create_active_directory_credential( bind_dn: str, base_dn: str, bind_password: str, - tls_mode: str, + tls_mode: ActiveDirectoryTlsMode | str, comment: str | None = None, port: int | None = None, ca_certificate: str | None = None, @@ -105,14 +112,20 @@ def create_active_directory_credential( argument="tls_mode", ) - if tls_mode not in ("ldaps", "starttls"): - raise InvalidArgument( - function=cls.create_active_directory_credential.__name__, - argument="tls_mode", - ) + if not isinstance(tls_mode, ActiveDirectoryTlsMode): + try: + tls_mode = ActiveDirectoryTlsMode(tls_mode) + except InvalidArgument as error: + raise InvalidArgument( + str(error), + function=cls.create_active_directory_credential.__name__, + argument="tls_mode", + ) from None if port is not None and ( - not isinstance(port, int) or not 1 <= port <= 65535 + isinstance(port, bool) + or not isinstance(port, int) + or not 1 <= port <= 65535 ): raise InvalidArgument( function=cls.create_active_directory_credential.__name__, @@ -128,7 +141,7 @@ def create_active_directory_credential( cmd.add_element("bind_dn", bind_dn) cmd.add_element("base_dn", base_dn) cmd.add_element("bind_password", bind_password) - cmd.add_element("tls_mode", tls_mode) + cmd.add_element("tls_mode", tls_mode.value) if port is not None: cmd.add_element("port", str(port)) if ca_certificate is not None: @@ -146,7 +159,7 @@ def modify_active_directory_credential( bind_dn: str | None = None, base_dn: str | None = None, bind_password: str | None = None, - tls_mode: str | None = None, + tls_mode: ActiveDirectoryTlsMode | str | None = None, port: int | str | None = None, ca_certificate: str | None = None, ) -> Request: @@ -211,16 +224,26 @@ def modify_active_directory_credential( argument="tls_mode", ) - if tls_mode is not None and tls_mode not in ("ldaps", "starttls"): - raise InvalidArgument( - function=cls.modify_active_directory_credential.__name__, - argument="tls_mode", - ) + if tls_mode is not None and not isinstance( + tls_mode, ActiveDirectoryTlsMode + ): + try: + tls_mode = ActiveDirectoryTlsMode(tls_mode) + except InvalidArgument as error: + raise InvalidArgument( + str(error), + function=cls.modify_active_directory_credential.__name__, + argument="tls_mode", + ) from None if ( port is not None and port != "" - and (not isinstance(port, int) or not 1 <= port <= 65535) + and ( + isinstance(port, bool) + or not isinstance(port, int) + or not 1 <= port <= 65535 + ) ): raise InvalidArgument( function=cls.modify_active_directory_credential.__name__, @@ -242,7 +265,7 @@ def modify_active_directory_credential( if bind_password is not None: cmd.add_element("bind_password", str(bind_password)) if tls_mode is not None: - cmd.add_element("tls_mode", str(tls_mode)) + cmd.add_element("tls_mode", tls_mode.value) if port is not None: cmd.add_element("port", str(port)) if ca_certificate is not None: @@ -258,7 +281,7 @@ def verify_active_directory_credential( bind_dn: str | None = None, bind_password: str | None = None, base_dn: str | None = None, - tls_mode: str | None = None, + tls_mode: ActiveDirectoryTlsMode | str | None = None, port: int | None = None, ca_certificate: str | None = None, ) -> Request: @@ -300,11 +323,20 @@ def verify_active_directory_credential( if not tls_mode: raise RequiredArgument(function=function, argument="tls_mode") - if tls_mode not in ("ldaps", "starttls"): - raise InvalidArgument(function=function, argument="tls_mode") + if not isinstance(tls_mode, ActiveDirectoryTlsMode): + try: + tls_mode = ActiveDirectoryTlsMode(tls_mode) + except InvalidArgument as error: + raise InvalidArgument( + str(error), + function=function, + argument="tls_mode", + ) from None if port is not None and ( - not isinstance(port, int) or not 1 <= port <= 65535 + isinstance(port, bool) + or not isinstance(port, int) + or not 1 <= port <= 65535 ): raise InvalidArgument(function=function, argument="port") @@ -315,7 +347,7 @@ def verify_active_directory_credential( cmd.add_element("bind_dn", bind_dn) cmd.add_element("bind_password", bind_password) cmd.add_element("base_dn", base_dn) - cmd.add_element("tls_mode", tls_mode) + cmd.add_element("tls_mode", tls_mode.value) if ca_certificate is not None: cmd.add_element("ca_certificate", ca_certificate) return cmd diff --git a/tests/protocols/gmpnext/entities/active_directory/__init__.py b/tests/protocols/gmpnext/entities/active_directory/__init__.py new file mode 100644 index 000000000..42dd84199 --- /dev/null +++ b/tests/protocols/gmpnext/entities/active_directory/__init__.py @@ -0,0 +1,9 @@ +# SPDX-FileCopyrightText: 2026 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +from .test_get_active_directory_objects import ( + GmpGetActiveDirectoryObjectsTestMixin, +) + +__all__ = ("GmpGetActiveDirectoryObjectsTestMixin",) diff --git a/tests/protocols/gmpnext/entities/active_directory/test_get_active_directory_objects.py b/tests/protocols/gmpnext/entities/active_directory/test_get_active_directory_objects.py new file mode 100644 index 000000000..5c7c9a888 --- /dev/null +++ b/tests/protocols/gmpnext/entities/active_directory/test_get_active_directory_objects.py @@ -0,0 +1,329 @@ +# SPDX-FileCopyrightText: 2026 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +from uuid import UUID + +from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.next import ( + ActiveDirectoryObjectType, + ActiveDirectorySearchScope, +) + + +class GmpGetActiveDirectoryObjectsTestMixin: + def test_get_active_directory_objects_with_duplicate_object_types(self): + self.gmp.get_active_directory_objects( + "credential-id", object_types=["computer", "computer"] + ) + + self.connection.send.has_been_called_with( + b'' + b"" + b"computer" + b"" + b"" + ) + + self.gmp.get_active_directory_objects( + "credential-id", + object_types=[ + "computer", + "group", + ActiveDirectoryObjectType.COMPUTER, + "COMPUTER", + ActiveDirectoryObjectType.GROUP, + ], + ) + + self.connection.send.has_been_called_with( + b'' + b"" + b"computer" + b"group" + b"" + b"" + ) + + def test_get_active_directory_objects_with_mixed_object_types(self): + self.gmp.get_active_directory_objects( + "credential-id", + scope=ActiveDirectorySearchScope.SUBTREE, + object_types=[ActiveDirectoryObjectType.COMPUTER, "group"], + ) + + self.connection.send.has_been_called_with( + b'' + b"computer" + b"group" + b"" + ) + + def test_get_active_directory_objects_with_enums(self): + self.gmp.get_active_directory_objects( + "credential-id", + scope=ActiveDirectorySearchScope.ONELEVEL, + object_types=[ + ActiveDirectoryObjectType.OU, + ActiveDirectoryObjectType.CONTAINER, + ActiveDirectoryObjectType.COMPUTER, + ActiveDirectoryObjectType.GROUP, + ], + ) + + self.connection.send.has_been_called_with( + b'' + b"ou" + b"container" + b"computer" + b"group" + b"" + ) + + def test_get_active_directory_objects_with_positional_credential_id(self): + self.gmp.get_active_directory_objects("credential-id") + + self.connection.send.has_been_called_with( + b'' + ) + + def test_get_active_directory_objects(self): + self.gmp.get_active_directory_objects(credential_id="credential-id") + + self.connection.send.has_been_called_with( + b'' + ) + + def test_get_active_directory_objects_with_uuid(self): + self.gmp.get_active_directory_objects( + credential_id=UUID("12345678-1234-1234-1234-123456789abc") + ) + + self.connection.send.has_been_called_with( + b"' + ) + + def test_get_active_directory_objects_with_all_options(self): + self.gmp.get_active_directory_objects( + credential_id="credential-id", + base_dn="OU=Machines,DC=example,DC=org", + group_dn="CN=Scan,DC=example,DC=org", + scope="subtree", + object_types=["ou", "container", "computer", "group"], + max_results=1000, + include_disabled_computers=True, + targets=True, + tasks=True, + details=True, + ) + + self.connection.send.has_been_called_with( + b'' + b"OU=Machines,DC=example,DC=org" + b"CN=Scan,DC=example,DC=org" + b"ou" + b"container" + b"computer" + b"group" + b"" + ) + + def test_get_active_directory_objects_with_false_flags(self): + self.gmp.get_active_directory_objects( + credential_id="credential-id", + include_disabled_computers=False, + targets=False, + tasks=False, + details=False, + ) + + self.connection.send.has_been_called_with( + b'' + ) + + def test_get_active_directory_objects_with_special_characters(self): + self.gmp.get_active_directory_objects( + credential_id="credential<&", + base_dn="OU=Machines<&,DC=example,DC=org", + group_dn="CN=Scan<&,DC=example,DC=org", + ) + + self.connection.send.has_been_called_with( + b'' + b"OU=Machines<&,DC=example,DC=org" + b"CN=Scan<&,DC=example,DC=org" + b"" + ) + + def test_get_active_directory_objects_with_scope(self): + self.gmp.get_active_directory_objects( + credential_id="credential-id", scope="base" + ) + + self.connection.send.has_been_called_with( + b'' + ) + + self.gmp.get_active_directory_objects( + credential_id="credential-id", scope="onelevel" + ) + + self.connection.send.has_been_called_with( + b'' + ) + + self.gmp.get_active_directory_objects( + credential_id="credential-id", scope="subtree" + ) + + self.connection.send.has_been_called_with( + b'' + ) + + def test_get_active_directory_objects_with_max_results(self): + self.gmp.get_active_directory_objects( + credential_id="credential-id", max_results=1 + ) + + self.connection.send.has_been_called_with( + b'' + ) + + self.gmp.get_active_directory_objects( + credential_id="credential-id", max_results=1000 + ) + + self.connection.send.has_been_called_with( + b'' + ) + + def test_get_active_directory_objects_without_credential_id(self): + with self.assertRaises(RequiredArgument): + self.gmp.get_active_directory_objects(credential_id=None) + + with self.assertRaises(RequiredArgument): + self.gmp.get_active_directory_objects(credential_id="") + + self.connection.send.has_not_been_called() + + def test_get_active_directory_objects_with_empty_dn(self): + with self.assertRaises(RequiredArgument): + self.gmp.get_active_directory_objects( + credential_id="credential-id", base_dn="" + ) + + with self.assertRaises(RequiredArgument): + self.gmp.get_active_directory_objects( + credential_id="credential-id", group_dn="" + ) + + self.connection.send.has_not_been_called() + + def test_get_active_directory_objects_with_empty_scope(self): + with self.assertRaises(RequiredArgument): + self.gmp.get_active_directory_objects( + credential_id="credential-id", scope="" + ) + + self.connection.send.has_not_been_called() + + def test_get_active_directory_objects_with_invalid_scope(self): + with self.assertRaises(InvalidArgument) as context: + self.gmp.get_active_directory_objects( + credential_id="credential-id", scope="invalid" + ) + + self.assertEqual(context.exception.argument, "scope") + self.assertEqual( + context.exception.function, "get_active_directory_objects" + ) + self.connection.send.has_not_been_called() + + def test_get_active_directory_objects_with_invalid_object_types(self): + with self.assertRaises(InvalidArgument): + self.gmp.get_active_directory_objects( + credential_id="credential-id", object_types=[] + ) + + with self.assertRaises(InvalidArgument): + self.gmp.get_active_directory_objects( + credential_id="credential-id", object_types="computer" + ) + + with self.assertRaises(InvalidArgument): + self.gmp.get_active_directory_objects( + credential_id="credential-id", object_types=[""] + ) + + with self.assertRaises(InvalidArgument) as context: + self.gmp.get_active_directory_objects( + credential_id="credential-id", + object_types=["computer", "invalid"], + ) + + self.assertEqual(context.exception.argument, "object_types") + self.assertEqual( + context.exception.function, "get_active_directory_objects" + ) + self.connection.send.has_not_been_called() + + def test_get_active_directory_objects_with_invalid_max_results(self): + with self.assertRaises(InvalidArgument): + self.gmp.get_active_directory_objects( + credential_id="credential-id", max_results=-1 + ) + + with self.assertRaises(InvalidArgument): + self.gmp.get_active_directory_objects( + credential_id="credential-id", max_results=0 + ) + + with self.assertRaises(InvalidArgument): + self.gmp.get_active_directory_objects( + credential_id="credential-id", max_results=1001 + ) + + with self.assertRaises(InvalidArgument): + self.gmp.get_active_directory_objects( + credential_id="credential-id", max_results="10" + ) + + with self.assertRaises(InvalidArgument): + self.gmp.get_active_directory_objects( + credential_id="credential-id", max_results=1.5 + ) + + with self.assertRaises(InvalidArgument): + self.gmp.get_active_directory_objects( + credential_id="credential-id", max_results=True + ) + + self.connection.send.has_not_been_called() + + def test_get_active_directory_objects_with_tasks_without_targets(self): + with self.assertRaises(InvalidArgument): + self.gmp.get_active_directory_objects( + credential_id="credential-id", + tasks=True, + targets=None, + ) + + with self.assertRaises(InvalidArgument): + self.gmp.get_active_directory_objects( + credential_id="credential-id", + tasks=True, + targets=False, + ) + + self.connection.send.has_not_been_called() diff --git a/tests/protocols/gmpnext/entities/credentials/test_create_active_directory_credential.py b/tests/protocols/gmpnext/entities/credentials/test_create_active_directory_credential.py index 0238cd5ce..0cb7fbf67 100644 --- a/tests/protocols/gmpnext/entities/credentials/test_create_active_directory_credential.py +++ b/tests/protocols/gmpnext/entities/credentials/test_create_active_directory_credential.py @@ -4,6 +4,7 @@ # from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.next import ActiveDirectoryTlsMode class GmpCreateActiveDirectoryCredentialTestMixin: @@ -79,6 +80,45 @@ def test_create_ad_credential_with_optional_arguments(self): b"" ) + def test_create_ad_credential_with_tls_mode_enum(self): + self.gmp.create_active_directory_credential( + name="AD", + host="dc.example.org", + bind_dn="CN=Scanner,DC=example,DC=org", + base_dn="DC=example,DC=org", + bind_password="secret", + tls_mode=ActiveDirectoryTlsMode.LDAPS, + ) + + self.connection.send.has_been_called_with( + b"ADad" + b"dc.example.org" + b"CN=Scanner,DC=example,DC=org" + b"DC=example,DC=org" + b"secret" + b"ldaps" + b"" + ) + + self.gmp.create_active_directory_credential( + name="AD", + host="dc.example.org", + bind_dn="CN=Scanner,DC=example,DC=org", + base_dn="DC=example,DC=org", + bind_password="secret", + tls_mode=ActiveDirectoryTlsMode.STARTTLS, + ) + + self.connection.send.has_been_called_with( + b"ADad" + b"dc.example.org" + b"CN=Scanner,DC=example,DC=org" + b"DC=example,DC=org" + b"secret" + b"starttls" + b"" + ) + def test_create_ad_credential_missing_name(self): with self.assertRaises(RequiredArgument): self.gmp.create_active_directory_credential( @@ -156,7 +196,7 @@ def test_create_ad_credential_missing_tls_mode(self): ) def test_create_ad_credential_invalid_tls_mode(self): - with self.assertRaises(InvalidArgument): + with self.assertRaises(InvalidArgument) as context: self.gmp.create_active_directory_credential( name="AD", host="dc.example.org", @@ -166,6 +206,11 @@ def test_create_ad_credential_invalid_tls_mode(self): tls_mode="ldap", ) + self.assertEqual(context.exception.argument, "tls_mode") + self.assertEqual( + context.exception.function, "create_active_directory_credential" + ) + def test_create_ad_credential_invalid_port(self): with self.assertRaises(InvalidArgument): self.gmp.create_active_directory_credential( @@ -178,6 +223,28 @@ def test_create_ad_credential_invalid_port(self): port=0, ) + with self.assertRaises(InvalidArgument): + self.gmp.create_active_directory_credential( + name="AD", + host="dc.example.org", + bind_dn="CN=Scanner,CN=Users,DC=example,DC=org", + base_dn="DC=example,DC=org", + bind_password="secret", + tls_mode="ldaps", + port=True, + ) + + with self.assertRaises(InvalidArgument): + self.gmp.create_active_directory_credential( + name="AD", + host="dc.example.org", + bind_dn="CN=Scanner,CN=Users,DC=example,DC=org", + base_dn="DC=example,DC=org", + bind_password="secret", + tls_mode="ldaps", + port=False, + ) + with self.assertRaises(InvalidArgument): self.gmp.create_active_directory_credential( name="AD", diff --git a/tests/protocols/gmpnext/entities/credentials/test_modify_active_directory_credential.py b/tests/protocols/gmpnext/entities/credentials/test_modify_active_directory_credential.py index 2ef9e36f1..bc938aef1 100644 --- a/tests/protocols/gmpnext/entities/credentials/test_modify_active_directory_credential.py +++ b/tests/protocols/gmpnext/entities/credentials/test_modify_active_directory_credential.py @@ -4,6 +4,7 @@ # from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.next import ActiveDirectoryTlsMode class GmpModifyActiveDirectoryCredentialTestMixin: @@ -71,6 +72,27 @@ def test_modify_ad_credential_clear_optional_arguments(self): b"" ) + def test_modify_ad_credential_with_tls_mode_enum(self): + self.gmp.modify_active_directory_credential( + "credential-id", tls_mode=ActiveDirectoryTlsMode.LDAPS + ) + + self.connection.send.has_been_called_with( + b'' + b"ldaps" + b"" + ) + + self.gmp.modify_active_directory_credential( + "credential-id", tls_mode=ActiveDirectoryTlsMode.STARTTLS + ) + + self.connection.send.has_been_called_with( + b'' + b"starttls" + b"" + ) + def test_modify_ad_credential_missing_credential_id(self): with self.assertRaises(RequiredArgument): self.gmp.modify_active_directory_credential(None) @@ -118,12 +140,27 @@ def test_modify_ad_credential_empty_tls_mode(self): ) def test_modify_ad_credential_invalid_tls_mode(self): - with self.assertRaises(InvalidArgument): + with self.assertRaises(InvalidArgument) as context: self.gmp.modify_active_directory_credential( credential_id="credential-id", tls_mode="ldap" ) + self.assertEqual(context.exception.argument, "tls_mode") + self.assertEqual( + context.exception.function, "modify_active_directory_credential" + ) + def test_modify_ad_credential_invalid_port(self): + with self.assertRaises(InvalidArgument): + self.gmp.modify_active_directory_credential( + credential_id="credential-id", port=True + ) + + with self.assertRaises(InvalidArgument): + self.gmp.modify_active_directory_credential( + credential_id="credential-id", port=False + ) + with self.assertRaises(InvalidArgument): self.gmp.modify_active_directory_credential( credential_id="credential-id", port=0 diff --git a/tests/protocols/gmpnext/entities/credentials/test_verify_active_directory_credential.py b/tests/protocols/gmpnext/entities/credentials/test_verify_active_directory_credential.py index bfeed6594..9eb66009d 100644 --- a/tests/protocols/gmpnext/entities/credentials/test_verify_active_directory_credential.py +++ b/tests/protocols/gmpnext/entities/credentials/test_verify_active_directory_credential.py @@ -4,6 +4,7 @@ # from gvm.errors import InvalidArgument, RequiredArgument +from gvm.protocols.gmp.requests.next import ActiveDirectoryTlsMode class GmpVerifyActiveDirectoryCredentialTestMixin: @@ -58,6 +59,43 @@ def test_verify_inline_ad_credential_with_optional_fields(self): b"" ) + def test_verify_inline_ad_credential_with_tls_mode_enum(self): + self.gmp.verify_active_directory_credential( + host="dc.example.org", + bind_dn="CN=Scanner,DC=example,DC=org", + bind_password="secret", + base_dn="DC=example,DC=org", + tls_mode=ActiveDirectoryTlsMode.LDAPS, + ) + + self.connection.send.has_been_called_with( + b"" + b"dc.example.org" + b"CN=Scanner,DC=example,DC=org" + b"secret" + b"DC=example,DC=org" + b"ldaps" + b"" + ) + + self.gmp.verify_active_directory_credential( + host="dc.example.org", + bind_dn="CN=Scanner,DC=example,DC=org", + bind_password="secret", + base_dn="DC=example,DC=org", + tls_mode=ActiveDirectoryTlsMode.STARTTLS, + ) + + self.connection.send.has_been_called_with( + b"" + b"dc.example.org" + b"CN=Scanner,DC=example,DC=org" + b"secret" + b"DC=example,DC=org" + b"starttls" + b"" + ) + def test_verify_without_saved_id_or_inline_fields(self): with self.assertRaises(RequiredArgument): self.gmp.verify_active_directory_credential() @@ -89,7 +127,7 @@ def test_verify_inline_ad_credential_missing_required_field(self): ) def test_verify_inline_ad_credential_invalid_tls_mode(self): - with self.assertRaises(InvalidArgument): + with self.assertRaises(InvalidArgument) as context: self.gmp.verify_active_directory_credential( host="dc.example.org", bind_dn="CN=Scanner,DC=example,DC=org", @@ -98,15 +136,58 @@ def test_verify_inline_ad_credential_invalid_tls_mode(self): tls_mode="ldap", ) + self.assertEqual(context.exception.argument, "tls_mode") + self.assertEqual( + context.exception.function, "verify_active_directory_credential" + ) + def test_verify_inline_ad_credential_invalid_port(self): - for port in (0, 65536, "389"): - with self.subTest(port=port): - with self.assertRaises(InvalidArgument): - self.gmp.verify_active_directory_credential( - host="dc.example.org", - bind_dn="CN=Scanner,DC=example,DC=org", - bind_password="secret", - base_dn="DC=example,DC=org", - tls_mode="ldaps", - port=port, - ) + with self.assertRaises(InvalidArgument): + self.gmp.verify_active_directory_credential( + host="dc.example.org", + bind_dn="CN=Scanner,DC=example,DC=org", + bind_password="secret", + base_dn="DC=example,DC=org", + tls_mode="ldaps", + port=0, + ) + + with self.assertRaises(InvalidArgument): + self.gmp.verify_active_directory_credential( + host="dc.example.org", + bind_dn="CN=Scanner,DC=example,DC=org", + bind_password="secret", + base_dn="DC=example,DC=org", + tls_mode="ldaps", + port=65536, + ) + + with self.assertRaises(InvalidArgument): + self.gmp.verify_active_directory_credential( + host="dc.example.org", + bind_dn="CN=Scanner,DC=example,DC=org", + bind_password="secret", + base_dn="DC=example,DC=org", + tls_mode="ldaps", + port="389", + ) + + with self.assertRaises(InvalidArgument): + self.gmp.verify_active_directory_credential( + host="dc.example.org", + bind_dn="CN=Scanner,DC=example,DC=org", + bind_password="secret", + base_dn="DC=example,DC=org", + tls_mode="ldaps", + port=True, + ) + + with self.assertRaises(InvalidArgument): + self.gmp.verify_active_directory_credential( + host="dc.example.org", + bind_dn="CN=Scanner,DC=example,DC=org", + bind_password="secret", + base_dn="DC=example,DC=org", + tls_mode="ldaps", + port=False, + ) diff --git a/tests/protocols/gmpnext/entities/test_active_directory.py b/tests/protocols/gmpnext/entities/test_active_directory.py new file mode 100644 index 000000000..5abd14453 --- /dev/null +++ b/tests/protocols/gmpnext/entities/test_active_directory.py @@ -0,0 +1,12 @@ +# SPDX-FileCopyrightText: 2026 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +from ...gmpnext import GMPTestCase +from .active_directory import GmpGetActiveDirectoryObjectsTestMixin + + +class GMPGetActiveDirectoryObjectsTestCase( + GmpGetActiveDirectoryObjectsTestMixin, GMPTestCase +): + pass diff --git a/tests/protocols/gmpnext/enums/test_active_directory_object_type.py b/tests/protocols/gmpnext/enums/test_active_directory_object_type.py new file mode 100644 index 000000000..067b803fb --- /dev/null +++ b/tests/protocols/gmpnext/enums/test_active_directory_object_type.py @@ -0,0 +1,46 @@ +# SPDX-FileCopyrightText: 2026 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import InvalidArgument +from gvm.protocols.gmp.requests.next import ActiveDirectoryObjectType + + +class GetActiveDirectoryObjectTypeFromStringTestCase(unittest.TestCase): + def test_invalid(self): + with self.assertRaises(InvalidArgument): + ActiveDirectoryObjectType.from_string("invalid") + + def test_none_or_empty(self): + self.assertIsNone(ActiveDirectoryObjectType.from_string(None)) + self.assertIsNone(ActiveDirectoryObjectType.from_string("")) + + def test_ou(self): + self.assertEqual( + ActiveDirectoryObjectType.from_string("ou"), + ActiveDirectoryObjectType.OU, + ) + self.assertEqual(ActiveDirectoryObjectType.OU.value, "ou") + + def test_container(self): + self.assertEqual( + ActiveDirectoryObjectType.from_string("container"), + ActiveDirectoryObjectType.CONTAINER, + ) + self.assertEqual(ActiveDirectoryObjectType.CONTAINER.value, "container") + + def test_computer(self): + self.assertEqual( + ActiveDirectoryObjectType.from_string("computer"), + ActiveDirectoryObjectType.COMPUTER, + ) + self.assertEqual(ActiveDirectoryObjectType.COMPUTER.value, "computer") + + def test_group(self): + self.assertEqual( + ActiveDirectoryObjectType.from_string("group"), + ActiveDirectoryObjectType.GROUP, + ) + self.assertEqual(ActiveDirectoryObjectType.GROUP.value, "group") diff --git a/tests/protocols/gmpnext/enums/test_active_directory_search_scope.py b/tests/protocols/gmpnext/enums/test_active_directory_search_scope.py new file mode 100644 index 000000000..cb91176d5 --- /dev/null +++ b/tests/protocols/gmpnext/enums/test_active_directory_search_scope.py @@ -0,0 +1,39 @@ +# SPDX-FileCopyrightText: 2026 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import InvalidArgument +from gvm.protocols.gmp.requests.next import ActiveDirectorySearchScope + + +class GetActiveDirectorySearchScopeFromStringTestCase(unittest.TestCase): + def test_invalid(self): + with self.assertRaises(InvalidArgument): + ActiveDirectorySearchScope.from_string("invalid") + + def test_none_or_empty(self): + self.assertIsNone(ActiveDirectorySearchScope.from_string(None)) + self.assertIsNone(ActiveDirectorySearchScope.from_string("")) + + def test_base(self): + self.assertEqual( + ActiveDirectorySearchScope.from_string("base"), + ActiveDirectorySearchScope.BASE, + ) + self.assertEqual(ActiveDirectorySearchScope.BASE.value, "base") + + def test_onelevel(self): + self.assertEqual( + ActiveDirectorySearchScope.from_string("onelevel"), + ActiveDirectorySearchScope.ONELEVEL, + ) + self.assertEqual(ActiveDirectorySearchScope.ONELEVEL.value, "onelevel") + + def test_subtree(self): + self.assertEqual( + ActiveDirectorySearchScope.from_string("subtree"), + ActiveDirectorySearchScope.SUBTREE, + ) + self.assertEqual(ActiveDirectorySearchScope.SUBTREE.value, "subtree") diff --git a/tests/protocols/gmpnext/enums/test_active_directory_tls_mode.py b/tests/protocols/gmpnext/enums/test_active_directory_tls_mode.py new file mode 100644 index 000000000..c566fbfdc --- /dev/null +++ b/tests/protocols/gmpnext/enums/test_active_directory_tls_mode.py @@ -0,0 +1,32 @@ +# SPDX-FileCopyrightText: 2026 Greenbone AG +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import unittest + +from gvm.errors import InvalidArgument +from gvm.protocols.gmp.requests.next import ActiveDirectoryTlsMode + + +class GetActiveDirectoryTlsModeFromStringTestCase(unittest.TestCase): + def test_invalid(self): + with self.assertRaises(InvalidArgument): + ActiveDirectoryTlsMode.from_string("ldap") + + def test_none_or_empty(self): + self.assertIsNone(ActiveDirectoryTlsMode.from_string(None)) + self.assertIsNone(ActiveDirectoryTlsMode.from_string("")) + + def test_ldaps(self): + self.assertEqual( + ActiveDirectoryTlsMode.from_string("ldaps"), + ActiveDirectoryTlsMode.LDAPS, + ) + self.assertEqual(ActiveDirectoryTlsMode.LDAPS.value, "ldaps") + + def test_starttls(self): + self.assertEqual( + ActiveDirectoryTlsMode.from_string("starttls"), + ActiveDirectoryTlsMode.STARTTLS, + ) + self.assertEqual(ActiveDirectoryTlsMode.STARTTLS.value, "starttls")