Skip to content

Open-source Python library for AI browser agents, plus Browser Use Cloud: stealth browsers and a hosted agent API.

fix(utils): prevent redact_sensitive_string cascade corruption (#5135)

Santhef1a51d4f4fd
diff --git a/browser_use/utils.py b/browser_use/utils.py
index 6298e66f9..380c8aa98 100644
--- a/browser_use/utils.py
+++ b/browser_use/utils.py
@@ -75,9 +75,18 @@ def collect_sensitive_data_values(sensitive_data: dict[str, str | dict[str, str]
def redact_sensitive_string(value: str, sensitive_values: dict[str, str]) -> str:
"""Replace sensitive values with placeholders, longest matches first to avoid partial leaks."""
- for key, secret in sorted(sensitive_values.items(), key=lambda item: len(item[1]), reverse=True):
- value = value.replace(secret, f'<secret>{key}</secret>')
- return value
+ if not sensitive_values:
+ return value
+
+ # Build a lookup from secret text → key name, longest secrets first so
+ # the regex alternation prefers the longest match.
+ sorted_items = sorted(sensitive_values.items(), key=lambda item: len(item[1]), reverse=True)
+ secret_to_key = {secret: key for key, secret in sorted_items}
+
+ # Single-pass replacement: each position in the string is consumed at
+ # most once, so earlier replacements cannot be corrupted by later ones.
+ pattern = re.compile('|'.join(re.escape(secret) for secret in secret_to_key))
+ return pattern.sub(lambda m: f'<secret>{secret_to_key[m.group(0)]}</secret>', value)
def _get_openai_bad_request_error() -> type | None:
diff --git a/tests/ci/test_redact_cascade.py b/tests/ci/test_redact_cascade.py
new file mode 100644
index 000000000..daffa3c47
--- /dev/null
+++ b/tests/ci/test_redact_cascade.py
@@ -0,0 +1,48 @@
+"""Tests for redact_sensitive_string to ensure no cascading/corruption."""
+
+from browser_use.utils import redact_sensitive_string
+
+
+def test_normal_redaction():
+ """Basic redaction replaces secret values with tagged placeholders."""
+ sensitive = {'password': 'hunter2'}
+ result = redact_sensitive_string('my password is hunter2', sensitive)
+ assert result == 'my password is <secret>password</secret>'
+
+
+def test_cascade_substring_secret():
+ """A shorter secret that is a substring of a placeholder tag must not corrupt output.
+
+ Regression test for issue #5135.
+ """
+ sensitive = {'password': 'supersecret', 'type': 'secret'}
+ result = redact_sensitive_string('supersecret', sensitive)
+ # 'supersecret' should be replaced first (longest), and 'secret' must NOT
+ # then corrupt the '<secret>password</secret>' tag.
+ assert result == '<secret>password</secret>'
+
+
+def test_multiple_overlapping_secrets():
+ """Multiple secrets where one is a prefix/substring of another."""
+ sensitive = {'short': 'abc', 'long': 'abcdef'}
+ result = redact_sensitive_string('abcdef and abc', sensitive)
+ assert result == '<secret>long</secret> and <secret>short</secret>'
+
+
+def test_empty_secrets_returns_original():
+ """An empty sensitive_values dict returns the original string unchanged."""
+ assert redact_sensitive_string('nothing to redact', {}) == 'nothing to redact'
+
+
+def test_secret_value_matches_tag_syntax():
+ """A secret whose value looks like XML tag syntax is handled correctly."""
+ sensitive = {'key': '<secret>'}
+ result = redact_sensitive_string('the value is <secret>', sensitive)
+ assert result == 'the value is <secret>key</secret>'
+
+
+def test_multiple_occurrences():
+ """All occurrences of the same secret are replaced."""
+ sensitive = {'tok': 'xyz'}
+ result = redact_sensitive_string('xyz-xyz-xyz', sensitive)
+ assert result == '<secret>tok</secret>-<secret>tok</secret>-<secret>tok</secret>'