From b8d21d1592a5c293d73c033c7627dd5b314ae3b7 Mon Sep 17 00:00:00 2001 From: sneak Date: Sun, 9 Aug 2026 16:10:45 +0000 Subject: [PATCH] Keep secrets out of the Docker build context at every depth (closes #29) The canonical .dockerignore was three lines -- .git, node_modules, .DS_Store -- while the canonical Dockerfile does `COPY . .`, so a developer's local .env, *.pem or *.key was shipped into the build context and could land in an image layer. Nothing surfaced it because .gitignore covers those patterns, so the files are invisible to every git-based check. The obvious repair, copying .gitignore's secret patterns across, is worse than the gap it closes. .dockerignore does not use .gitignore semantics: Docker matches with Go filepath.Match, `*` does not cross `/`, and a pattern without a leading `**/` is anchored at the build-context root. A file listing .env, *.pem and *.key therefore reads as solved, reviews as solved, and protects only the repository root, while config/.env and certs/server.key still ship. The three-line file at least invited scrutiny; the transplanted form manufactures confidence and stops anyone looking. So every depth-independent pattern here carries the `**/` prefix and only genuinely root-anchored entries stay unprefixed. `**/node_modules` fixes a defect the three-line file had today for any nested node_modules, independently of the secret exposure. The OS and editor patterns are included on their own merits rather than by mirroring .gitignore. None of them is ever a build input, and editor state in particular churns under a developer's hands, so each one is a source of `COPY . .` invalidation carrying no information about the source tree. Now that the checks are keyed on CHECK_EPOCH rather than on accidental context churn, there is no reason left to keep churn in the context. Language build artifacts are deliberately absent: they are per-repo, and the file's header comment tells consuming repos to add their own host-built binaries, which is the case that actually bites -- a host `make build` drops a multi-megabyte artifact into the context where .gitignore hides it from every git-based check. .gitignore is untouched. Its semantics are the inverse: an unanchored pattern already matches at any depth, so `**/`-prefixing it produces a file that is wrong in a way that looks careful. That asymmetry is why "derive one from the other" was the wrong instruction, and it is now written down in REPO_POLICIES.md in both directions, together with the requirement to verify by enumerating the image rather than by reading the patterns. Every consuming repo inherits .dockerignore by copy, so the trap has to live where the next person looks, not only be fixed once here. Both repo checklists gain the same requirement, since they are what an agent reads while extending the file. Verified by planting .env, server.key and ca.pem at the root plus config/.env, config/.env.production, certs/ca.pem, certs/server.key, deploy/secrets/id_rsa.key, web/node_modules/nested/index.js and a nested .swp below it, then building a standalone probe image doing `COPY . .` and listing what actually landed inside it. Before: all eleven planted files in the image. Against the naive unprefixed form: the three root-level files excluded and every nested one still present, which is what shows the enumeration can detect the failure mode at all. After: every planted file excluded at every depth, with web/src/app.js still present to prove the probe was copying nested files rather than copying nothing. Transferred-context size is recorded but load-bearing on nothing, and the runs show why: the naive build reported 2.18kB transferred while 43 files, five of them secrets, were in the image. BuildKit transfers only the delta from the previous build, so the number describes the transfer and not the contents. Planted files were removed and their absence confirmed against the filesystem rather than against `git status`, which could not have seen them. `make docker` re-run after the change: the check layer executed rather than being served from cache, so the CHECK_EPOCH verification still holds under the altered build context. --- .dockerignore | 37 ++++++++++++++++++++++++++++-- TODO.md | 11 +++++++++ prompts/EXISTING_REPO_CHECKLIST.md | 7 ++++++ prompts/NEW_REPO_CHECKLIST.md | 6 +++++ prompts/REPO_POLICIES.md | 34 ++++++++++++++++++++++++++- 5 files changed, 92 insertions(+), 3 deletions(-) diff --git a/.dockerignore b/.dockerignore index 5414d56..c7a02e9 100644 --- a/.dockerignore +++ b/.dockerignore @@ -1,3 +1,36 @@ +# .dockerignore uses Go filepath.Match, NOT .gitignore semantics: `*` +# does not cross `/`, and a pattern without a leading `**/` is anchored +# at the build-context root. Every depth-independent pattern therefore +# needs the `**/` prefix — without it `config/.env` and +# `certs/server.key` still ship while the file reads as solved. Entries +# that are genuinely root-anchored stay unprefixed. Extend this file +# with the repo's own host-built artifacts (compiled binaries, test +# binaries, coverage output); those are per-repo and belong here because +# a host build otherwise drops them into the context. + +# Repository metadata: exactly one, at the context root. .git -node_modules -.DS_Store + +# Environment and secrets. These are the reason the prefixes matter: a +# developer's local copy is invisible to every git-based check. +**/.env +**/.env.* +**/*.pem +**/*.key + +# Dependencies: restored inside the image, never copied in. +**/node_modules + +# OS metadata. +**/.DS_Store +**/Thumbs.db + +# Editor state. Never a build input, and it churns under a developer's +# hands, so it invalidates COPY for reasons unrelated to the source. +**/*.swp +**/*.swo +**/*~ +**/*.bak +**/.idea +**/.vscode +**/*.sublime-* diff --git a/TODO.md b/TODO.md index 8d9557d..6d371f9 100644 --- a/TODO.md +++ b/TODO.md @@ -21,6 +21,17 @@ fmt-check, and commit. # Completed Steps +- 2026-08-09: Closed the secret exposure in the canonical `.dockerignore`: a + developer's local `.env`, `*.pem` or `*.key` was reaching the Docker build + context under `COPY . .`, invisible to every git-based check because + `.gitignore` covers it. The patterns are written to `.dockerignore`'s own + `filepath.Match` semantics — `**/`-prefixed so they hold at every depth, which + also fixes nested `node_modules` — rather than transplanted from `.gitignore`, + whose unprefixed form protects only the repository root while reading as + solved. `REPO_POLICIES.md` and both repo checklists now state that asymmetry + and require verification by enumerating the image rather than by reading the + patterns. Verified with a probe image before, against the naive unprefixed + form, and after. - 2026-08-09: Made the pinned golangci-lint actually propagate: REPO_POLICIES.md now carries the canonical `script/bootstrap` snippet for Go repos, which installs when the installed version does not match the pin (the old diff --git a/prompts/EXISTING_REPO_CHECKLIST.md b/prompts/EXISTING_REPO_CHECKLIST.md index 69cb02b..38a5d3e 100644 --- a/prompts/EXISTING_REPO_CHECKLIST.md +++ b/prompts/EXISTING_REPO_CHECKLIST.md @@ -37,6 +37,13 @@ with your task. `CHECK_EPOCH` rule in `REPO_POLICIES.md`. Without them the check layer is served from cache on an unchanged tree and the build reports a green it never ran. +- [ ] Every depth-independent pattern in `.dockerignore` carries a `**/` prefix; + only genuinely root-anchored entries such as `.git` are unprefixed, and + `.gitignore`'s patterns have not been transplanted unmodified. + `.dockerignore` anchors an unprefixed pattern at the context root, so the + transplanted form leaves `config/.env` and `certs/server.key` in the build + context while reading as solved — see the `.dockerignore` rule in + `REPO_POLICIES.md`. - [ ] Gitea Actions workflow in `.gitea/workflows/` runs `script/cibuild` on push — reference `https://git.eeqj.de/sneak/prompts/raw/branch/main/.gitea/workflows/check.yml` diff --git a/prompts/NEW_REPO_CHECKLIST.md b/prompts/NEW_REPO_CHECKLIST.md index 5b0bcfe..d090d41 100644 --- a/prompts/NEW_REPO_CHECKLIST.md +++ b/prompts/NEW_REPO_CHECKLIST.md @@ -52,6 +52,12 @@ Template files can be fetched from: `https://git.eeqj.de/sneak/prompts/raw/branch/main/prompts/REPO_POLICIES.md` - [ ] `Dockerfile` and `.dockerignore` — fetch `.dockerignore` from `https://git.eeqj.de/sneak/prompts/raw/branch/main/.dockerignore` + - Extend `.dockerignore` with the repo's own host-built artifacts, giving + every depth-independent pattern a `**/` prefix. Do not transplant + `.gitignore`'s patterns: `.dockerignore` anchors an unprefixed pattern at + the context root, so the copied form leaves `config/.env` in the build + context while reading as solved. See the `.dockerignore` rule in + `REPO_POLICIES.md`. - All Dockerfiles must run `make check` as a build step, and every stage containing a check-running `RUN` must declare `ARG CHECK_EPOCH` with the `RUN [ -n "$CHECK_EPOCH" ] || exit 1` guard immediately below it — see the diff --git a/prompts/REPO_POLICIES.md b/prompts/REPO_POLICIES.md index a893c8d..9400bc8 100644 --- a/prompts/REPO_POLICIES.md +++ b/prompts/REPO_POLICIES.md @@ -331,7 +331,39 @@ style conventions are in separate documents: editor files (`.swp`, `*~`), language build artifacts, and `node_modules/`. Fetch the standard `.gitignore` from `https://git.eeqj.de/sneak/prompts/raw/branch/main/.gitignore` when setting up - a new repo. + a new repo. These patterns are written to `.gitignore`'s own semantics, in + which an unanchored pattern already matches at every depth. They are not a + `.dockerignore` and must not be transplanted into one unmodified — see the + next rule. + +- **`.dockerignore` does not use `.gitignore` semantics, and copying patterns + across unmodified leaves secrets in the build context.** Docker matches with + Go `filepath.Match`: `*` does not cross `/`, and a pattern without a leading + `**/` is anchored at the build-context root. A `.dockerignore` listing `.env`, + `*.pem` and `*.key` therefore excludes only the copies at the repository root; + `config/.env` and `certs/server.key` still reach the context and can land in + an image layer. That file is more dangerous than a short one with no secret + patterns at all, because it reads as solved and stops anyone looking. Give + every depth-independent pattern the `**/` prefix — `**/.env`, `**/.env.*`, + `**/*.pem`, `**/*.key`, `**/node_modules` — and leave only genuinely + root-anchored entries such as `.git` unprefixed. The inverse move is equally + wrong: never apply `**/` to `.gitignore`, where it is redundant and produces a + file that is wrong in a way that looks careful. Each file is written to its + own semantics; neither is derived from the other. Fetch the standard + `.dockerignore` from + `https://git.eeqj.de/sneak/prompts/raw/branch/main/.dockerignore` and extend + it with the repo's own host-built artifacts — a host `make build` that leaves + a compiled binary in the repo root puts that binary in the build context, + where `.gitignore` hides it from every git-based check. + +- **Verify `.dockerignore` by enumerating the image, not by reading the + patterns.** Plant files at the root _and_ at least two directories deep, build + a probe image that does `COPY . .`, and list what actually landed + (`docker run --rm --entrypoint find IMAGE /app`). Reading the patterns and + agreeing they look right is exactly what lets the root-only form through. The + `transferring context` size is not a substitute: a nested secret is a few + bytes, and BuildKit transfers only the delta from the previous build, so the + reported size describes the transfer and not the contents of the image. - **No build artifacts in version control.** Code-derived data (compiled bundles, minified output, generated assets) must never be committed to the