fix(security): enhance error handling and sensitive information filte…

…ring

- Add safe path check function to prevent open redirects
- Improve error message handling, filter sensitive information and stack traces
- Implement unified secure error responses in Docker sandbox and agents
- Add test cases to verify security filtering functionality

docs-cn/config-examples/superset/oauth_config.py

@@ -250,12 +250,24 @@ def _validate_origin(cls, raw):
         origin = cls._normalise_origin(raw)
         return origin if origin in cls._allowed_origins() else ""
 
+    @staticmethod
+    def _safe_next_path(raw_path):
+        """只允许站内相对路径进入 login next 参数。"""
+        next_path = (raw_path or "/").rstrip("?").replace("\\", "/")
+        parsed = urlparse(next_path)
+        if (
+            not next_path.startswith("/")
+            or next_path.startswith("//")
+            or parsed.scheme
+            or parsed.netloc
+        ):
+            return "/"
+        return next_path
+
     @expose("/", methods=["GET"])
     def df_sso_bridge(self):
         if not self._is_real_logged_in_user():
-            next_url = request.full_path.rstrip("?")
-            if not next_url.startswith("/"):
-                next_url = "/"
+            next_url = self._safe_next_path(request.full_path)
             return redirect(f"/login/?next={quote(next_url)}")
 
         df_origin = self._validate_origin(request.args.get("df_origin"))

py-src/data_formulator/agents/agent_data_rec.py

@@ -6,8 +6,8 @@
 
 from data_formulator.agents.agent_utils import extract_json_objects, extract_code_from_gpt_response, generate_data_summary, supplement_missing_block, ensure_output_variable_in_code
 from data_formulator.agents.agent_diagnostics import AgentDiagnostics
+from data_formulator.security.sanitize import sanitize_error_message
 
-import traceback
 import pandas as pd
 
 import logging
@@ -254,8 +254,10 @@ def process_gpt_response(self, input_tables, messages, response, t_llm=None):
         t_exec_total = 0.0
 
         if isinstance(response, Exception):
-            result = {'status': 'other error', 'content': str(response.body),
-                      'diagnostics': self._diag.for_error(messages, error=str(response.body))}
+            raw_error = str(getattr(response, "body", response))
+            safe_error = sanitize_error_message(raw_error)
+            result = {'status': 'other error', 'content': safe_error,
+                      'diagnostics': self._diag.for_error(messages, error=safe_error)}
             return [result]
 
         candidates = []
@@ -337,9 +339,18 @@ def process_gpt_response(self, input_tables, messages, response, t_llm=None):
                     )
                     t_exec_total += time.time() - t_exec_start
 
+                    if execution_result['status'] != 'ok':
+                        diagnostics = execution_result.get("diagnostics", {})
+                        raw_exec_error = diagnostics.get(
+                            "safe_detail",
+                            execution_result.get('content', execution_result.get('error_message', 'Unknown error')),
+                        )
+                        safe_exec_error = sanitize_error_message(raw_exec_error)
+                    else:
+                        safe_exec_error = None
                     _diag_exec = {
                         "status": execution_result['status'],
-                        "error_message": execution_result.get('content') if execution_result['status'] != 'ok' else None,
+                        "error_message": safe_exec_error,
                         "available_dataframes": execution_result.get('df_names', []),
                     }
 
@@ -368,19 +379,22 @@ def process_gpt_response(self, input_tables, messages, response, t_llm=None):
                             },
                         }
                     else:
-                        error_message = execution_result.get('content', execution_result.get('error_message', 'Unknown error'))
                         result = {
                             'status': 'error',
                             'code': code,
-                            'content': error_message
+                            'content': safe_exec_error or 'Unknown error'
                         }
 
                 except Exception as e:
