fix(secrets)!: 로컬 비밀 기본값을 __LOCAL_DEV_ 규칙에 맞추고 가림 약속을 구현과 맞춘다

로컬 비밀 기본값(compose·lane·application-local의 DB 비밀번호, MinIO
root, Keycloak admin)이 __LOCAL_DEV_ 접두어 규칙을 따르지 않아 prod
sentinel 검사가 그 값을 알아보지 못한다. secrets-classification.yaml은
구현 없는 masking_rule full_except_last_4를 약속하고, full로 적은 키 일부
(salt·PEM·HMAC/signing key, URI 사용자 정보)를 LogMaskingPatterns가 가리지
않는다. required_test는 없는 시험 이름이다. IP 신뢰 설정을 두 문서가
다르게 적는다(application-local은 framework, rate-limiting은 native).

- 기본값을 __LOCAL_DEV_db_password__·__LOCAL_DEV_minio_root__·
  __LOCAL_DEV_keycloak_admin__로 바꾼다.
- masking_rule을 full|userinfo|none 셋으로 줄이고, LogMaskingPatterns의
  키 목록을 넓히고 URI userinfo와 여러 줄 PEM 블록 가림을 더한다. 시험이 masking_rule 어휘,
  required_test 클래스 존재, full·userinfo 행이 실제로 가려지는지 본다.
  버린 안: full_except_last_4 구현(끝 네 자리를 남길 값이 없다).
- IP 신뢰는 native + 내부 proxy 목록 하나로 적는다.

위험: 로컬 compose 볼륨이 옛 비밀번호로 만들어졌으면 DB 접속이 실패한다
(docs/upgrade/2026-11-round9-observability.md 6행). 운영 값은 바뀌지
않는다.

검증: 위와 같은 desktop 실행(묶음 셋을 합친 트리) rc=0.

Refs: RR9-02-10, RR9-02-12, RR9-02-13
BREAKING CHANGE: 로컬 compose·lane의 비밀 기본값이 바뀐다. 옛 볼륨은
  지우거나 env로 옛 값을 준다(docs/upgrade/2026-11-round9-observability.md 6~7행).
