diff --git a/sentry/src/main/java/io/sentry/util/HttpUtils.java b/sentry/src/main/java/io/sentry/util/HttpUtils.java index 73da780805..544cb18094 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 c0791642b5..ff52464cb2 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 { @@ -21,6 +22,17 @@ class HttpUtilsTest { .isEqualTo("name=value&access_token=[Filtered]&customerId=[Filtered]") } + @Test + fun `query parameter deny list matches sensitive names and configured terms regardless of case`() { + assertThat( + HttpUtils.filterQueryParams( + "name=value&ACCESS_TOKEN=secret&customerId=123", + KeyValueCollectionBehavior.denyList("CuStOmEr"), + ), + ) + .isEqualTo("name=value&ACCESS_TOKEN=[Filtered]&customerId=[Filtered]") + } + @Test fun `query parameter allow list only retains allowed non-sensitive values`() { assertThat( @@ -32,6 +44,17 @@ class HttpUtilsTest { .isEqualTo("name=value&access_token=[Filtered]&customerId=[Filtered]") } + @Test + fun `query parameter 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( @@ -91,6 +114,32 @@ class HttpUtilsTest { ) } + @Test + fun `header deny list matches sensitive names and configured terms regardless of case`() { + 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 `header allow list only retains allowed non-sensitive values`() { val filtered = @@ -113,4 +162,75 @@ class HttpUtilsTest { "[Filtered]", ) } + + @Test + fun `header allow list matches mixed-case terms but still filters sensitive names`() { + 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 `sensitive data key check rejects an empty key`() { + assertThat(HttpUtils.containsSensitiveDataKey("")).isFalse() + } + + @Test + fun `sensitive data key check 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 `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 `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 `configured term check matches no keys when no terms are configured`() { + assertThat(HttpUtils.containsTerm("customerId", emptyList())).isFalse() + } + + @Test + fun `configured term check 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) + } + } }