-                    logger.warning('Error occurred during code execution:')
-                    error_message = traceback.format_exc()
-                    logger.warning(error_message)
-                    result = {'status': 'other error', 'code': code, 'content': f"Unexpected error: {error_message}", 'content_code': 'agent.unexpectedError'}
-                    _diag_exec = {"status": "exception", "error_message": str(e)}
+                    logger.exception('Error occurred during code execution')
+                    safe_error = sanitize_error_message(f"{type(e).__name__}: {e}")
+                    result = {
+                        'status': 'other error',
+                        'code': code,
+                        'content': "Unexpected error during code execution.",
+                        'content_code': 'agent.unexpectedError'
+                    }
+                    _diag_exec = {"status": "exception", "error_message": safe_error}
             else:
                 result = {'status': 'error', 'code': "", 'content': "No code block found in the response. The model is unable to generate code to complete the task.", 'content_code': 'agent.noCodeBlock'}
 

py-src/data_formulator/agents/agent_data_transform.py

@@ -6,6 +6,7 @@
 
 from data_formulator.agents.agent_utils import extract_json_objects, extract_code_from_gpt_response, supplement_missing_block, ensure_output_variable_in_code
 from data_formulator.agents.agent_diagnostics import AgentDiagnostics
+from data_formulator.security.sanitize import sanitize_error_message
 from data_formulator.agents.agent_data_rec import (
     SHARED_ENVIRONMENT,
     SHARED_SEMANTIC_TYPE_REFERENCE,
@@ -156,8 +157,10 @@ def process_gpt_response(self, response, messages, t_llm=None):
         t_exec_total = 0.0
 
         if isinstance(response, Exception):
-            result = {'status': 'other error', 'content': str(response.body),
-                      'diagnostics': self._diag.for_error(messages, error=str(response.body))}
+            raw_error = str(getattr(response, "body", response))
+            safe_error = sanitize_error_message(raw_error)
+            result = {'status': 'other error', 'content': safe_error,
+                      'diagnostics': self._diag.for_error(messages, error=safe_error)}
             return [result]
 
         candidates = []
@@ -237,9 +240,18 @@ def process_gpt_response(self, response, messages, t_llm=None):
                     )
                     t_exec_total += time.time() - t_exec_start
 
+                    if execution_result['status'] != 'ok':
+                        diagnostics = execution_result.get("diagnostics", {})
+                        raw_exec_error = diagnostics.get(
+                            "safe_detail",
+                            execution_result.get('content', execution_result.get('error_message', 'Unknown error')),
+                        )
+                        safe_exec_error = sanitize_error_message(raw_exec_error)
+                    else:
+                        safe_exec_error = None
                     _diag_exec = {
                         "status": execution_result['status'],
-                        "error_message": execution_result.get('content') if execution_result['status'] != 'ok' else None,
+                        "error_message": safe_exec_error,
                         "available_dataframes": execution_result.get('df_names', []),
                     }
 
@@ -271,15 +283,18 @@ def process_gpt_response(self, response, messages, t_llm=None):
                         result = {
                             'status': 'error',
                             'code': code,
-                            'content': execution_result['content']
+                            'content': safe_exec_error or 'Unknown error'
                         }
 
                 except Exception as e:
-                    logger.warning('Error occurred during code execution:')
-                    logger.warning(f"Error type: {type(e).__name__}, message: {str(e)}")
-                    error_message = f"An error occurred during code execution. Error type: {type(e).__name__}, message: {str(e)}"
-                    result = {'status': 'error', 'code': code, 'content': error_message}
-                    _diag_exec = {"status": "exception", "error_message": str(e)}
+                    logger.exception('Error occurred during code execution')
+                    safe_error = sanitize_error_message(f"{type(e).__name__}: {e}")
+                    result = {
+                        'status': 'error',
+                        'code': code,
+                        'content': "An error occurred during code execution."
+                    }
+                    _diag_exec = {"status": "exception", "error_message": safe_error}
 
             else:
                 result = {'status': 'error', 'code': "", 'content': "No code block found in the response. The model is unable to generate code to complete the task.", 'content_code': 'agent.noCodeBlock'}

py-src/data_formulator/sandbox/docker_sandbox.py

@@ -21,6 +21,7 @@
 import pandas as pd
 
 from data_formulator.datalake.parquet_utils import safe_data_filename