This commit is contained in:
DongHyeonka
2026-11-13 13:12:09 +09:00
parent 75df7615e5
commit a7f44d8a8d
12 changed files with 246 additions and 92 deletions
+3
View File
@@ -323,6 +323,9 @@ relay 조립(`OutboxRelayAutoConfiguration`, 스케줄러·metrics·leader token
- **시크릿 값만 가리고 키/스킴은 남긴다.** `token=abc123` → `token=****`,
`Authorization: Bearer eyJ...` → `Authorization: Bearer ****`처럼 동작한다. 키와 인증 스킴(`Bearer`
등)을 남기는 이유는 진단할 때 "어떤 종류의 자격증명이 있었는지"는 알아야 하기 때문이다.
- **URI의 사용자 정보 비밀번호와 PEM 블록도 가린다.** `jdbc:postgresql://app:pw@db` → `jdbc:postgresql://app:****@db`
(사용자 이름은 남긴다, secrets registry의 `userinfo` 규칙). `-----BEGIN …-----`부터 `-----END …-----`까지(키·인증서)는
여러 줄이어도 본문 전체를 가리고 두 경계 줄만 남긴다. 같은 라벨의 END가 없으면 끝까지 가린다.
- **정규식 마스킹은 보증이 아니라 심층 방어(defence-in-depth)의 보조 수단이다.** 1차 방어선은
"로거가 애초에 본문/페이로드를 받지 않도록 설계한 것"(`FailOpenDependencyLogger`)이고, 이 정규식은
그걸 빠져나간 누출을 잡는 그물이다. 키 접두어 없는 Base64URL 블롭 같은 난독화된 형태는 놓칠 수
@@ -47,7 +47,7 @@ services:
environment:
PGHOST: "db"
PGUSER: "${APP_DATASOURCE_USERNAME:-ca_skeleton}"
PGPASSWORD: "${APP_DATASOURCE_PASSWORD:-ca_skeleton}"
PGPASSWORD: "${APP_DATASOURCE_PASSWORD:-__LOCAL_DEV_db_password__}"
PGDATABASE: "${POSTGRES_DB:-ca_skeleton}"
CAPABILITY_STREAMS: "${CAPABILITY_STREAMS:-}"
volumes:
@@ -82,7 +82,7 @@ services:
environment:
PGHOST: "db"
PGUSER: "${APP_DATASOURCE_USERNAME:-ca_skeleton}"
PGPASSWORD: "${APP_DATASOURCE_PASSWORD:-ca_skeleton}"
PGPASSWORD: "${APP_DATASOURCE_PASSWORD:-__LOCAL_DEV_db_password__}"
PGDATABASE: "${POSTGRES_DB:-ca_skeleton}"
CAPABILITY_STREAMS: "${CAPABILITY_STREAMS:-}"
volumes:
@@ -176,7 +176,7 @@ services:
environment:
MINIO_ENDPOINT: "http://minio:9000"
MINIO_ROOT_USER: "${MINIO_ROOT_USER:-caskeleton}"
MINIO_ROOT_PASSWORD: "${MINIO_ROOT_PASSWORD:-caskeleton-local}"
MINIO_ROOT_PASSWORD: "${MINIO_ROOT_PASSWORD:-__LOCAL_DEV_minio_root__}"
MINIO_BUCKET: "${MINIO_BUCKET:-ca-skeleton-objects}"
volumes:
- type: bind
@@ -7,7 +7,11 @@ import net.logstash.logback.mask.ValueMasker;
/**
* SSOT for secret-masking regex rules (shared by the JSON-encoder and pattern-layout paths). See
* README for the design rationale.
* README for the design rationale. The rules are the {@code masking_rule} values of {@code
* docs/registries/secrets-classification.yaml}: {@code full} (rules 0–3) and {@code userinfo} (rule
* 4). Rule 1 knows the secret names that registry uses — password, secret, token, api key, salt,
* PEM, and HMAC/signing/encryption/credential/private keys — so a {@code NAME=value} of any {@code
* full} row is masked; {@code SecretsClassificationRegistryTest} checks every such row.
*/
public final class LogMaskingPatterns {
@@ -22,11 +26,20 @@ public final class LogMaskingPatterns {
private static final List<Rule> RULES =
List.of(
// 0. A PEM block, multi-line included: rule 1 alone stops at the first space and would
// mask only "-----BEGIN". The armour lines stay so a line still says what it held.
// A block cut short (no END with its own label) is masked to the end of the text: what
// follows the armour is key material either way.
new Rule(
Pattern.compile(
"(-----BEGIN ([A-Z0-9 ]{1,40})-----)[\\s\\S]*?(-----END \\2-----|\\z)"),
"$1" + MASK + "$3"),
// 1. key=value / "key":"value" secrets — keep the key + separator, mask the value.
new Rule(
Pattern.compile(
"(?i)(password|passwd|pwd|secret|token|api[_-]?key|access[_-]?token"
+ "|refresh[_-]?token|client[_-]?secret)("
+ "|refresh[_-]?token|client[_-]?secret|salt|pem"
+ "|(?:hmac|signing|encryption|credential|private)[_-]?key)("
+ SEP
+ ")("
+ VALUE
@@ -38,7 +51,21 @@ public final class LogMaskingPatterns {
"(?i)(authorization" + SEP + ")((?:bearer|basic|negotiate)\\s+)?(" + VALUE + ")"),
"$1$2" + MASK),
// 3. Standalone bearer token not preceded by an "authorization" key.
new Rule(Pattern.compile("(?i)(bearer\\s+)([A-Za-z0-9._~+/=-]{8,})"), "$1" + MASK));
new Rule(Pattern.compile("(?i)(bearer\\s+)([A-Za-z0-9._~+/=-]{8,})"), "$1" + MASK),
// 4. The password in a URI's userinfo (jdbc:postgresql://app:pw@db, mongodb+srv://…),
// the secrets registry's "userinfo" rule. The user name stays, so a line still says
// which account connected (review 2026-11-12: the rule was declared, nothing did it).
new Rule(
// The password ends at the first '@' that a host[:port] and a delimiter follow, so a
// raw '@', '/', '#' or '?' in it is masked too, and an '@' later in a path or query
// is not taken for one. "user:8080/" is a port, not a password. The password is
// bounded and never crosses another "://", so a long line stays linear.
Pattern.compile(
"(?i)(?<![a-z0-9+.-])([a-z][a-z0-9+.-]*://[^:/@\\s\"']*:)"
+ "(?!\\d{1,5}(?:[/?#\\s]|$))"
+ "((?:(?!://)[^\\s\"]){1,256}?)(@)"
+ "(?=[a-z0-9.-]+(?::\\d+)?(?:[/?#,;\\s\"']|$))"),
"$1" + MASK + "$3"));
private LogMaskingPatterns() {}
@@ -52,7 +52,7 @@ spring:
# H2 is still available and now has to be asked for: `./gradlew :app-bootstrap:bootRunH2`.
url: ${APP_DATASOURCE_URL:jdbc:postgresql://localhost:5433/ca_skeleton}
username: ${APP_DATASOURCE_USERNAME:ca_skeleton}
password: ${APP_DATASOURCE_PASSWORD:ca_skeleton}
password: ${APP_DATASOURCE_PASSWORD:__LOCAL_DEV_db_password__}
driver-class-name: ${APP_DATASOURCE_DRIVER:org.postgresql.Driver}
hikari:
maximum-pool-size: 10
@@ -118,7 +118,9 @@ server:
port: ${APP_SERVER_PORT:8080}
shutdown: graceful
# No proxy in front of a local run, so trusting X-Forwarded-* would let a caller forge its own
# client IP. dev/prod sit behind a load balancer and set this to framework via env.
# client IP. dev/prod behind a load balancer set APP_SERVER_FORWARD_HEADERS_STRATEGY=native and
# list their proxies' IPs (a regex) in server.tomcat.remoteip.internal-proxies — never framework,
# which believes every peer (config/server.yml).
forward-headers-strategy: none
tomcat:
threads:
@@ -3,7 +3,9 @@ package dev.caskeleton.bootstrap.contract;
import static org.assertj.core.api.Assertions.assertThat;
import dev.caskeleton.bootstrap.contract.support.RepositoryContractResources;
import dev.caskeleton.bootstrap.logging.LogMaskingPatterns;
import dev.caskeleton.bootstrap.runtime.SecretSourceValidator;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
@@ -11,6 +13,7 @@ import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Stream;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Tag;
@@ -115,4 +118,66 @@ class SecretsClassificationRegistryTest {
.isIn(VALID_TIERS);
}
}
@Test
@DisplayName(
"masking_rule 은 LogMaskingPatterns 가 하는 셋(full·userinfo·none)뿐이다 — 구현 없는 규칙을 약속하지 않는다")
void everyMaskingRuleIsOneTheMaskingLayerImplements() {
// when
Set<Object> rules = new LinkedHashSet<>();
registryRows.forEach(row -> rules.add(row.get("masking_rule")));
// then
assertThat(rules).isSubsetOf("full", "userinfo", "none");
}
@Test
@DisplayName("required_test 는 app-bootstrap 시험 폴더에 있는 시험 클래스 이름이다")
void everyRequiredTestNamesATestClassThatExists() throws IOException {
// given
Path tests =
RepositoryContractResources.fromSystemProperty()
.requireTrackedDirectory("src/bootstrap/app/src/test/java");
Set<String> classNames = new LinkedHashSet<>();
try (Stream<Path> files = Files.walk(tests)) {
files
.map(path -> path.getFileName().toString())
.filter(name -> name.endsWith("Test.java"))
.forEach(name -> classNames.add(name.substring(0, name.length() - ".java".length())));
}
// when
Set<Object> named = new LinkedHashSet<>();
registryRows.stream()
.map(row -> row.get("required_test"))
.filter(java.util.Objects::nonNull)
.forEach(named::add);
// then
assertThat(classNames).containsAll(named.stream().map(String::valueOf).toList());
}
@Test
@DisplayName("masking_rule 이 full 인 행의 NAME=값 과 userinfo 행의 URI 비밀번호는 Layer 1 가림이 실제로 가린다")
void everyMaskingRuleIsHonouredByTheMaskingLayer() {
// given
String secret = "s3cr3t-Value-1234";
// when
List<String> leaked = new java.util.ArrayList<>();
for (Map<String, Object> row : registryRows) {
String name = String.valueOf(row.get("name"));
Object rule = row.get("masking_rule");
String line =
"full".equals(rule)
? name + "=" + secret
: "userinfo".equals(rule) ? "scheme://user:" + secret + "@host/db" : null;
if (line != null && LogMaskingPatterns.mask(line).contains(secret)) {
leaked.add(name);
}
}
// then
assertThat(leaked).isEmpty();
}
}
@@ -2,7 +2,11 @@ package dev.caskeleton.bootstrap.logging;
import static org.assertj.core.api.Assertions.assertThat;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
import org.junit.jupiter.params.provider.ValueSource;
/**
* Guards the Redaction Layer 1 secret catalog (feature-log-management-contract 테스트 계약:
@@ -76,4 +80,93 @@ class LogMaskingPatternsTest {
Object number = 42;
assertThat(LogMaskingPatterns.valueMasker().mask(null, number)).isSameAs(number);
}
@ParameterizedTest
@CsvSource(
delimiter = '|',
value = {
"connecting to jdbc:postgresql://app:hunter2@db:5432/ca | connecting to jdbc:postgresql://app:****@db:5432/ca",
"uri=mongodb+srv://reader:s3cr3t-pw@cluster0.example.net/app | uri=mongodb+srv://reader:****@cluster0.example.net/app",
"redis://default:pw@cache:6379 | redis://default:****@cache:6379",
"redis://:pw@cache:6379 | redis://:****@cache:6379",
"jdbc:postgresql://app:it's-a-secret@db/ca | jdbc:postgresql://app:****@db/ca",
"jdbc:postgresql://app:p@ss@db:5432/ca | jdbc:postgresql://app:****@db:5432/ca",
"redis://default:Ab/cd+ef@cache:6379 | redis://default:****@cache:6379",
"redis://default:P#ssw0rd@cache:6379 | redis://default:****@cache:6379",
"redis://default:pa?ss@cache:6379 | redis://default:****@cache:6379",
"redis://u:pw@h,redis://u2:pw2@h2 | redis://u:****@h,redis://u2:****@h2",
"mongodb://u:p@h1:27017,h2:27017/db | mongodb://u:****@h1:27017,h2:27017/db"
})
@DisplayName("URI 사용자 정보의 비밀번호를 가리고 사용자 이름은 남긴다(secrets registry 의 userinfo 규칙)")
void masksThePasswordInAUrisUserinfo(String line, String masked) {
assertThat(LogMaskingPatterns.mask(line)).isEqualTo(masked);
}
@Test
@DisplayName("PEM 블록은 여러 줄이어도 BEGIN·END 사이를 모두 가린다 — 첫 공백에서 멈추지 않는다")
void masksAWholePemBlockAcrossLines() {
// given
String line =
"trust_pem=-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASC\nSECRETBODY\n"
+ "-----END PRIVATE KEY----- loaded";
// when
String masked = LogMaskingPatterns.mask(line);
// then
assertThat(masked)
.doesNotContain("MIIEvQIBADANBgkqhkiG9w0BAQEFAASC", "SECRETBODY")
.contains("-----END PRIVATE KEY----- loaded");
}
@Test
@DisplayName("END 가 없는 PEM 블록은 BEGIN 줄만 남기고 끝까지 가린다")
void masksAPemBlockCutShortToTheEnd() {
// when
String masked =
LogMaskingPatterns.mask(
"key=-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASC\nSECRETBODY");
// then
assertThat(masked).isEqualTo("key=-----BEGIN PRIVATE KEY-----****");
}
@Test
@DisplayName("다른 라벨의 END 만 있는 PEM 블록도 BEGIN 줄만 남기고 끝까지 가린다")
void masksAPemBlockClosedUnderAnotherLabelToTheEnd() {
// when
String masked =
LogMaskingPatterns.mask(
"-----BEGIN RSA PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASC\n"
+ "-----END PRIVATE KEY-----\nSECRETBODY");
// then
assertThat(masked).isEqualTo("-----BEGIN RSA PRIVATE KEY-----****");
}
@Test
@DisplayName("공백 없는 긴 줄도 가림 규칙이 선형으로 끝난다 — 줄 길이의 제곱으로 느려지지 않는다")
void aLongLineWithoutSpacesIsMaskedInLinearTime() {
// given
String line = "a://:".repeat(32_000) + "http://h:1/".repeat(15_000) + "a".repeat(40_000);
// when
long started = System.nanoTime();
LogMaskingPatterns.mask(line);
long elapsedMillis = (System.nanoTime() - started) / 1_000_000;
// then
assertThat(elapsedMillis).as("masking a 365 KB line").isLessThan(1_000);
}
@ParameterizedTest
@ValueSource(
strings = {
"calling https://api.example.com:8443/v1/things",
"calling https://api.example.com:8443/v1/users?email=a@b.example",
"GET http://localhost:8080/v1/users/alice@example.com"
})
void aUriWithoutUserinfoIsUntouched(String line) {
assertThat(LogMaskingPatterns.mask(line)).isSameAs(line);
}
}