From 42cc2176d27e6151f685bc3783fbc6edce781c6b Mon Sep 17 00:00:00 2001 From: Adam Brown Date: Fri, 20 Nov 2026 12:10:39 +0100 Subject: [PATCH 1/3] perf(core): Avoid repeated sensitive denylist normalization Match built-in sensitive terms in their existing lowercase form and normalize only the input key. Reuse this path for query parameters and headers while preserving case-insensitive matching for caller-configured terms. Cover mixed-case matching, sensitive allowlist precedence, empty terms, and locale independence. Co-Authored-By: Codex --- .../main/java/io/sentry/util/HttpUtils.java | 13 +++- .../test/java/io/sentry/util/HttpUtilsTest.kt | 69 ++++++++++++++++--- 2 files changed, 69 insertions(+), 13 deletions(-) diff --git a/sentry/src/main/java/io/sentry/util/HttpUtils.java b/sentry/src/main/java/io/sentry/util/HttpUtils.java index 73da7808056..544cb18094e 100644 --- a/sentry/src/main/java/io/sentry/util/HttpUtils.java +++ b/sentry/src/main/java/io/sentry/util/HttpUtils.java @@ -33,6 +33,7 @@ public final class HttpUtils { "X-CSRFTOKEN", "X-XSRF-TOKEN"); + // Keep these terms lowercase so sensitive-key checks only normalize the input key. private static final List SENSITIVE_DATA_KEYS = Arrays.asList( "auth", @@ -80,7 +81,7 @@ public static boolean containsSensitiveHeader(final @NotNull String header) { final int separator = param.indexOf('='); final @NotNull String name = separator < 0 ? param : param.substring(0, separator); final @NotNull String decodedName = decodeQueryParamName(name); - final boolean sensitive = containsTerm(decodedName, SENSITIVE_DATA_KEYS); + final boolean sensitive = containsSensitiveDataKey(decodedName); final boolean matchesTerm = containsTerm(decodedName, behavior.getTerms()); final boolean shouldFilter = sensitive @@ -108,7 +109,7 @@ public static boolean containsSensitiveHeader(final @NotNull String header) { for (final Map.Entry header : headers.entrySet()) { final @NotNull String name = header.getKey(); final boolean sensitive = - containsTerm(name, SENSITIVE_DATA_KEYS) + containsSensitiveDataKey(name) || "Cookie".equalsIgnoreCase(name) || "Set-Cookie".equalsIgnoreCase(name); if (sensitive) { @@ -136,7 +137,13 @@ public static boolean containsSensitiveHeader(final @NotNull String header) { } static boolean containsSensitiveDataKey(final @NotNull String key) { - return containsTerm(key, SENSITIVE_DATA_KEYS); + final @NotNull String normalizedKey = key.toLowerCase(Locale.ROOT); + for (final String term : SENSITIVE_DATA_KEYS) { + if (normalizedKey.contains(term)) { + return true; + } + } + return false; } static boolean containsTerm(final @NotNull String key, final @NotNull List terms) { diff --git a/sentry/src/test/java/io/sentry/util/HttpUtilsTest.kt b/sentry/src/test/java/io/sentry/util/HttpUtilsTest.kt index c0791642b5c..88ee3d30d69 100644 --- a/sentry/src/test/java/io/sentry/util/HttpUtilsTest.kt +++ b/sentry/src/test/java/io/sentry/util/HttpUtilsTest.kt @@ -2,6 +2,7 @@ package io.sentry.util import com.google.common.truth.Truth.assertThat import io.sentry.KeyValueCollectionBehavior +import java.util.Locale import kotlin.test.Test class HttpUtilsTest { @@ -14,11 +15,11 @@ class HttpUtilsTest { fun `query parameter deny list filters built-in sensitive and configured terms`() { assertThat( HttpUtils.filterQueryParams( - "name=value&access_token=secret&customerId=123", - KeyValueCollectionBehavior.denyList("customer"), + "name=value&ACCESS_TOKEN=secret&customerId=123", + KeyValueCollectionBehavior.denyList("CuStOmEr"), ), ) - .isEqualTo("name=value&access_token=[Filtered]&customerId=[Filtered]") + .isEqualTo("name=value&ACCESS_TOKEN=[Filtered]&customerId=[Filtered]") } @Test @@ -26,7 +27,7 @@ class HttpUtilsTest { assertThat( HttpUtils.filterQueryParams( "name=value&access_token=secret&customerId=123", - KeyValueCollectionBehavior.allowList("name", "access_token"), + KeyValueCollectionBehavior.allowList("NaMe", "AcCeSs_ToKeN"), ), ) .isEqualTo("name=value&access_token=[Filtered]&customerId=[Filtered]") @@ -71,18 +72,18 @@ class HttpUtilsTest { HttpUtils.filterHeaders( mapOf( "content-type" to "application/json", - "authorization" to "Bearer token", + "AUTHORIZATION" to "Bearer token", "x-customer" to "customer value", "Cookie" to "name=value", ), - KeyValueCollectionBehavior.denyList("customer"), + KeyValueCollectionBehavior.denyList("CuStOmEr"), ) assertThat(filtered) .containsExactly( "content-type", "application/json", - "authorization", + "AUTHORIZATION", "[Filtered]", "x-customer", "[Filtered]", @@ -97,20 +98,68 @@ class HttpUtilsTest { HttpUtils.filterHeaders( mapOf( "content-type" to "application/json", - "authorization" to "Bearer token", + "AUTHORIZATION" to "Bearer token", "x-customer" to "customer value", ), - KeyValueCollectionBehavior.allowList("content", "authorization"), + KeyValueCollectionBehavior.allowList("CoNtEnT", "AuThOrIzAtIoN"), ) assertThat(filtered) .containsExactly( "content-type", "application/json", - "authorization", + "AUTHORIZATION", "[Filtered]", "x-customer", "[Filtered]", ) } + + @Test + fun `containsSensitiveDataKey() - rejects an empty key`() { + assertThat(HttpUtils.containsSensitiveDataKey("")).isFalse() + } + + @Test + fun `containsSensitiveDataKey() - matches independently of the default locale`() { + val originalLocale = Locale.getDefault() + try { + Locale.setDefault(Locale("tr", "TR")) + + assertThat(HttpUtils.containsSensitiveDataKey("SESSION")).isTrue() + assertThat(HttpUtils.containsSensitiveDataKey("IDENTITY")).isTrue() + } finally { + Locale.setDefault(originalLocale) + } + } + + @Test + fun `containsTerm() - matches substrings regardless of key and term case`() { + assertThat(HttpUtils.containsTerm("X-CUSTOMER-ID", listOf("CuStOmEr"))).isTrue() + assertThat(HttpUtils.containsTerm("X-CUSTOMER-ID", listOf("account"))).isFalse() + } + + @Test + fun `containsTerm() - ignores null and empty terms`() { + assertThat(HttpUtils.containsTerm("customerId", listOf(null, "", "CuStOmEr"))).isTrue() + assertThat(HttpUtils.containsTerm("customerId", listOf(null, ""))).isFalse() + } + + @Test + fun `containsTerm() - matches no keys when no terms are configured`() { + assertThat(HttpUtils.containsTerm("customerId", emptyList())).isFalse() + } + + @Test + fun `containsTerm() - matches independently of the default locale`() { + val originalLocale = Locale.getDefault() + try { + Locale.setDefault(Locale("tr", "TR")) + + assertThat(HttpUtils.containsTerm("DISPLAY", listOf("display"))).isTrue() + assertThat(HttpUtils.containsTerm("display", listOf("DISPLAY"))).isTrue() + } finally { + Locale.setDefault(originalLocale) + } + } } From 5c39282c8b74e7a8bbd95f4e68c16fa7de47843a Mon Sep 17 00:00:00 2001 From: Adam Brown Date: Fri, 20 Nov 2026 12:40:57 +0100 Subject: [PATCH 2/3] test(core): Separate mixed-case HTTP filtering coverage Preserve the original filtering examples and add dedicated casing tests for query parameters and headers in allowlist and denylist modes. Co-Authored-By: Codex --- .../test/java/io/sentry/util/HttpUtilsTest.kt | 73 ++++++++++++++++++- 1 file changed, 72 insertions(+), 1 deletion(-) diff --git a/sentry/src/test/java/io/sentry/util/HttpUtilsTest.kt b/sentry/src/test/java/io/sentry/util/HttpUtilsTest.kt index 88ee3d30d69..26801c9db58 100644 --- a/sentry/src/test/java/io/sentry/util/HttpUtilsTest.kt +++ b/sentry/src/test/java/io/sentry/util/HttpUtilsTest.kt @@ -13,6 +13,17 @@ class HttpUtilsTest { @Test fun `query parameter deny list filters built-in sensitive and configured terms`() { + assertThat( + HttpUtils.filterQueryParams( + "name=value&access_token=secret&customerId=123", + KeyValueCollectionBehavior.denyList("customer"), + ), + ) + .isEqualTo("name=value&access_token=[Filtered]&customerId=[Filtered]") + } + + @Test + fun `filterQueryParams() - deny list matches sensitive names and configured terms regardless of case`() { assertThat( HttpUtils.filterQueryParams( "name=value&ACCESS_TOKEN=secret&customerId=123", @@ -27,12 +38,23 @@ class HttpUtilsTest { assertThat( HttpUtils.filterQueryParams( "name=value&access_token=secret&customerId=123", - KeyValueCollectionBehavior.allowList("NaMe", "AcCeSs_ToKeN"), + KeyValueCollectionBehavior.allowList("name", "access_token"), ), ) .isEqualTo("name=value&access_token=[Filtered]&customerId=[Filtered]") } + @Test + fun `filterQueryParams() - allow list matches mixed-case terms but still filters sensitive names`() { + assertThat( + HttpUtils.filterQueryParams( + "name=value&AcCeSs_ToKeN=secret&customerId=123", + KeyValueCollectionBehavior.allowList("NaMe", "AcCeSs_ToKeN"), + ), + ) + .isEqualTo("name=value&AcCeSs_ToKeN=[Filtered]&customerId=[Filtered]") + } + @Test fun `query parameter filter matches decoded names and preserves encoding`() { assertThat( @@ -68,6 +90,32 @@ class HttpUtilsTest { @Test fun `header deny list filters built-in sensitive and configured terms`() { + val filtered = + HttpUtils.filterHeaders( + mapOf( + "content-type" to "application/json", + "authorization" to "Bearer token", + "x-customer" to "customer value", + "Cookie" to "name=value", + ), + KeyValueCollectionBehavior.denyList("customer"), + ) + + assertThat(filtered) + .containsExactly( + "content-type", + "application/json", + "authorization", + "[Filtered]", + "x-customer", + "[Filtered]", + "Cookie", + "[Filtered]", + ) + } + + @Test + fun `filterHeaders() - deny list matches sensitive names and configured terms regardless of case`() { val filtered = HttpUtils.filterHeaders( mapOf( @@ -94,6 +142,29 @@ class HttpUtilsTest { @Test fun `header allow list only retains allowed non-sensitive values`() { + val filtered = + HttpUtils.filterHeaders( + mapOf( + "content-type" to "application/json", + "authorization" to "Bearer token", + "x-customer" to "customer value", + ), + KeyValueCollectionBehavior.allowList("content", "authorization"), + ) + + assertThat(filtered) + .containsExactly( + "content-type", + "application/json", + "authorization", + "[Filtered]", + "x-customer", + "[Filtered]", + ) + } + + @Test + fun `filterHeaders() - allow list matches mixed-case terms but still filters sensitive names`() { val filtered = HttpUtils.filterHeaders( mapOf( From 3f4c49a523fcf83ad04383b54f4dcec56dc44e25 Mon Sep 17 00:00:00 2001 From: Adam Brown Date: Fri, 20 Nov 2026 12:50:13 +0100 Subject: [PATCH 3/3] test(core): Match existing HTTP utility test naming Describe the added cases using the behavior-based naming already used in HttpUtilsTest. Co-Authored-By: Codex --- .../test/java/io/sentry/util/HttpUtilsTest.kt | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/sentry/src/test/java/io/sentry/util/HttpUtilsTest.kt b/sentry/src/test/java/io/sentry/util/HttpUtilsTest.kt index 26801c9db58..ff52464cb2d 100644 --- a/sentry/src/test/java/io/sentry/util/HttpUtilsTest.kt +++ b/sentry/src/test/java/io/sentry/util/HttpUtilsTest.kt @@ -23,7 +23,7 @@ class HttpUtilsTest { } @Test - fun `filterQueryParams() - deny list matches sensitive names and configured terms regardless of case`() { + fun `query parameter deny list matches sensitive names and configured terms regardless of case`() { assertThat( HttpUtils.filterQueryParams( "name=value&ACCESS_TOKEN=secret&customerId=123", @@ -45,7 +45,7 @@ class HttpUtilsTest { } @Test - fun `filterQueryParams() - allow list matches mixed-case terms but still filters sensitive names`() { + fun `query parameter allow list matches mixed-case terms but still filters sensitive names`() { assertThat( HttpUtils.filterQueryParams( "name=value&AcCeSs_ToKeN=secret&customerId=123", @@ -115,7 +115,7 @@ class HttpUtilsTest { } @Test - fun `filterHeaders() - deny list matches sensitive names and configured terms regardless of case`() { + fun `header deny list matches sensitive names and configured terms regardless of case`() { val filtered = HttpUtils.filterHeaders( mapOf( @@ -164,7 +164,7 @@ class HttpUtilsTest { } @Test - fun `filterHeaders() - allow list matches mixed-case terms but still filters sensitive names`() { + fun `header allow list matches mixed-case terms but still filters sensitive names`() { val filtered = HttpUtils.filterHeaders( mapOf( @@ -187,12 +187,12 @@ class HttpUtilsTest { } @Test - fun `containsSensitiveDataKey() - rejects an empty key`() { + fun `sensitive data key check rejects an empty key`() { assertThat(HttpUtils.containsSensitiveDataKey("")).isFalse() } @Test - fun `containsSensitiveDataKey() - matches independently of the default locale`() { + fun `sensitive data key check matches independently of the default locale`() { val originalLocale = Locale.getDefault() try { Locale.setDefault(Locale("tr", "TR")) @@ -205,24 +205,24 @@ class HttpUtilsTest { } @Test - fun `containsTerm() - matches substrings regardless of key and term case`() { + fun `configured term check matches substrings regardless of key and term case`() { assertThat(HttpUtils.containsTerm("X-CUSTOMER-ID", listOf("CuStOmEr"))).isTrue() assertThat(HttpUtils.containsTerm("X-CUSTOMER-ID", listOf("account"))).isFalse() } @Test - fun `containsTerm() - ignores null and empty terms`() { + fun `configured term check ignores null and empty terms`() { assertThat(HttpUtils.containsTerm("customerId", listOf(null, "", "CuStOmEr"))).isTrue() assertThat(HttpUtils.containsTerm("customerId", listOf(null, ""))).isFalse() } @Test - fun `containsTerm() - matches no keys when no terms are configured`() { + fun `configured term check matches no keys when no terms are configured`() { assertThat(HttpUtils.containsTerm("customerId", emptyList())).isFalse() } @Test - fun `containsTerm() - matches independently of the default locale`() { + fun `configured term check matches independently of the default locale`() { val originalLocale = Locale.getDefault() try { Locale.setDefault(Locale("tr", "TR"))