+from data_formulator.security.sanitize import sanitize_error_message
 from .base import Sandbox
 
 logger = logging.getLogger(__name__)
@@ -35,6 +36,15 @@
 DEFAULT_TIMEOUT = int(os.environ.get("DOCKER_SANDBOX_TIMEOUT", "120"))
 
 
+def _safe_error_response(content, detail=None):
+    response = {"status": "error", "content": content}
+    if detail:
+        safe_detail = sanitize_error_message(detail)
+        if safe_detail:
+            response["diagnostics"] = {"safe_detail": safe_detail}
+    return response
+
+
 class DockerSandbox(Sandbox):
     """Execute Python code inside a Docker container.
 
@@ -179,22 +189,25 @@ def run_python_code(
                     ),
                 }
             except Exception as exc:
+                logger.exception("Failed to start Docker container")
                 self._cleanup(tmpdir)
-                return {
-                    "status": "error",
-                    "content": f"Failed to start Docker container: {exc}",
-                }
+                return _safe_error_response(
+                    "Failed to start Docker container.",
+                    f"{type(exc).__name__}: {exc}",
+                )
 
             stdout = proc.stdout or ""
             stderr = proc.stderr or ""
 
             if proc.returncode != 0 or "__DOCKER_SANDBOX_OK__" not in stdout:
                 self._cleanup(tmpdir)
                 err_detail = stderr.strip() or stdout.strip() or "Unknown error"
-                return {
-                    "status": "error",
-                    "content": f"Docker sandbox execution failed:\n{err_detail}",
-                }
+                logger.error("Docker sandbox execution failed: %s", err_detail)
+                safe_detail = sanitize_error_message(err_detail)
+                return _safe_error_response(
+                    safe_detail or "Docker sandbox execution failed.",
+                    safe_detail,
+                )
 
             # ---- read back output ---------------------------------------------
             # Defensive: ensure the filename stays inside output_dir even if
@@ -226,11 +239,12 @@ def run_python_code(
             try:
                 output_df = pd.read_parquet(parquet_out)
             except Exception as exc:
+                logger.exception("Failed to read output parquet")
                 self._cleanup(tmpdir)
-                return {
-                    "status": "error",
-                    "content": f"Failed to read output parquet: {exc}",
-                }
+                return _safe_error_response(
+                    "Failed to read output parquet.",
+                    f"{type(exc).__name__}: {exc}",
+                )
 
             self._cleanup(tmpdir)
             return {"status": "ok", "content": output_df}

py-src/data_formulator/security/sanitize.py

@@ -21,6 +21,26 @@
 _GENERIC_502 = "Upstream service unavailable"
 _GENERIC_4XX = "Bad request"
 
+
+def _extract_traceback_summary(message: str) -> str:
+    """Return the final exception line from a Python traceback when possible."""
+    if "Traceback (most recent call last):" not in message:
+        return message
+
+    for line in reversed(message.splitlines()):
+        stripped = line.strip()
+        if not stripped:
+            continue
+        if stripped.startswith("Traceback (most recent call last):"):
+            continue
+        if stripped.startswith("File "):
+            continue
+        if stripped.startswith("^"):
+            continue
+        if re.match(r"^[\w.]+(?:Error|Exception|Warning|Interrupt|Exit)\b", stripped):
+            return stripped
+    return ""
+
 _HTTP_CLIENT_MESSAGES: dict[int, str] = {
     400: "Bad request",
     401: "Authentication required",
@@ -151,11 +171,11 @@ def sanitize_error_message(error_message: str) -> str:
     summary is returned to the browser.
     """
     # Cap input length first to prevent ReDoS on crafted payloads.
-    message = html.escape(error_message[:2000])
+    message = html.escape(_extract_traceback_summary(error_message[:2000]))
 
