Add pluggable abstraction for applying custom sanitization rules

Closes gh-27840

Author: mbhave

spring-boot-project/spring-boot-actuator-autoconfigure/src/main/java/org/springframework/boot/actuate/autoconfigure/context/properties/ConfigurationPropertiesReportEndpointAutoConfiguration.java

@@ -16,9 +16,11 @@
 
 package org.springframework.boot.actuate.autoconfigure.context.properties;
 
+import org.springframework.beans.factory.ObjectProvider;
 import org.springframework.boot.actuate.autoconfigure.endpoint.condition.ConditionalOnAvailableEndpoint;
 import org.springframework.boot.actuate.context.properties.ConfigurationPropertiesReportEndpoint;
 import org.springframework.boot.actuate.context.properties.ConfigurationPropertiesReportEndpointWebExtension;
+import org.springframework.boot.actuate.endpoint.SanitizingFunction;
 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
@@ -43,8 +45,9 @@ public class ConfigurationPropertiesReportEndpointAutoConfiguration {
 	@Bean
 	@ConditionalOnMissingBean
 	public ConfigurationPropertiesReportEndpoint configurationPropertiesReportEndpoint(
-			ConfigurationPropertiesReportEndpointProperties properties) {
-		ConfigurationPropertiesReportEndpoint endpoint = new ConfigurationPropertiesReportEndpoint();
+			ConfigurationPropertiesReportEndpointProperties properties,
+			ObjectProvider<SanitizingFunction> sanitizingFunctions) {
+		ConfigurationPropertiesReportEndpoint endpoint = new ConfigurationPropertiesReportEndpoint(sanitizingFunctions);
 		String[] keysToSanitize = properties.getKeysToSanitize();
 		if (keysToSanitize != null) {
 			endpoint.setKeysToSanitize(keysToSanitize);

spring-boot-project/spring-boot-actuator-autoconfigure/src/main/java/org/springframework/boot/actuate/autoconfigure/env/EnvironmentEndpointAutoConfiguration.java

@@ -16,7 +16,9 @@
 
 package org.springframework.boot.actuate.autoconfigure.env;
 
+import org.springframework.beans.factory.ObjectProvider;
 import org.springframework.boot.actuate.autoconfigure.endpoint.condition.ConditionalOnAvailableEndpoint;
+import org.springframework.boot.actuate.endpoint.SanitizingFunction;
 import org.springframework.boot.actuate.env.EnvironmentEndpoint;
 import org.springframework.boot.actuate.env.EnvironmentEndpointWebExtension;
 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
@@ -41,8 +43,9 @@ public class EnvironmentEndpointAutoConfiguration {
 
 	@Bean
 	@ConditionalOnMissingBean
-	public EnvironmentEndpoint environmentEndpoint(Environment environment, EnvironmentEndpointProperties properties) {
-		EnvironmentEndpoint endpoint = new EnvironmentEndpoint(environment);
+	public EnvironmentEndpoint environmentEndpoint(Environment environment, EnvironmentEndpointProperties properties,
+			ObjectProvider<SanitizingFunction> sanitizingFunctions) {
+		EnvironmentEndpoint endpoint = new EnvironmentEndpoint(environment, sanitizingFunctions);
 		String[] keysToSanitize = properties.getKeysToSanitize();
 		if (keysToSanitize != null) {
 			endpoint.setKeysToSanitize(keysToSanitize);

spring-boot-project/spring-boot-actuator-autoconfigure/src/test/java/org/springframework/boot/actuate/autoconfigure/context/properties/ConfigurationPropertiesReportEndpointAutoConfigurationTests.java

@@ -22,6 +22,7 @@
 
 import org.springframework.boot.actuate.context.properties.ConfigurationPropertiesReportEndpoint;
 import org.springframework.boot.actuate.context.properties.ConfigurationPropertiesReportEndpoint.ApplicationConfigurationProperties;
+import org.springframework.boot.actuate.endpoint.SanitizingFunction;
 import org.springframework.boot.autoconfigure.AutoConfigurations;
 import org.springframework.boot.context.properties.ConfigurationProperties;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
@@ -72,6 +73,14 @@ void additionalKeysToSanitizeCanBeConfiguredViaTheEnvironment() {
 				.run(validateTestProperties("******", "******"));
 	}
 
+	@Test
+	void customSanitizingFunctionShouldBeApplied() {
+		this.contextRunner.withUserConfiguration(Config.class, SanitizingFunctionConfiguration.class)
+				.withPropertyValues("management.endpoints.web.exposure.include=configprops",
+						"test.my-test-property=abc")
+				.run(validateTestProperties("******", "$$$"));
+	}
+
 	@Test
 	void runWhenNotExposedShouldNotHaveEndpointBean() {
 		this.contextRunner
@@ -129,4 +138,19 @@ public void setMyTestProperty(String myTestProperty) {
 
 	}
 
+	@Configuration(proxyBeanMethods = false)
+	static class SanitizingFunctionConfiguration {
+
+		@Bean
+		SanitizingFunction testSanitizingFunction() {
+			return (data) -> {
+				if (data.getKey().contains("my")) {
+					return data.withValue("$$$");
+				}
+				return data;
+			};
+		}
+
+	}
+
 }

spring-boot-project/spring-boot-actuator-autoconfigure/src/test/java/org/springframework/boot/actuate/autoconfigure/env/EnvironmentEndpointAutoConfigurationTests.java

@@ -20,6 +20,7 @@
 
 import org.junit.jupiter.api.Test;
 
+import org.springframework.boot.actuate.endpoint.SanitizingFunction;
 import org.springframework.boot.actuate.env.EnvironmentEndpoint;
 import org.springframework.boot.actuate.env.EnvironmentEndpoint.EnvironmentDescriptor;
 import org.springframework.boot.actuate.env.EnvironmentEndpoint.PropertySourceDescriptor;
@@ -28,6 +29,8 @@
 import org.springframework.boot.test.context.assertj.AssertableApplicationContext;
 import org.springframework.boot.test.context.runner.ApplicationContextRunner;
 import org.springframework.boot.test.context.runner.ContextConsumer;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -67,6 +70,21 @@ void keysToSanitizeCanBeConfiguredViaTheEnvironment() {
 				.run(validateSystemProperties("******", "123456"));
 	}
 
+	@Test
+	void sanitizingFunctionsCanBeConfiguredViaTheEnvironment() {
+		this.contextRunner.withUserConfiguration(SanitizingFunctionConfiguration.class)
+				.withPropertyValues("management.endpoints.web.exposure.include=env")
+				.withSystemProperties("custom=123456", "password=123456").run((context) -> {
+					assertThat(context).hasSingleBean(EnvironmentEndpoint.class);
+					EnvironmentEndpoint endpoint = context.getBean(EnvironmentEndpoint.class);
+					EnvironmentDescriptor env = endpoint.environment(null);
+					Map<String, PropertyValueDescriptor> systemProperties = getSource("systemProperties", env)
+							.getProperties();
+					assertThat(systemProperties.get("custom").getValue()).isEqualTo("$$$");
+					assertThat(systemProperties.get("password").getValue()).isEqualTo("******");
+				});
+	}
+
 	@Test
 	void additionalKeysToSanitizeCanBeConfiguredViaTheEnvironment() {
 		this.contextRunner.withPropertyValues("management.endpoints.web.exposure.include=env")
@@ -91,4 +109,14 @@ private PropertySourceDescriptor getSource(String name, EnvironmentDescriptor de
 				.get();
 	}
 
+	@Configuration(proxyBeanMethods = false)
+	static class SanitizingFunctionConfiguration {
+
+		@Bean
+		SanitizingFunction testSanitizingFunction() {
+			return (data) -> data.withValue("$$$");
+		}
+
+	}
+
 }

spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/context/properties/ConfigurationPropertiesReportEndpoint.java

@@ -53,7 +53,9 @@
 
 import org.springframework.beans.BeanUtils;
 import org.springframework.beans.BeansException;
+import org.springframework.boot.actuate.endpoint.SanitizableData;
 import org.springframework.boot.actuate.endpoint.Sanitizer;
+import org.springframework.boot.actuate.endpoint.SanitizingFunction;
 import org.springframework.boot.actuate.endpoint.annotation.Endpoint;
 import org.springframework.boot.actuate.endpoint.annotation.ReadOperation;
 import org.springframework.boot.actuate.endpoint.annotation.Selector;
@@ -64,6 +66,7 @@
 import org.springframework.boot.context.properties.bind.Name;
 import org.springframework.boot.context.properties.source.ConfigurationProperty;
 import org.springframework.boot.context.properties.source.ConfigurationPropertyName;
+import org.springframework.boot.context.properties.source.ConfigurationPropertySource;
 import org.springframework.boot.origin.Origin;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.ApplicationContextAware;
@@ -73,6 +76,7 @@
 import org.springframework.core.annotation.MergedAnnotation;
 import org.springframework.core.annotation.MergedAnnotations;
 import org.springframework.core.annotation.MergedAnnotations.SearchStrategy;
+import org.springframework.core.env.PropertySource;
 import org.springframework.util.ClassUtils;
 import org.springframework.util.StringUtils;
 
@@ -100,12 +104,20 @@ public class ConfigurationPropertiesReportEndpoint implements ApplicationContext
 
 	private static final String CONFIGURATION_PROPERTIES_FILTER_ID = "configurationPropertiesFilter";
 
-	private final Sanitizer sanitizer = new Sanitizer();
+	private final Sanitizer sanitizer;
 
 	private ApplicationContext context;
 
 	private ObjectMapper objectMapper;
 
+	public ConfigurationPropertiesReportEndpoint() {
+		this(Collections.emptyList());
+	}
+
+	public ConfigurationPropertiesReportEndpoint(Iterable<SanitizingFunction> sanitizingFunctions) {
+		this.sanitizer = new Sanitizer(sanitizingFunctions);
+	}
+
 	@Override
 	public void setApplicationContext(ApplicationContext context) throws BeansException {
 		this.context = context;
@@ -236,26 +248,63 @@ else if (value instanceof List) {
 				map.put(key, sanitize(qualifiedKey, (List<Object>) value));
 			}
 			else {
-				value = this.sanitizer.sanitize(key, value);
-				value = this.sanitizer.sanitize(qualifiedKey, value);
-				map.put(key, value);
+				map.put(key, sanitizeWithPropertySourceIfPresent(qualifiedKey, value));
 			}
 		});
 		return map;
 	}
 
+	private Object sanitizeWithPropertySourceIfPresent(String qualifiedKey, Object value) {
+		ConfigurationPropertyName currentName = getCurrentName(qualifiedKey);
+		ConfigurationProperty candidate = getCandidate(currentName);
+		PropertySource<?> propertySource = getPropertySource(candidate);
+		if (propertySource != null) {
+			SanitizableData data = new SanitizableData(propertySource, qualifiedKey, value);
+			return this.sanitizer.sanitize(data);
+		}
+		SanitizableData data = new SanitizableData(null, qualifiedKey, value);
+		return this.sanitizer.sanitize(data);
+	}
+
+	private PropertySource<?> getPropertySource(ConfigurationProperty configurationProperty) {
+		if (configurationProperty == null) {
+			return null;
+		}
+		ConfigurationPropertySource source = configurationProperty.getSource();
+		Object underlyingSource = (source != null) ? source.getUnderlyingSource() : null;
+		return (underlyingSource instanceof PropertySource<?>) ? (PropertySource<?>) underlyingSource : null;
+	}
+
+	private ConfigurationPropertyName getCurrentName(String qualifiedKey) {
+		return ConfigurationPropertyName.adapt(qualifiedKey, '.');
+	}
+
+	private ConfigurationProperty getCandidate(ConfigurationPropertyName currentName) {
+		BoundConfigurationProperties bound = BoundConfigurationProperties.get(this.context);
+		if (bound == null) {
+			return null;
+		}
+		ConfigurationProperty candidate = bound.get(currentName);
+		if (candidate == null && currentName.isLastElementIndexed()) {
+			candidate = bound.get(currentName.chop(currentName.getNumberOfElements() - 1));
+		}
+		return candidate;
+	}
+
 	@SuppressWarnings("unchecked")
 	private List<Object> sanitize(String prefix, List<Object> list) {
 		List<Object> sanitized = new ArrayList<>();
+		int index = 0;
 		for (Object item : list) {
+			String name = prefix + "[" + index++ + "]";
 			if (item instanceof Map) {
-				sanitized.add(sanitize(prefix, (Map<String, Object>) item));
+				sanitized.add(sanitize(name, (Map<String, Object>) item));
 			}
 			else if (item instanceof List) {
-				sanitized.add(sanitize(prefix, (List<Object>) item));
+				sanitized.add(sanitize(name, (List<Object>) item));
 			}
 			else {
-				sanitized.add(this.sanitizer.sanitize(prefix, item));
+				sanitized.add(sanitizeWithPropertySourceIfPresent(name, item));
 			}
 		}
 		return sanitized;
@@ -299,24 +348,22 @@ else if (item instanceof List) {
 	}
 
 	private Map<String, Object> applyInput(String qualifiedKey) {
-		BoundConfigurationProperties bound = BoundConfigurationProperties.get(this.context);
-		if (bound == null) {
-			return Collections.emptyMap();
-		}
-		ConfigurationPropertyName currentName = ConfigurationPropertyName.adapt(qualifiedKey, '.');
-		ConfigurationProperty candidate = bound.get(currentName);
-		if (candidate == null && currentName.isLastElementIndexed()) {
-			candidate = bound.get(currentName.chop(currentName.getNumberOfElements() - 1));
-		}
-		return (candidate != null) ? getInput(currentName.toString(), candidate) : Collections.emptyMap();
+		ConfigurationPropertyName currentName = getCurrentName(qualifiedKey);
+		ConfigurationProperty candidate = getCandidate(currentName);
+		PropertySource<?> propertySource = getPropertySource(candidate);
+		if (propertySource != null) {
+			Object value = stringifyIfNecessary(candidate.getValue());
+			SanitizableData data = new SanitizableData(propertySource, currentName.toString(), value);
+			return getInput(candidate, this.sanitizer.sanitize(data));
+		}
+		return Collections.emptyMap();
 	}
 
-	private Map<String, Object> getInput(String property, ConfigurationProperty candidate) {
+	private Map<String, Object> getInput(ConfigurationProperty candidate, Object sanitizedValue) {
 		Map<String, Object> input = new LinkedHashMap<>();
-		Object value = stringifyIfNecessary(candidate.getValue());
 		Origin origin = Origin.from(candidate);
 		List<Origin> originParents = Origin.parentsFrom(candidate);
-		input.put("value", this.sanitizer.sanitize(property, value));
+		input.put("value", sanitizedValue);
 		input.put("origin", (origin != null) ? origin.toString() : "none");
 		if (!originParents.isEmpty()) {
 			input.put("originParents", originParents.stream().map(Object::toString).toArray(String[]::new));

spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/endpoint/SanitizableData.java

@@ -0,0 +1,86 @@
+/*
+ * Copyright 2012-2021 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.actuate.endpoint;
+
+import org.springframework.core.env.PropertySource;
+
+/**
+ * Value object that represents the data that can be used by a {@link SanitizingFunction}.
+ *
+ * @author Madhura Bhave
+ * @since 2.6.0
+ **/
+public final class SanitizableData {
+
+	/**
+	 * Represents a sanitized value.
+	 */
+	public static final String SANITIZED_VALUE = "******";
+
+	private final PropertySource<?> propertySource;
+
+	private final String key;
+
+	private final Object value;
+
+	/**
+	 * Create a new {@link SanitizableData} instance.
+	 * @param propertySource the property source that provided the data or {@code null}.
+	 * @param key the data key
+	 * @param value the data value
+	 */
+	public SanitizableData(PropertySource<?> propertySource, String key, Object value) {
+		this.propertySource = propertySource;
+		this.key = key;
+		this.value = value;
+	}
+
+	/**
+	 * Return the property source that provided the data or {@code null} If the data was
+	 * not from a {@link PropertySource}.
+	 * @return the property source that provided the data
+	 */
+	public PropertySource<?> getPropertySource() {
+		return this.propertySource;
+	}
+
+	/**
+	 * Return the key of the data.
+	 * @return the data key
+	 */
+	public String getKey() {
+		return this.key;
+	}
+
+	/**
+	 * Return the value of the data.
+	 * @return the data value
+	 */
+	public Object getValue() {
+		return this.value;
+	}
+
+	/**
+	 * Return a new {@link SanitizableData} instance with a different value.
+	 * @param value the new value (often {@link #SANITIZED_VALUE}
+	 * @return a new sanitizable data instance
+	 */
+	public SanitizableData withValue(Object value) {
+		return new SanitizableData(this.propertySource, this.key, value);
+	}
+
+}