fix regexp with pipe in signatureStr of trusted-suppress-native-method. #473

AG-38902

Squashed commit of the following:

commit 9548f83
Author: slvvko <v.leleka@adguard.com>
Date:   Wed Feb 4 10:59:40 2026 -0500

    clean up storages in afterEach

commit 238eb3f
Merge: f5b4010 7e9d4b4
Author: slvvko <v.leleka@adguard.com>
Date:   Wed Feb 4 10:55:27 2026 -0500

    Merge branch 'master' into fix/AG-38902

commit f5b4010
Merge: 468b48b 1ed9b5f
Author: slvvko <v.leleka@adguard.com>
Date:   Tue Feb 3 19:39:25 2026 -0500

    Merge branch 'master' into fix/AG-38902

commit 468b48b
Author: slvvko <v.leleka@adguard.com>
Date:   Tue Feb 3 19:38:31 2026 -0500

    fix test

commit 1288c55
Author: slvvko <v.leleka@adguard.com>
Date:   Mon Feb 2 21:44:59 2026 -0500

    fix changelog

commit 149caca
Author: slvvko <v.leleka@adguard.com>
Date:   Mon Feb 2 21:44:06 2026 -0500

    fix tests diff

commit d0c3d57
Author: slvvko <v.leleka@adguard.com>
Date:   Mon Feb 2 21:42:11 2026 -0500

    fix regexp with pipe in signatureStr of trusted-suppress-native-method

Author: slvvko

CHANGELOG.md