-    # Remove API keys / tokens
+    # Remove credentials and tokens from key=value-style messages.
     message = re.sub(
-        r'(api[-_]?key|api[-_]?token)[=:]\s*[^\s&]+',
+        r'(api[-_]?key|api[-_]?token|access[-_]?token|refresh[-_]?token|token|password|passwd|pwd|secret|client[-_]?secret|connection[-_]?string)[=:]\s*[^\s&]+',
         r'\1=<redacted>', message, flags=re.IGNORECASE,
     )
 

tests/backend/routes/test_agent_diagnostics_wiring.py

@@ -122,6 +122,39 @@ def test_exception_response_has_error_diagnostics(self) -> None:
         assert diag["agent"] == "DataRecAgent"
         assert diag["error"] == "rate limit"
 
+    @patch("data_formulator.agents.agent_data_rec.supplement_missing_block")
+    @patch("data_formulator.sandbox.create_sandbox")
+    def test_execution_exception_diagnostics_are_sanitized(self, mock_sandbox_factory, mock_supplement) -> None:
+        mock_supplement.return_value = (
+            {"chart_type": "Bar Chart", "output_variable": "result_df"},
+            ["result_df = pd.DataFrame({'x':[1]})"],
+            None,
+            0.0,
+        )
+        import pandas as pd
+        mock_sandbox = MagicMock()
+        mock_sandbox.run_python_code.return_value = {
+            "status": "ok",
+            "content": pd.DataFrame({"x": [1]}),
+        }
+        mock_sandbox_factory.return_value = mock_sandbox
+
+        agent = self._make_agent()
+        agent.workspace.write_parquet.side_effect = RuntimeError(
+            r"boom C:\Users\dev\secret.txt token=secret-token"
+        )
+        response = _make_llm_response(LLM_CONTENT_WITH_JSON_AND_CODE)
+        messages = [{"role": "system", "content": "sys"}, {"role": "user", "content": "q"}]
+
+        candidate = agent.process_gpt_response([], messages, response)[0]
+
+        assert candidate["content"] == "Unexpected error during code execution."
+        exec_error = candidate["diagnostics"]["execution"]["error_message"]
+        assert "RuntimeError" in exec_error
+        assert "Traceback" not in exec_error
+        assert r"C:\Users\dev" not in exec_error
+        assert "secret-token" not in exec_error
+
 
 # ---------------------------------------------------------------------------
 # DataTransformationAgent
@@ -182,6 +215,39 @@ def test_exception_response_has_error_diagnostics(self) -> None:
         assert diag["agent"] == "DataTransformationAgent"
         assert diag["error"] == "server error"
 
+    @patch("data_formulator.agents.agent_data_transform.supplement_missing_block")
+    @patch("data_formulator.sandbox.create_sandbox")
+    def test_execution_exception_diagnostics_are_sanitized(self, mock_sandbox_factory, mock_supplement) -> None:
+        mock_supplement.return_value = (
+            {"chart_type": "Bar Chart", "output_variable": "result_df"},
+            ["result_df = pd.DataFrame({'x':[1]})"],
+            None,
+            0.0,
+        )
+        import pandas as pd
+        mock_sandbox = MagicMock()
+        mock_sandbox.run_python_code.return_value = {
+            "status": "ok",
+            "content": pd.DataFrame({"x": [1]}),
+        }
+        mock_sandbox_factory.return_value = mock_sandbox
+
+        agent = self._make_agent()
+        agent.workspace.write_parquet.side_effect = RuntimeError(
+            r"boom /tmp/workspace/secret.txt token=secret-token"
+        )
+        response = _make_llm_response(LLM_CONTENT_WITH_JSON_AND_CODE)
+        messages = [{"role": "system", "content": "sys"}, {"role": "user", "content": "q"}]
+
+        candidate = agent.process_gpt_response(response, messages)[0]
+
+        assert candidate["content"] == "An error occurred during code execution."
+        exec_error = candidate["diagnostics"]["execution"]["error_message"]
+        assert "RuntimeError" in exec_error
+        assert "Traceback" not in exec_error
+        assert "/tmp/workspace" not in exec_error
+        assert "secret-token" not in exec_error
+
 
 # ---------------------------------------------------------------------------
 # DataLoadAgent