diff --git a/connpy/cli/run_handler.py b/connpy/cli/run_handler.py index 7a2c6e6..8004628 100644 --- a/connpy/cli/run_handler.py +++ b/connpy/cli/run_handler.py @@ -162,7 +162,10 @@ class RunHandler: path = args.data[0] try: with open(path, "r") as f: - playbook = yaml.load(f, Loader=yaml.FullLoader) + playbook = yaml.safe_load(f) + + if not isinstance(playbook, dict): + raise TypeError("Invalid playbook format: expected a dictionary") # Check preflight first before any task runs if getattr(args, "preflight_ai", False): diff --git a/connpy/core.py b/connpy/core.py index a4de4f5..ab49167 100755 --- a/connpy/core.py +++ b/connpy/core.py @@ -103,7 +103,7 @@ class node: ''' - def __init__(self, unique, host, options='', logs='', password='', port='', protocol='', user='', config='', tags='', jumphost=''): + def __init__(self, unique, host, options='', logs='', password='', port='', protocol='', user='', config='', tags='', jumphost='', allow_unsafe_options=None): ''' ### Parameters: @@ -138,14 +138,22 @@ class node: like "os", "prompt" and "screenleght_command" - jumphost (str): Reference another node to be used as a jumphost + + - allow_unsafe_options (bool): Explicitly override safety restrictions. ''' self.config = config if config == '': self.idletime = 0 self.key = None else: - self.idletime = config.config["idletime"] - self.key = config.key + self.idletime = config.config["idletime"] if (hasattr(config, "config") and isinstance(config.config, dict) and "idletime" in config.config) else 0 + self.key = getattr(config, "key", None) + if allow_unsafe_options is not None: + self.allow_unsafe_options = bool(allow_unsafe_options) + elif config != '' and config is not None and hasattr(config, "config") and isinstance(config.config, dict): + self.allow_unsafe_options = bool(config.config.get("allow_unsafe_options", False)) + else: + self.allow_unsafe_options = False self.unique = unique attr = {"host": host, "logs": logs, "options":options, "port": port, "protocol": protocol, "user": user, "tags": tags, "jumphost": jumphost} for key in attr: @@ -216,6 +224,79 @@ class node: jh_dict["password"] = [jh_dict["password"]] return jh_dict + def _is_unsafe_allowed(self) -> bool: + if getattr(self, "allow_unsafe_options", False): + return True + if hasattr(self, "config") and self.config and hasattr(self.config, "config") and isinstance(self.config.config, dict): + return bool(self.config.config.get("allow_unsafe_options", False)) + return False + + def _validate_base_fields(self, check_port=True): + """Sanitize host, user, and port against argument injection and shell metacharacters.""" + host_s = str(self.host) if self.host is not None else "" + if not host_s: + raise ValueError("Host cannot be empty") + if host_s.startswith("-"): + raise ValueError(f"Host cannot start with '-': '{self.host}'") + host_bare = ( + host_s[1:-1] + if (host_s.startswith("[") and host_s.endswith("]")) + else host_s + ) + if not host_bare or host_bare.startswith("-"): + raise ValueError(f"Invalid characters in host: '{self.host}'") + if _LEGACY_SSH_UNSAFE_RE.search(host_bare): + raise ValueError(f"Invalid characters in host: '{self.host}'") + + user_s = str(self.user) if self.user is not None else "" + if user_s: + if user_s.startswith("-"): + raise ValueError(f"User cannot start with '-': '{self.user}'") + if _LEGACY_SSH_UNSAFE_RE.search(user_s): + raise ValueError(f"Invalid characters in user: '{self.user}'") + + if check_port and self.port != "" and self.port is not None: + if isinstance(self.port, (bool, float)): + raise ValueError(f"Invalid TCP SSH port '{self.port}'") + port_s = str(self.port).strip() + if port_s: + if ( + not port_s.isascii() + or not re.fullmatch(r"[0-9]+", port_s, re.ASCII) + or not (1 <= int(port_s) <= 65535) + ): + raise ValueError(f"Invalid TCP SSH port '{self.port}'") + + def _validate_options_and_safety(self): + """Validate options string for unbalanced quotes and dangerous control characters.""" + if not self.options: + return + opts_str = str(self.options).strip() + if not opts_str: + return + if not self._is_unsafe_allowed(): + if any(c in opts_str for c in ("\n", "\r", "\x00")): + raise ValueError("Options cannot contain newlines or null bytes") + try: + shlex.split(opts_str) + except ValueError as e: + raise ValueError(f"Invalid options: unbalanced quotes ({e})") from e + + def _validate_ssh_options(self): + """Sanitize SSH options against local command execution directives.""" + self._validate_options_and_safety() + if not self.options: + return + opts_str = str(self.options).strip() + if not opts_str: + return + if not self._is_unsafe_allowed(): + dangerous_directives = ("ProxyCommand", "LocalCommand", "PermitLocalCommand", "KnownHostsCommand") + pattern = r'(?:' + '|'.join(dangerous_directives) + r')' + match = re.search(pattern, opts_str, re.IGNORECASE) + if match: + raise ValueError(f"Disallowed SSH directive in options: '{match.group(0)}'") + @staticmethod def _validate_legacy_ssh_hop_fields(host, user, port): """Minimal injection guard for legacy SSH jumphost fields (preserves DOMAIN\\user, %scope, etc.).""" @@ -1442,10 +1523,13 @@ class node: @MethodHook def _generate_ssh_sftp_cmd(self, force_ssh=False, allow_reverse_tunnel_port=None): + self._validate_base_fields(check_port=True) is_from_mosh = ( self.protocol == "mosh" or getattr(self, "_orig_protocol", "") == "mosh" ) + if not is_from_mosh: + self._validate_ssh_options() proto = "ssh" if force_ssh else self.protocol cmd = proto if is_from_mosh: @@ -1536,8 +1620,9 @@ class node: if isinstance(self.tags, dict) and self.tags.get("mosh_ssh_options"): ssh_opts = str(self.tags["mosh_ssh_options"]).strip() if ssh_opts: - if re.search(r'(?:LocalCommand|ProxyCommand)', ssh_opts, re.IGNORECASE): - raise ValueError("mosh_ssh_options cannot contain LocalCommand or ProxyCommand") + if not self._is_unsafe_allowed(): + if re.search(r'(?:LocalCommand|ProxyCommand|PermitLocalCommand|KnownHostsCommand)', ssh_opts, re.IGNORECASE): + raise ValueError("mosh_ssh_options cannot contain LocalCommand or ProxyCommand") try: shlex.split(ssh_opts) except ValueError as exc: @@ -1555,8 +1640,9 @@ class node: if opts: if re.search(r'--(?:ssh|server|client)(?:=|\s|$)', opts): raise ValueError("Options cannot override --ssh, --server or --client for mosh") - if re.search(r'(?:LocalCommand|ProxyCommand)', opts, re.IGNORECASE): - raise ValueError("Options cannot contain LocalCommand or ProxyCommand") + if not self._is_unsafe_allowed(): + if re.search(r'(?:LocalCommand|ProxyCommand|PermitLocalCommand|KnownHostsCommand)', opts, re.IGNORECASE): + raise ValueError("Options cannot contain LocalCommand or ProxyCommand") try: shlex.split(opts) except ValueError as exc: @@ -1569,6 +1655,8 @@ class node: @MethodHook def _generate_telnet_cmd(self): + self._validate_base_fields(check_port=True) + self._validate_options_and_safety() cmd = f"telnet {self.host}" if self.port: cmd += f" {self.port}" @@ -1578,22 +1666,52 @@ class node: @MethodHook def _generate_kube_cmd(self): - cmd = f"kubectl exec {self.options} {self.host} -it --" + self._validate_base_fields(check_port=False) + self._validate_options_and_safety() kube_command = self.tags.get("kube_command", "/bin/bash") if isinstance(self.tags, dict) else "/bin/bash" + if not self._is_unsafe_allowed() and kube_command: + k_str = str(kube_command) + if any(c in k_str for c in ("\n", "\r", "\x00")): + raise ValueError("kube_command cannot contain newlines or null bytes") + try: + shlex.split(k_str) + except ValueError as e: + raise ValueError(f"Invalid kube_command: unbalanced quotes ({e})") from e + cmd = f"kubectl exec {self.options} {self.host} -it --" cmd += f" {kube_command}" return cmd @MethodHook def _generate_docker_cmd(self): - cmd = f"docker {self.options} exec -it {self.host}" + self._validate_base_fields(check_port=False) + self._validate_options_and_safety() docker_command = self.tags.get("docker_command", "/bin/bash") if isinstance(self.tags, dict) else "/bin/bash" + if not self._is_unsafe_allowed() and docker_command: + d_str = str(docker_command) + if any(c in d_str for c in ("\n", "\r", "\x00")): + raise ValueError("docker_command cannot contain newlines or null bytes") + try: + shlex.split(d_str) + except ValueError as e: + raise ValueError(f"Invalid docker_command: unbalanced quotes ({e})") from e + cmd = f"docker {self.options} exec -it {self.host}" cmd += f" {docker_command}" return cmd @MethodHook def _generate_ssm_cmd(self): + self._validate_base_fields(check_port=False) + self._validate_options_and_safety() region = self.tags.get("region", "") if isinstance(self.tags, dict) else "" profile = self.tags.get("profile", "") if isinstance(self.tags, dict) else "" + if not self._is_unsafe_allowed(): + for field_name, field_val in [("region", region), ("profile", profile)]: + if field_val: + f_str = str(field_val) + if f_str.startswith("-"): + raise ValueError(f"SSM tag '{field_name}' cannot start with '-': '{field_val}'") + if re.search(r'[\s\x00-\x1f\x7f;|&$`><"\']', f_str): + raise ValueError(f"Invalid characters in SSM tag '{field_name}': '{field_val}'") cmd = f"aws ssm start-session --target {self.host}" if region: cmd += f" --region {region}" diff --git a/connpy/grpc_layer/server.py b/connpy/grpc_layer/server.py index 14e77e8..55be642 100644 --- a/connpy/grpc_layer/server.py +++ b/connpy/grpc_layer/server.py @@ -960,7 +960,7 @@ class ImportExportServicer(connpy_pb2_grpc.ImportExportServiceServicer): if request.value.startswith("---YAML---\n"): import yaml content = request.value[len("---YAML---\n"):] - data = yaml.load(content, Loader=yaml.FullLoader) + data = yaml.safe_load(content) self.service.import_from_dict(data) else: self.service.import_from_file(request.value) diff --git a/connpy/services/import_export_service.py b/connpy/services/import_export_service.py index 7d16eec..8e135e5 100644 --- a/connpy/services/import_export_service.py +++ b/connpy/services/import_export_service.py @@ -71,7 +71,7 @@ class ImportExportService(BaseService): try: with open(file_path, "r") as f: - data = yaml.load(f, Loader=yaml.FullLoader) + data = yaml.safe_load(f) self.import_from_dict(data) except Exception as e: raise InvalidConfigurationError(f"Failed to read/parse import file: {e}") diff --git a/connpy/tests/test_security_yaml_cmd.py b/connpy/tests/test_security_yaml_cmd.py new file mode 100644 index 0000000..9c77745 --- /dev/null +++ b/connpy/tests/test_security_yaml_cmd.py @@ -0,0 +1,222 @@ +"""Tests for YAML safe deserialization and connection options sanitization with allow_unsafe_options.""" + +from unittest.mock import MagicMock, patch + +import pytest + +from connpy.cli.run_handler import RunHandler +from connpy.core import node +from connpy.grpc_layer.server import ImportExportServicer +from connpy.services.exceptions import InvalidConfigurationError +from connpy.services.import_export_service import ImportExportService + +# ========================================================================= +# 1. Tests de Deserialización YAML Segura +# ========================================================================= + + +class TestYamlSafeDeserialization: + def test_import_export_service_rejects_unsafe_yaml(self, config, tmp_path): + """YAML with !!python/object/apply must fail with InvalidConfigurationError and never execute.""" + malicious_yaml = tmp_path / "malicious.yaml" + malicious_yaml.write_text('!!python/object/apply:os.system ["echo pwned"]') + + service = ImportExportService(config) + + with patch("os.system") as mock_system: + with pytest.raises(InvalidConfigurationError): + service.import_from_file(str(malicious_yaml)) + mock_system.assert_not_called() + + def test_grpc_import_from_file_rejects_unsafe_yaml(self): + """gRPC import with !!python/object/apply must abort via context and never execute.""" + payload = '---YAML---\n!!python/object/apply:os.system ["echo pwned"]' + request = MagicMock() + request.value = payload + context = MagicMock() + + provider = MagicMock() + servicer = ImportExportServicer(provider) + + with patch("os.system") as mock_system: + servicer.import_from_file(request, context) + context.abort.assert_called_once() + mock_system.assert_not_called() + + def test_run_handler_yaml_run_rejects_unsafe_yaml(self, tmp_path): + """RunHandler.yaml_run with !!python/object/apply exits cleanly with code 10 and never executes.""" + malicious_playbook = tmp_path / "bad_playbook.yaml" + malicious_playbook.write_text( + 'tasks:\n - name: exploit\n action: run\n nodes: all\n commands:\n - !!python/object/apply:os.system ["echo pwned"]\n' + ) + + app = MagicMock() + handler = RunHandler(app) + args = MagicMock() + args.data = [str(malicious_playbook)] + args.preflight_ai = False + args.analyze = None + + with patch("os.system") as mock_system: + with pytest.raises(SystemExit) as exc_info: + handler.yaml_run(args) + assert exc_info.value.code == 10 + mock_system.assert_not_called() + + def test_run_handler_yaml_run_rejects_non_dict_yaml(self, tmp_path): + """RunHandler.yaml_run with empty or non-dict YAML exits cleanly with code 10.""" + non_dict_playbook = tmp_path / "list_playbook.yaml" + non_dict_playbook.write_text("- item1\n- item2\n") + + app = MagicMock() + handler = RunHandler(app) + args = MagicMock() + args.data = [str(non_dict_playbook)] + args.preflight_ai = False + args.analyze = None + + with pytest.raises(SystemExit) as exc_info: + handler.yaml_run(args) + assert exc_info.value.code == 10 + + +# ========================================================================= +# 2. Tests Negativos de Inyección en Protocolos (allow_unsafe_options=False) +# ========================================================================= + + +class TestProtocolInjectionNegative: + @pytest.mark.parametrize("proto", ["ssh", "sftp", "telnet", "kubectl", "docker", "ssm"]) + def test_host_starting_with_dash_raises_value_error(self, proto): + """Host starting with '-' raises ValueError across all protocols.""" + n = node("bad_node", "-oProxyCommand=id", protocol=proto) + with pytest.raises(ValueError, match="Host cannot start with '-'"): + n._get_cmd() + + @pytest.mark.parametrize("proto", ["ssh", "sftp", "telnet", "kubectl", "docker", "ssm"]) + def test_host_with_unsafe_characters_raises_value_error(self, proto): + """Host containing whitespace, control characters or shell metacharacters raises ValueError.""" + for bad_host in ["host; id", "host | id", "host`id`", "host$id", "host&id"]: + n = node("bad_node", bad_host, protocol=proto) + with pytest.raises(ValueError, match="Invalid characters in host"): + n._get_cmd() + + @pytest.mark.parametrize("proto", ["ssh", "sftp", "telnet", "kubectl", "docker", "ssm"]) + def test_user_starting_with_dash_raises_value_error(self, proto): + """User starting with '-' raises ValueError across all protocols.""" + n = node("n1", "10.0.0.1", user="-oProxyCommand=id", protocol=proto) + with pytest.raises(ValueError, match="User cannot start with '-'"): + n._get_cmd() + + @pytest.mark.parametrize("proto", ["ssh", "sftp", "telnet", "kubectl", "docker", "ssm"]) + def test_user_with_unsafe_characters_raises_value_error(self, proto): + """User containing shell metacharacters raises ValueError across all protocols.""" + for bad_user in ["; id", "user | id", "user`id`", "user$id", "user&id"]: + n = node("n1", "10.0.0.1", user=bad_user, protocol=proto) + with pytest.raises(ValueError, match="Invalid characters in user"): + n._get_cmd() + + @pytest.mark.parametrize("proto", ["ssh", "sftp", "telnet"]) + def test_invalid_port_raises_value_error(self, proto): + """Invalid port in SSH/SFTP/Telnet raises ValueError.""" + for bad_port in ["22 -oProxyCommand=id", "99999", "abc", "0", "-1"]: + n = node("n1", "10.0.0.1", port=bad_port, protocol=proto) + with pytest.raises(ValueError, match="Invalid TCP SSH port"): + n._get_cmd() + + @pytest.mark.parametrize("proto", ["ssh", "sftp"]) + def test_dangerous_ssh_directives_in_options_raise_value_error(self, proto): + """Directives like ProxyCommand, LocalCommand, etc. in options raise ValueError.""" + dangerous_opts = [ + '-o ProxyCommand="sh -c id"', + "-oProxyCommand=id", + '-o LocalCommand="id"', + "-o PermitLocalCommand=yes", + '-o KnownHostsCommand="id"', + '-o "ProxyCommand=id"', + "-o proxycommand=id", + ] + for opt in dangerous_opts: + n = node("n1", "10.0.0.1", options=opt, protocol=proto) + with pytest.raises(ValueError, match="Disallowed SSH directive in options"): + n._get_cmd() + + @pytest.mark.parametrize("proto", ["ssh", "sftp", "telnet", "kubectl", "docker", "ssm"]) + def test_unbalanced_quotes_in_options_raise_value_error(self, proto): + """Unbalanced quotes in options raise ValueError.""" + n = node("n1", "10.0.0.1", options='-o "StrictHostKeyChecking=no', protocol=proto) + with pytest.raises(ValueError, match="unbalanced quotes"): + n._get_cmd() + + def test_ssm_invalid_region_or_profile_tags_raise_value_error(self): + """SSM tags 'region' and 'profile' reject leading dash and shell metacharacters.""" + n_reg = node("ssm1", "i-1234567890abcdef0", protocol="ssm", tags={"region": "us-east-1; id"}) + with pytest.raises(ValueError, match="Invalid characters in SSM tag"): + n_reg._get_cmd() + + n_prof = node("ssm2", "i-1234567890abcdef0", protocol="ssm", tags={"profile": "-bad"}) + with pytest.raises(ValueError, match="cannot start with '-'"): + n_prof._get_cmd() + + def test_container_command_validation(self): + """Kube and Docker commands reject newlines and unbalanced quotes.""" + n_kube = node("k1", "pod-1", protocol="kubectl", tags={"kube_command": 'sh -c "echo\nid"'}) + with pytest.raises(ValueError, match="cannot contain newlines or null bytes"): + n_kube._get_cmd() + + n_kube_q = node("k2", "pod-1", protocol="kubectl", tags={"kube_command": 'sh -c "unclosed'}) + with pytest.raises(ValueError, match="unbalanced quotes"): + n_kube_q._get_cmd() + + n_doc = node("d1", "cont-1", protocol="docker", tags={"docker_command": 'sh -c "echo\nid"'}) + with pytest.raises(ValueError, match="cannot contain newlines or null bytes"): + n_doc._get_cmd() + + n_doc_q = node("d2", "cont-1", protocol="docker", tags={"docker_command": 'sh -c "unclosed'}) + with pytest.raises(ValueError, match="unbalanced quotes"): + n_doc_q._get_cmd() + + +# ========================================================================= +# 3. Tests Positivos de Regresión y allow_unsafe_options=True +# ========================================================================= + + +class TestPositiveAndAllowUnsafeOptions: + def test_ssh_jumphost_proxycommand_allowed_when_safe_mode(self, populated_config): + """Valid jumphost chain still generates -o ProxyCommand correctly when allow_unsafe_options=False.""" + # populated_config has 'router1' + n = node("target", "10.0.0.2", protocol="ssh", jumphost="router1", config=populated_config) + cmd = n._get_cmd() + assert '-o ProxyCommand="' in cmd + assert "ssh -W %h:%p" in cmd + assert "admin@10.0.0.1" in cmd + + def test_ssh_safe_options_permitted(self): + """Benign SSH options work without issue.""" + safe_opts = "-o StrictHostKeyChecking=no -i ~/.ssh/id_rsa -L 8080:localhost:80" + n = node("s1", "10.0.0.1", protocol="ssh", options=safe_opts) + cmd = n._get_cmd() + assert safe_opts in cmd + + def test_user_domain_and_ipv6_bracketed_permitted(self): + """Formats like DOMAIN\\user and bracketed IPv6 [2001:db8::1] remain supported.""" + n = node("s1", "[2001:db8::1]", user=r"DOMAIN\user", protocol="ssh", port="22") + cmd = n._get_cmd() + assert r"DOMAIN\user@[2001:db8::1]" in cmd + assert "-p 22" in cmd + + def test_allow_unsafe_options_via_config(self, populated_config): + """When config.config['allow_unsafe_options'] is True, ProxyCommand in options is allowed.""" + populated_config.config["allow_unsafe_options"] = True + custom_proxy = '-o ProxyCommand="ssh -W %h:%p bastion"' + n = node("s1", "10.0.0.1", protocol="ssh", options=custom_proxy, config=populated_config) + cmd = n._get_cmd() + assert custom_proxy in cmd + + def test_allow_unsafe_options_via_kwarg(self): + """When allow_unsafe_options=True passed to node, dangerous options are allowed.""" + custom_proxy = '-o ProxyCommand="ssh -W %h:%p bastion"' + n = node("s1", "10.0.0.1", protocol="ssh", options=custom_proxy, allow_unsafe_options=True) + cmd = n._get_cmd() + assert custom_proxy in cmd