@@ -34,12 +34,15 @@ The format is based on [Keep a Changelog], and this project adheres to [Semantic
 - XHR scriptlet bypass vulnerability in `trusted-replace-xhr-response`,
   `prevent-xhr`, and `xml-prune` scriptlets where
   setting `xhr.shouldBePrevented = false` could disable the scriptlet [#386].
+- Parsing of regexp patterns containing pipe `|` character in `signatureStr` arg
+  of `trusted-suppress-native-method` scriptlet [#473].
 
 [Unreleased]: https://github.com/AdguardTeam/Scriptlets/compare/v2.2.15...HEAD
 [#329]: https://github.com/AdguardTeam/Scriptlets/issues/329
 [#386]: https://github.com/AdguardTeam/Scriptlets/issues/386
 [#422]: https://github.com/AdguardTeam/Scriptlets/issues/422
 [#461]: https://github.com/AdguardTeam/Scriptlets/issues/461
+[#473]: https://github.com/AdguardTeam/Scriptlets/issues/473
 [#486]: https://github.com/AdguardTeam/Scriptlets/issues/486
 [#507]: https://github.com/AdguardTeam/Scriptlets/issues/507
 [#528]: https://github.com/AdguardTeam/Scriptlets/issues/528

src/helpers/string-utils.ts

@@ -606,3 +606,76 @@ export const splitByNotEscapedDelimiter = (string: string, delimiter: string) =>
     result.push(current);
     return result;
 };
+
+/**
+ * Splits a string by pipe `|` delimiter, but respects regex boundaries.
+ * Content between `/` and `/` (including optional flags) is preserved.
+ *
+ * **!IMPORTANT**: Do not change this to an arrow function, as it will not be bundled correctly!
+ *
+ * @param str String to split.
+ *
+ * @returns Array of substrings.
+ *
+ * @example
+ * splitByPipeRespectingRegex('/(foo|bar)/|"test"') // ['/(foo|bar)/', '"test"']
+ * splitByPipeRespectingRegex('/pattern/gi|123')    // ['/pattern/gi', '123']
+ */
+export function splitByPipeRespectingRegex(str: string): string[] {
+    const PIPE = '|';
+    const SLASH = '/';
+    const BACKSLASH = '\\';
+    const result: string[] = [];
+    let current = '';
+    let insideRegex = false;
+    let i = 0;
+
+    while (i < str.length) {
+        const char = str[i];
+
+        if (!insideRegex) {
+            // Check if entering regex (current segment starts with /)
+            if (char === SLASH && current === '') {
+                insideRegex = true;
+                current += char;
+                i += 1;
+                continue;
+            }
+
+            // Split on pipe when outside regex
+            if (char === PIPE) {
+                result.push(current);
+                current = '';
+                i += 1;
+                continue;
+            }
+        } else if (char === SLASH) {
+            // Inside regex: check for closing slash (unescaped)
+            // Check if escaped by counting preceding backslashes
+            let backslashCount = 0;
+            let j = current.length - 1;
+            while (j >= 0 && current[j] === BACKSLASH) {
+                backslashCount += 1;
+                j -= 1;
+            }
+            // Slash is escaped if preceded by odd number of backslashes
+            if (backslashCount % 2 === 0) {
+                current += char;
+                i += 1;
+                // Consume optional regex flags (g, i, m, s, u, y, d)
+                while (i < str.length && /[gimsuy]/.test(str[i])) {
+                    current += str[i];
+                    i += 1;
+                }
+                insideRegex = false;
+                continue;
+            }
+        }
+
+        current += char;
+        i += 1;
+    }
+
+    result.push(current);
+    return result;
+}

src/scriptlets/trusted-suppress-native-method.ts

@@ -20,6 +20,7 @@ import {
     isObjectMatched,
     backupRegExpValues,
     restoreRegExpValues,
+    splitByPipeRespectingRegex,
 } from '../helpers';
 import { type Source } from './scriptlets';
 
@@ -121,7 +122,7 @@ export function trustedSuppressNativeMethod(
 
     let signatureMatcher: unknown[];
     try {
-        signatureMatcher = signatureStr.split('|').map((value) => {
+        signatureMatcher = splitByPipeRespectingRegex(signatureStr).map((value) => {
             return value === IGNORE_ARG_SYMBOL ? value : inferValue(value);
         });
     } catch (e) {
@@ -222,6 +223,7 @@ trustedSuppressNativeMethod.injections = [
     getAbortFunc,
     matchStackTrace,
     getErrorMessage,
+    splitByPipeRespectingRegex,
     // following helpers should be imported and injected
     // because they are used by helpers above
     shouldAbortInlineOrInjectedScript,

tests/helpers/string-utils.spec.js

@@ -5,6 +5,7 @@ import {
     inferValue,
     extractRegexAndReplacement,
     splitByNotEscapedDelimiter,
+    splitByPipeRespectingRegex,
 } from '../../src/helpers';
 
 describe('Test string utils', () => {
@@ -527,4 +528,153 @@ describe('Test string utils', () => {
             expect(result).toStrictEqual([',']);
         });
     });
+
+    describe('splitByPipeRespectingRegex', () => {
+        test('regexp with pipe character - issue #473', () => {
+            const result = splitByPipeRespectingRegex('/(foo|bar)/');
+            expect(result).toStrictEqual(['/(foo|bar)/']);
+        });
+
+        test('regexp with pipe and additional string argument', () => {
+            const result = splitByPipeRespectingRegex('/(foo|bar)/|"test"');
+            expect(result).toStrictEqual([
+                '/(foo|bar)/',
+                '"test"',
+            ]);
+        });
+
+        test('regexp with pipe and multiple string arguments', () => {
+            const result = splitByPipeRespectingRegex('/(key|other)/|"test-value"|"prevent"');
+            expect(result).toStrictEqual([
+                '/(key|other)/',
+                '"test-value"',
+                '"prevent"',
+            ]);
+        });
+
+        test('multiple regexp patterns with pipes and string argument', () => {
+            const result = splitByPipeRespectingRegex('/(a|b)/|/(#c|d)/|"string"');
+            expect(result).toStrictEqual([
+                '/(a|b)/',
+                '/(#c|d)/',
+                '"string"',
+            ]);
+        });
+
+        test('regexp with flags', () => {
+            const result = splitByPipeRespectingRegex('/pattern/gi|123');
+            expect(result).toStrictEqual([
+                '/pattern/gi',
+                '123',
+            ]);
+        });
+
+        test('regexp with escaped slash inside', () => {
+            const result = splitByPipeRespectingRegex('/foo\\/bar/|"test"');
+            expect(result).toStrictEqual([
+                '/foo\\/bar/',
+                '"test"',
+            ]);
+        });
+
+        test('Complex regex with multiple pipes and escaped slashes', () => {
+            const result = splitByPipeRespectingRegex('/(a\\/b|c\\/d)/|"value"');
+            expect(result).toStrictEqual([
+                '/(a\\/b|c\\/d)/',
+                '"value"',
+            ]);
+        });
+
+        test('No regex, only strings', () => {
+            const result = splitByPipeRespectingRegex('"string1"|"string2"|"string3"');
+            expect(result).toStrictEqual([
+                '"string1"',
+                '"string2"',
+                '"string3"',
+            ]);
+        });
+
+        test('Empty string', () => {
+            const result = splitByPipeRespectingRegex('');
+            expect(result).toStrictEqual(['']);
+        });
+
+        test('String with no pipes', () => {
+            const result = splitByPipeRespectingRegex('"single-value"');
+            expect(result).toStrictEqual(['"single-value"']);
+        });
+
+        test('regexp at the end', () => {
+            const result = splitByPipeRespectingRegex('"test"|/(a|b)/');
+            expect(result).toStrictEqual([
+                '"test"',
+                '/(a|b)/',
+            ]);
+        });
+
+        test('regexp with all supported flags', () => {
+            const result = splitByPipeRespectingRegex('/(test|value)/gimsu|"arg"');
+            expect(result).toStrictEqual([
+                '/(test|value)/gimsu',
+                '"arg"',
+            ]);
+        });
+
+        test('Object notation with pipes', () => {
+            const result = splitByPipeRespectingRegex('{"a":1}|{"b":2}');
+            expect(result).toStrictEqual([
+                '{"a":1}',
+                '{"b":2}',
+            ]);
+        });
+
+        test('Mixed types: regex, object, string', () => {
+            const result = splitByPipeRespectingRegex('/(a|b)/|{"key":"val"}|"string"');
+            expect(result).toStrictEqual([
+                '/(a|b)/',
+                '{"key":"val"}',
+                '"string"',
+            ]);
+        });
+
+        test('Pipe at start (empty first segment)', () => {
+            const result = splitByPipeRespectingRegex('|"test"');
+            expect(result).toStrictEqual([
+                '',
+                '"test"',
+            ]);
+        });
+
+        test('Pipe at end (empty last segment)', () => {
+            const result = splitByPipeRespectingRegex('"test"|');
+            expect(result).toStrictEqual([
+                '"test"',
+                '',
+            ]);
+        });
+
+        test('Consecutive pipes (empty segments)', () => {
+            const result = splitByPipeRespectingRegex('"a"||"b"');
+            expect(result).toStrictEqual([
+                '"a"',
+                '',
+                '"b"',
+            ]);
+        });
+
+        test('regexp with no closing slash (stays in regex mode)', () => {
+            const result = splitByPipeRespectingRegex('/incomplete|"test"');
+            expect(result).toStrictEqual([
+                '/incomplete|"test"',
+            ]);
+        });
+
+        test('Real-world example from localStorage.setItem', () => {
+            const result = splitByPipeRespectingRegex('/key/|"test-value"');
+            expect(result).toStrictEqual([
+                '/key/',
+                '"test-value"',
+            ]);
+        });
+    });
 });

tests/scriptlets/trusted-suppress-native-method.test.js

@@ -45,6 +45,8 @@ const afterEach = () => {
     window.testMatching = testMatching;
     Object.keys(natives).forEach(restoreNativeMethod);
     clearGlobalProps('hit', '__debug');
+    localStorage.clear();
+    sessionStorage.clear();
 };
 
 module(name, { beforeEach, afterEach });
@@ -328,3 +330,28 @@ test('Match: stack trace', (assert) => {
     const result3 = testFunc1();
     assert.strictEqual(result3, undefined, 'testFunc1 should return undefined when prevented');
 });
+
+test('Regexp with pipe as signatureStr', (assert) => {
+    let item = window.localStorage.getItem('key1');
+    assert.strictEqual(item, null, 'Item is not set');
+
+    runScriptlet(name, ['localStorage.setItem', '/(key1|key2)/|"value"', 'prevent']);
+
+    window.localStorage.setItem('key1', 'test-value-1');
+    item = window.localStorage.getItem('key1');
+    assert.strictEqual(item, null, 'Call with "key" regexp part was prevented');
+    assert.strictEqual(window.hit, 'FIRED', 'hit func executed');
+    clearGlobalProps('hit');
+
+    window.localStorage.setItem('key2', 'test-value-2');
+    item = window.localStorage.getItem('key2');
+    assert.strictEqual(item, null, 'Call with "key2" regexp part was prevented');
+    assert.strictEqual(window.hit, 'FIRED', 'hit func executed');
+    clearGlobalProps('hit');
+
+    window.localStorage.setItem('other3', 'test-value-3');
+    item = window.localStorage.getItem('other3');
+    assert.strictEqual(item, 'test-value-3', 'Call with "other3" regexp part was not prevented');
+    assert.strictEqual(window.hit, undefined, 'hit should not fire');
+    clearGlobalProps('hit');
+});