Derive the vault key from the mnemonic's words however they are spaced (closes #135)

The long-term key was derived from the mnemonic text exactly as typed,
so a double space, a tab or a trailing newline gave a different key,
and a vault made that way did not open with the same words typed
normally. agehd.DeriveEntropy, which init, vault create, vault import,
unlocker add and every unlock go through, now joins the words with
single spaces and puts them in Unicode NFKD, as BIP39 defines the
seed's input, before hashing them. golang.org/x/text, already an
indirect dependency, becomes a direct one for the NFKD step.

Judgement call: internal/bip39's NewSeed keeps hashing its input as
given, as upstream does; the normalising is in agehd.

Model: opus-5-5

.dockerignore

@@ -1,29 +1,78 @@
+# .dockerignore does NOT use .gitignore semantics. Docker matches with
+# moby/patternmatcher: filepath.Match plus `**`, so `*` does not cross
+# `/` and an unprefixed pattern is anchored at the context root. Every
+# depth-independent pattern therefore needs `**/`, or `config/.env` and
+# `certs/server.key` still ship while this file reads as solved. Only
+# genuinely root-anchored entries go unprefixed. Never transplant these
+# into .gitignore, where `**/` is wrong.
+#
+# Matching is case-sensitive, so secrets use character ranges rather
+# than an ALL-CAPS twin, which would still miss `Server.Key`.
+#
+# Extend with this repo's own host-built artifacts, written anchored:
+# `/myapp`, never `**/myapp`, which also matches `cmd/myapp/` and
+# deletes the package directory from the context.
+
 # .git is sent without its config. Without a VERSION build argument the
 # stage that compiles runs `git describe --tags --always` on .git, which
 # does not need .git/config; that file can hold a credential, such as a
 # password in a remote URL or the token the CI checkout step stores there.
-.git/config
+# Each submodule keeps a config with the same exposure in its git directory
+# under .git/modules/, nested again for a submodule's own submodules, or in
+# its own .git directory when it keeps one.
+# KNOWN GAP: a submodule whose name has a `config` segment (`config`,
+# `deploy/config`, `config/lib`) loses its whole git directory, because
+# `**/.git/modules/**/config` also matches that segment's directory
+# under .git/modules/. Go's version stamping then fails the build;
+# nothing leaks. Name such a submodule without that segment:
+# `git submodule add --name`.
+**/.git/config
+**/.git/modules/**/config
 
-# Build artifacts
-secret
-coverage.out
-*.test
+# Agent scratch: one full checkout of the repo per in-flight agent.
+# Anchored because it occurs once where agents run at the repo root.
+# KNOWN GAP: a repo running agents in subdirectories still ships
+# `services/api/.claude/` and must add its own anchored entry.
+.claude
 
-# IDE and editor files
-.vscode
-.idea
-*.swp
-*.swo
-*~
+# Environment files. `*.env` covers bare `.env` and the `prod.env`
+# convention. Re-include a committed template with a negation if the
+# build needs one: `!docs/example.env`.
+**/*.[eE][nN][vV]
+**/.[eE][nN][vV].*
+**/.[eE][nN][vV][rR][cC]
 
-# Dependencies
-node_modules
+# Private keys and the bundles carrying them. Public certificates
+# (*.crt, *.cer) are deliberately absent: they are legitimate inputs.
+**/*.[pP][eE][mM]
+**/*.[kK][eE][yY]
+**/*.[pP]12
+**/*.[pP][fF][xX]
+**/[iI][dD]_[rR][sS][aA]
+**/[iI][dD]_[dD][sS][aA]
+**/[iI][dD]_[eE][cC][dD][sS][aA]
+**/[iI][dD]_[eE][cC][dD][sS][aA]_[sS][kK]
+**/[iI][dD]_[eE][dD]25519
+**/[iI][dD]_[eE][dD]25519_[sS][kK]
 
-# macOS
-.DS_Store
+# Dependencies: restored inside the image, never copied in.
+**/node_modules
 
-# Claude files
-.claude/
+# OS metadata.
+**/.DS_Store
+**/Thumbs.db
 
-# Local settings
-.claude/settings.local.json
+# Editor state: never a build input, and it churns COPY.
+**/*.swp
+**/*.swo
+**/*~
+**/*.bak
+**/.idea
+**/.vscode
+**/*.sublime-*
+
+# This repo's host-built artifacts: the binary script/build writes, test
+# binaries and coverage output.
+/secret
+/*.test
+/coverage.out

.editorconfig

@@ -10,3 +10,6 @@ insert_final_newline = true
 
 [Makefile]
 indent_style = tab
+
+[*.go]
+indent_style = tab

.gitea/workflows/check.yml

@@ -4,6 +4,6 @@ jobs:
     check:
         runs-on: ubuntu-latest
         steps:
-            # actions/checkout v4.2.2, 2026-02-28
+            # actions/checkout v4.2.2, 2026-02-22
             - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
             - run: script/cibuild

.gitignore

@@ -20,15 +20,35 @@ Thumbs.db
 # Node
 node_modules/
 
-# Environment / secrets
-.env
-.env.*
-*.pem
-*.key
+# Secrets. Unanchored like every entry above, so each matches at every
+# depth. Matching is case-sensitive on Linux, so names use character
+# ranges rather than a lowercase form that misses `Server.Key`.
 
-# This repo. /secret is the built binary, anchored so that it does not
-# also match the internal/secret/ package directory.
-/secret
+# Environment files. `*.env` covers bare `.env` and the `prod.env`
+# convention. Only the templates `example.env` and `sample.env` are
+# re-included below. A repository that commits any other template adds
+# its own negation after these lines, for example `!.env.example`.
+*.[eE][nN][vV]
+.[eE][nN][vV].*
+.[eE][nN][vV][rR][cC]
+!example.env
+!sample.env
+
+# Private keys and the bundles carrying them.
+*.[pP][eE][mM]
+*.[kK][eE][yY]
+*.[pP]12
+*.[pP][fF][xX]
+[iI][dD]_[rR][sS][aA]
+[iI][dD]_[dD][sS][aA]
+[iI][dD]_[eE][cC][dD][sS][aA]
+[iI][dD]_[eE][cC][dD][sS][aA]_[sS][kK]
+[iI][dD]_[eE][dD]25519
+[iI][dD]_[eE][dD]25519_[sS][kK]
+
+# Go. /secret is the built binary, anchored so that it does not also match
+# the internal/secret/ package directory.
 *.log
+*.out
 *.test
-settings.local.json
+/secret

.golangci.yml

@@ -17,6 +17,7 @@ linters:
   disable:
     # Genuinely incompatible with project patterns
     - exhaustruct      # Requires all struct fields
+    - exhaustruct_v5   # Requires all struct fields (successor to exhaustruct)
     - godot            # Requires comments to end with periods
     - wrapcheck        # Too verbose for internal packages
     - varnamelen       # Short names like db, id are idiomatic Go

AGENTS.md

@@ -100,6 +100,18 @@ Version: 2025-06-08
     are acceptable in the root, but source code and other files should be
     organized in appropriate subdirectories.
 
+13. Commit messages carry no author or co-author attribution for the coding
+    agent. The agent is an inanimate tool and the owner is the sole author of
+    the code it writes; such a line is advertising, not attribution.
+
+14. Never run part of the test suite: always run the whole thing with
+    `make test`.
+
+15. Do not stop working on a task until you have reached the definition of done
+    it gives. Do all of the work, not part or most of it.
+
+16. After each commit, push to the remote.
+
 ## Python-Specific Guidelines
 
 1. **Type Annotations (UP006)**: Use built-in collection types directly for type
@@ -154,10 +166,17 @@ Version: 2025-06-08
 
 3. **Wrap errors** with `fmt.Errorf("context: %w", err)` for debuggability.
 
-4. **Never modify linter config** (`.golangci.yml`) to suppress findings. Fix
-   the code.
+4. **Never modify linter config** (`.golangci.yml`) to suppress findings, and do
+   not modify it at all unless specifically instructed. Fix the code.
 
 5. **All PRs must pass `make check` with zero failures.** No exceptions, no
    "pre-existing issue" excuses.
 
 6. **Pin external dependencies by commit hash**, not mutable tags.
+
+7. **A program's `main.go` is `./cmd/<program_name>/main.go`** and only imports
+   and calls `<program_name>.CLIEntry()`; the implementation is in
+   `./internal/<program_name>/`. This keeps several programs in one repository
+   from cluttering the root directory.
+
+8. **Log with `log/slog`.**

CLAUDE.md

@@ -1,95 +0,0 @@
-# IMPORTANT RULES
-
-* Claude is an inanimate tool.  The spam that Claude attempts to insert into
-  commit messages (which it erroneously refers to as "attribution") is not
-  attribution, as I am the sole author of code created using Claude.  It is
-  corporate advertising for Anthropic and is therefore completely
-  unacceptable in commit messages.
-
-* Tests should always be run before committing code.  No commits should be
-  made that do not pass tests.
-
-* Code should always be formatted before committing.  Do not commit
-  unformatted code.
-
-* Code should always be linted and linter errors fixed before committing.
-  NEVER commit code that does not pass the linter.  DO NOT modify the linter
-  config unless specifically instructed.
-
-* The test suite is fast and local.  When running tests, NEVER run
-  individual parts of the test suite, always run the whole thing by running
-  "make test".
-
-* Do not stop working on a task until you have reached the definition of
-  done provided to you in the initial instruction.  Don't do part or most of
-  the work, do all of the work until the criteria for done are met.
-
-* When you complete each task, if the tests are passing and the code is
-  formatted and there are no linter errors, always commit and push your
-  work. Use a good commit message and don't mention any author or co-author
-  attribution.
-
-* Do not create additional files in the root directory of the project
-  without asking permission first. Configuration files, documentation, and
-  build files are acceptable in the root, but source code and other files
-  should be organized in appropriate subdirectories.
-
-* Do not use bare strings or numbers in code, especially if they appear
-  anywhere more than once.  Always define a constant (usually at the top of
-  the file) and give it a descriptive name, then use that constant in the
-  code instead of the bare string or number.
-
-* If you are fixing a bug, write a test first that reproduces the bug and
-  fails, and then fix the bug in the code, using the test to verify that the
-  fix worked.
-
-* When implementing new features, be aware of potential side-effects (such
-  as state files on disk, data in the database, etc.) and ensure that it is
-  possible to mock or stub these side-effects in tests when designing an
-   API.
-
-* When dealing with dates and times or timestamps, always use, display, and
-  store UTC.  Set the local timezone to UTC on startup.  If the user needs
-  to see the time in a different timezone, store the user's timezone in a
-  separate field and convert the UTC time to the user's timezone when
-  displaying it.  For internal use and internal applications and
-  administrative purposes, always display UTC.
-
-* When implementing programs, put the main.go in
-  ./cmd/<program_name>/main.go and put the program's code in
-  ./internal/<program_name>/.  This allows for multiple programs to be
-  implemented in the same repository without cluttering the root directory.
-  main.go should simply import and call <program_name>.CLIEntry().  The
-  full implementation should be in ./internal/<program_name>/.
-
-* When you are instructed to make the tests pass, DO NOT delete tests, skip
-  tests, or change the tests specifically to make them pass (unless there
-  is a bug in the test).  This is cheating, and it is bad.  You should only
-  be modifying the test if it is incorrect or if the test is no longer
-  relevant.  In almost all cases, you should be fixing the code that is
-  being tested, or updating the tests to match a refactored implementation.
-
-* Always write a `Makefile` with the default target being `test`, and with a
-  `fmt` target that formats the code.  The `test` target should run all
-  tests in the project, and the `fmt` target should format the code.  `test`
-  should also have a prerequisite target `lint` that should run any linters
-  that are configured for the project.
-
-* After each completed bugfix or feature, the code must be committed.  Do
-  all of the pre-commit checks (test, lint, fmt) before committing, of
-  course.  After each commit, push to the remote.
-
-* Always write tests, even if they are extremely simple and just check for
-  correct syntax (ability to compile/import). If you are writing a new
-  feature, write a test for it.  You don't need to target complete coverage,
-  but you should at least test any new functionality you add.
-
-* Always use structured logging.  Log any relevant state/context with the
-  messages (but do not log secrets).  If stdout is not a terminal, output
-  the structured logs in jsonl format.  Use go's log/slog.
-
-* You do not need to summarize your changes in the chat after making them.
-  Making the changes and committing them is sufficient.  If anything out of
-  the ordinary happened, please explain it, but in the normal case where you
-  found and fixed the bug, or implemented the feature, there is no need for
-  the end-of-change summary.

Dockerfile

@@ -1,68 +1,76 @@
-# Lint stage — fast feedback on formatting and lint issues
-# golangci/golangci-lint:v2.12.2 (Debian-based), 2026-08-07
-FROM golangci/golangci-lint:v2.12.2@sha256:5cceeef04e53efe1470638d4b4b4f5ceefd574955ab3941b2d9a68a8c9ad5240 AS lint
-
+# Lint phase. The linter is invoked directly rather than through `make
+# lint` or `script/lint`, which are themselves a docker build.
+# golangci/golangci-lint:v2.14.0 (Debian-based), 2026-09-24
+FROM golangci/golangci-lint@sha256:ad862ba6b3798cbe0fd9fd7408d498fd74fbd2623a92406b2fd3898faf0bf98f AS lint
 WORKDIR /src
 COPY go.mod go.sum ./
 RUN go mod download
-
-# script/cibuild sets CHECK_EPOCH to the current time, so the RUN steps
-# below run again on each build, an unchanged tree included, while the
-# steps above stay cached. ARG is per stage: the build stage declares it too.
-ARG CHECK_EPOCH
-
 COPY . .
-
-RUN make fmt-check
-# Not make lint or make lint-darwin: script/lint and script/lint-darwin are
-# docker builds, which cannot run in here. These are their commands.
+RUN go vet ./...
 RUN golangci-lint run --config .golangci.yml ./...
+# The same checks on the code as a macOS build compiles it, which a Linux
+# build never compiles. Cgo is off, because compiling cgo code for macOS
+# needs Apple's SDK headers.
 RUN GOOS=darwin CGO_ENABLED=0 go vet ./...
 RUN GOOS=darwin CGO_ENABLED=0 golangci-lint run --config .golangci.yml ./...
 
-# Build stage — tests and compilation
-# golang 1.24.13-alpine (2026-03-10)
-FROM golang@sha256:8bee1901f1e530bfb4a7850aa7a479d17ae3a18beb6e09064ed54cfd245b7191 AS builder
-
-# Force BuildKit to run the lint stage
-COPY --from=lint /src/go.sum /dev/null
-
-RUN apk add --no-cache gcc musl-dev make git gnupg
-
-WORKDIR /build
+# Test phase. -race needs cgo and so a C compiler, which the Debian Go
+# image ships and the alpine one does not.
+# golang:1.24.13-trixie, 2026-02-04
+FROM golang@sha256:5835f052b784aa39f2fe9070def3568605c8bc3fcd810f10402066348b61e716 AS test
+ENV CGO_ENABLED=1
+WORKDIR /src
 COPY go.mod go.sum ./
 RUN go mod download
+COPY . .
+# Go's build cache goes in a cache mount, not the image layer, which would
+# take seconds longer to export. --no-cache, on every build in script/,
+# starts the mount empty; -count=1 keeps a build without it from taking
+# test results from there.
+RUN --mount=type=cache,id=sneak/secret/go-build-test,target=/root/.cache/go-build \
+    go test -count=1 -timeout 90s -race -cover ./... || \
+    { echo "--- Rerunning with -v for details ---"; \
+      go test -count=1 -timeout 90s -race -v ./...; exit 1; }
 
-# As in the lint stage: the RUN steps below run again on each script/cibuild.
-ARG CHECK_EPOCH
-
+# Build stage. Nothing is wanted from either phase above; the copies are
+# what make BuildKit build them first, so this stage cannot run unless
+# lint and test passed.
+# golang 1.24.13-alpine, 2026-03-10
+FROM golang@sha256:8bee1901f1e530bfb4a7850aa7a479d17ae3a18beb6e09064ed54cfd245b7191 AS builder
+COPY --from=lint /src/go.sum /dev/null
+COPY --from=test /src/go.sum /dev/null
+# script/build compiles with cgo, so it needs a C compiler too.
+RUN apk add --no-cache gcc musl-dev make git
+# A tar-stream context keeps the sender's file owners, which git refuses.
+RUN git config --system --add safe.directory /src
+WORKDIR /src
+COPY go.mod go.sum ./
+RUN go mod download
 COPY . .
 
-RUN make test
-
-# The version stamped into the binary: the VERSION build argument when one
-# is given, otherwise `git describe --tags --always` of the .git the build
-# context carries: the tag on a tagged commit, tag-N-gHASH on a commit after
-# one, the short commit when no tag is reachable. A context that carries .git
-# and still yields no version fails the build.
+# The VERSION build arg when one is given, otherwise
+# `git describe --tags --always` on the .git in the build context. With
+# .git present, a version that is still empty, dev or unknown fails the
+# build: git is missing or could not read the checkout.
 ARG VERSION
-RUN version="${VERSION:-$(git describe --tags --always)}"; \
-    if [ -e .git ] && { [ -z "$version" ] || [ "$version" = dev ] || \
-        [ "$version" = unknown ]; }; then \
-        echo "no version could be derived although the build context carries .git" >&2; \
-        exit 1; \
+RUN VERSION="${VERSION:-$(git describe --tags --always)}"; \
+    if [ -e .git ]; then \
+        case "$VERSION" in ""|dev|unknown) \
+            echo "version is '$VERSION' although .git is present" >&2; \
+            exit 1 ;; \
+        esac; \
     fi; \
-    make build VERSION="${version:-dev}"
+    make build VERSION="${VERSION:-dev}"
 
-# Runtime stage
-# alpine 3.23 (2026-03-10)
+# Runtime stage, and the last one
+# alpine 3.23, 2026-03-10
 FROM alpine@sha256:25109184c71bdad752c8312a8623239686a9a2071e8825f20acb8f2198c3f659
 
 RUN apk add --no-cache ca-certificates gnupg
 
 RUN adduser -D -s /bin/sh secret
 
-COPY --from=builder /build/secret /usr/local/bin/secret
+COPY --from=builder /src/secret /usr/local/bin/secret
 RUN chmod +x /usr/local/bin/secret
 
 USER secret

Dockerfile.lint

@@ -1,29 +0,0 @@
-# Lint image, built by script/lint and script/lint-darwin: golangci-lint runs
-# as a build step, so a successful build is a clean lint. Works where the
-# docker daemon is remote and bind mounts are impossible.
-
-# golangci/golangci-lint:v2.12.2 (Debian-based), 2026-08-07
-FROM golangci/golangci-lint:v2.12.2@sha256:5cceeef04e53efe1470638d4b4b4f5ceefd574955ab3941b2d9a68a8c9ad5240 AS deps
-
-WORKDIR /src
-
-COPY go.mod go.sum ./
-RUN go mod download
-
-# script/lint rebuilds this stage on every run, by this name; the module
-# download above stays cached.
-FROM deps AS lint
-
-COPY . .
-
-RUN golangci-lint run --config .golangci.yml ./...
-
-# script/lint-darwin rebuilds this stage on every run, by this name. It
-# checks the code as a macOS build compiles it, but with cgo off, which
-# leaves out the files that need cgo on macOS (see script/lint-darwin).
-FROM deps AS lint-darwin
-
-COPY . .
-
-RUN GOOS=darwin CGO_ENABLED=0 go vet ./...
-RUN GOOS=darwin CGO_ENABLED=0 golangci-lint run --config .golangci.yml ./...

Makefile

@@ -1,7 +1,7 @@
 export CGO_ENABLED=1
 
-.PHONY: default bootstrap setup build test lint lint-darwin fmt fmt-check \
-	check docker docker-run clean install hooks
+.PHONY: default bootstrap setup build test lint fmt fmt-check check docker \
+	docker-run clean install hooks
 
 default: check
 
@@ -21,13 +21,10 @@ test:
 fmt:
 	@script/fmt
 
+# Vets and lints the Linux build, then the macOS build
 lint:
 	@script/lint
 
-# Type-check and lint the macOS build from Linux (see script/lint-darwin)
-lint-darwin:
-	@script/lint-darwin
-
 check:
 	@script/check
 

README.md

@@ -223,8 +223,6 @@ Creates a new unlocker of the specified type:
 
 - `passphrase`: Traditional passphrase-protected unlocker
 - `pgp`: Uses an existing GPG key for encryption/decryption
-- `keychain`: macOS Keychain integration (macOS only)
-- `secure-enclave`: Hardware-backed Secure Enclave protection (macOS only)
 
 **Options:**
 
@@ -345,21 +343,6 @@ Unlockers provide different authentication methods to access the long-term keys:
     - Leverages existing key management workflows
     - Strong authentication through GPG
 
-3. **Keychain Unlockers** (macOS only):
-    - Stores unlock keys in macOS Keychain
-    - Kept on this Mac only: the keychain item is never synced to other devices
-    - Automatic unlocking when Keychain is unlocked
-    - Cross-application integration
-
-4. **Secure Enclave Unlockers** (macOS):
-    - Hardware-backed key storage using Apple Secure Enclave
-    - Uses `sc_auth` / CryptoTokenKit for SE key management (no Apple Developer
-      Program required)
-    - ECIES encryption: the vault long-term key is encrypted directly to the SE
-      key, and only the SE can decrypt it
-    - The SE key cannot leave this Mac; using it asks for no Touch ID or
-      password
-
 Each vault maintains its own set of unlockers and one long-term key. The
 long-term key is encrypted to each unlocker, allowing any authorized unlocker to
 access vault secrets.
@@ -412,9 +395,6 @@ variables.
 ### Hardware Integration
 
 - Hardware token support via PGP/GPG integration
-- macOS Keychain integration for system-level security
-- Secure Enclave integration for hardware-backed key protection (macOS, via
-  `sc_auth` / CryptoTokenKit)
 
 ## Examples
 
@@ -468,8 +448,6 @@ secret vault remove personal --force
 # Add multiple unlock methods
 secret unlocker add passphrase              # Password-based
 secret unlocker add pgp --keyid ABCD1234    # GPG key
-secret unlocker add keychain                # macOS Keychain (macOS only)
-secret unlocker add secure-enclave          # macOS Secure Enclave (macOS only)
 
 # List unlockers
 secret unlocker list
@@ -538,12 +516,8 @@ secret decrypt encryption/mykey --input document.txt.age --output document.txt
 
 ### Cross-Platform Support
 
-- **macOS**: Full support including Keychain and Secure Enclave integration
-- **Linux**: Full support (excluding macOS-specific features)
-
-The keychain and Secure Enclave unlockers need a macOS build with cgo. A macOS
-build without cgo, such as one cross-compiled from Linux, offers them but fails
-to add or use them.
+- **macOS**: Full support
+- **Linux**: Full support
 
 ## Security Considerations
 
@@ -556,7 +530,7 @@ to add or use them.
 ### Best Practices
 
 1. Use strong, unique passphrases for unlockers
-2. Enable hardware authentication (Keychain, hardware tokens) when available
+2. Enable hardware authentication (hardware tokens) when available
 3. Regularly audit unlockers and remove unused ones
 4. Keep mnemonic phrases securely backed up offline
 5. Use separate vaults for different security contexts
@@ -565,7 +539,6 @@ to add or use them.
 
 - Requires access to unlockers for secret retrieval
 - Mnemonic phrases must be securely stored and backed up
-- Hardware features limited to supported platforms
 
 ## Development
 
@@ -593,8 +566,10 @@ standard: normalized scripts in `script/` are the entrypoints for the
 development workflow, and the Makefile targets are thin shims that call them. We
 provide:
 
-- `script/bootstrap` — install all dependencies (Go, Go module download),
-  idempotently; golangci-lint is not installed, it runs in docker
+- `script/bootstrap` — install all dependencies (Go, Go module download, and
+  node, yarn and prettier for formatting markdown), idempotently; prettier is
+  pinned by hash in `package.json` and `yarn.lock`; golangci-lint is not
+  installed, it runs in docker
 - `script/setup` — make a fresh clone ready for development: runs
   `script/bootstrap`, then `script/install-precommit`
 - `script/projectname` — output the project name (`secret`); used by other
@@ -602,24 +577,21 @@ provide:
 - `script/build` — build the `secret` binary into the repo root, stamping the
   version (`VERSION` from the environment, else `git describe`) and the git
   commit
-- `script/test` — run `go vet` and the test suite (verbose rerun on failure)
-- `script/lint` — run `golangci-lint` in docker only: builds `Dockerfile.lint`,
-  where the linter is a build step that runs on every call, also on an unchanged
-  tree
-- `script/lint-darwin` — run `go vet` and `golangci-lint` in docker on the code
-  as a macOS build compiles it (`GOOS=darwin`), which a Linux build never
-  compiles; cgo is off, so the keychain unlocker's calls into the keychain
-  (`internal/secret/keychainunlocker_cgo.go`, and `keychainunlocker_test.go`)
-  and the Secure Enclave bindings (`internal/macse`) are not checked
-- `script/fmt` — format all Go code (writes)
-- `script/fmt-check` — check formatting without writing
-- `script/check` — run `script/test`, `script/lint`, `script/lint-darwin`, and
-  `script/fmt-check`
-- `script/docker` — build the Docker image tagged with the project name
-- `script/cibuild` — CI entrypoint: `docker build --ulimit memlock=-1:-1 .`
-  (memguard needs mlock; the Dockerfile runs the checks), with a new
-  `CHECK_EPOCH` build argument on every run so the checks run again on an
-  unchanged tree
+- `script/test` — build the `test` phase of the `Dockerfile`, which runs the
+  test suite with the race detector, a 90-second timeout and coverage; on
+  failure it reruns the tests verbosely for the details and fails even when the
+  rerun passes
+- `script/lint` — build the `lint` phase of the `Dockerfile`, which runs
+  `go vet` and `golangci-lint`, then both again on the code as a macOS build
+  compiles it (`GOOS=darwin`, with cgo off), which a Linux build never compiles
+- `script/fmt` — format all Go code with `go fmt` and every markdown file with
+  prettier (4-space tabs, `proseWrap: always`) (writes)
+- `script/fmt-check` — check the same formatting without writing, on the host
+- `script/check` — run `script/test`, `script/lint` and `script/fmt-check`
+- `script/docker` — build the Docker image tagged with the project name; the
+  build runs the `lint` and `test` phases first
+- `script/cibuild` — CI entrypoint: runs `script/bootstrap`, `script/check`,
+  then builds the image as `script/docker` does
 - `script/precommit` — pre-commit checks: `go mod tidy` verification, then
   `script/check`
 - `script/install-precommit` — install the git pre-commit hook that runs
@@ -627,8 +599,7 @@ provide:
 
 ## Features
 
-- **Multiple Authentication Methods**: Supports passphrase, PGP, macOS Keychain,
-  and Secure Enclave unlockers
+- **Multiple Authentication Methods**: Supports passphrase and PGP unlockers
 - **Vault Isolation**: Complete separation between different vaults
 - **Per-Secret Encryption**: Each secret has its own encryption key
 - **BIP39 Mnemonic Support**: Keyless operation using mnemonic phrases

REPO_POLICIES.md

@@ -1,6 +1,6 @@
 ---
 title: Repository Policies
-last_modified: 2026-07-06
+last_modified: 2026-10-04
 ---
 
 This document covers repository structure, tooling, and workflow standards. Code
@@ -60,17 +60,28 @@ style conventions are in separate documents:
   prerequisite since nvm requires bash. yarn is then pinned via
   `corepack prepare yarn@<version> --activate`. Never install "latest" or "lts";
   always exact versions. `script/cibuild` runs the CI build: it changes to the
-  repo root and runs `docker build .`; the Gitea workflow calls it. Four further
-  scripts are our own extensions to the standard: `script/check` runs
-  `script/test`, `script/lint`, and `script/fmt-check`; `script/precommit` is
-  what the git pre-commit hook runs, and it calls `script/check`;
-  `script/install-precommit` installs the git pre-commit hook (the `make hooks`
-  target shims to it); and `script/projectname` (literally that filename) simply
-  outputs the project's name. Scripts that need the name call
-  `script/projectname` — e.g. `script/docker` assembles its image tag from it —
-  so those scripts stay byte-identical across all repos. Repo-type-specific
-  pre-commit extras (e.g. `go mod tidy` verification in Go repos) belong in
-  `script/precommit`, not in the hook itself. Model scripts are at
+  repo root, runs `script/bootstrap`, runs `script/check`, and builds the image
+  with the version; the Gitea workflow calls it. **`script/cibuild` runs
+  `script/bootstrap` first**, because the workflow checks out the repo and runs
+  nothing else, while `script/fmt-check` runs the formatter on the host: on a
+  pristine checkout with nothing installed the run dies there, after the
+  containerised gates have passed. **The bootstrap alone is not enough**:
+  `script/bootstrap` installs node and yarn under nvm and leaves neither on the
+  `PATH` of the shell that called it, so a bare `yarn` still exits 127. The host
+  entrypoints that need yarn — `script/fmt` and `script/fmt-check` — therefore
+  source nvm for the pinned node version before invoking it, exactly as
+  `script/bootstrap`'s own install step does. A runner carrying nothing but
+  docker and git then gets through `script/check`. Four further scripts are our
+  own extensions to the standard: `script/check` runs `script/test`,
+  `script/lint` and `script/fmt-check`; `script/precommit` is what the git
+  pre-commit hook runs, and it calls `script/check`; `script/install-precommit`
+  installs the git pre-commit hook (the `make hooks` target shims to it); and
+  `script/projectname` (literally that filename) simply outputs the project's
+  name. Scripts that need the name call `script/projectname` — e.g.
+  `script/docker` assembles its image tag from it — so those scripts stay
+  byte-identical across all repos. Repo-type-specific pre-commit extras (e.g.
+  `go mod tidy` verification in Go repos) belong in `script/precommit`, not in
+  the hook itself. Model scripts are at
   `https://git.eeqj.de/sneak/prompts/raw/branch/main/script/<name>`. The README
   must document the provided scripts in an **Entrypoints** section (see the
   README requirements below).
@@ -89,87 +100,198 @@ style conventions are in separate documents:
   contributor should be able to understand the entire development workflow by
   reading the Makefile.
 
-- Every repo should have a `Dockerfile`. All Dockerfiles must run `make check`
-  as a build step so the build fails if the branch is not green. For non-server
-  repos, the Dockerfile should bring up a development environment and run
-  `make check`. For server repos, `make check` should run as an early build
-  stage before the final image is assembled. Dockerfiles install development
-  prerequisites by running `script/bootstrap` rather than duplicating installs
-  inline; COPY `script/` and the dependency manifests (`package.json` +
-  `yarn.lock`, `go.mod` + `go.sum`, etc.) before running it so the bootstrap
-  layer stays cached until dependencies change.
+- Every repo should have a `Dockerfile`, and it carries the repo's gates: a
+  `lint` phase and a `test` phase, with the final stage depending on both so the
+  image cannot be built unless they pass. For non-server repos the final stage
+  brings up a development environment; for server repos it is the runtime image.
+  The gate phases and the build stage start from their pinned base images and
+  install what those images lack either inline, as the canonical Go `Dockerfile`
+  below does for `git`, or by running `script/bootstrap`, as the `prompts`
+  repo's own `Dockerfile` does for its yarn packages. The development
+  environment stage installs development prerequisites by running
+  `script/bootstrap` rather than duplicating its installs inline. A stage that
+  runs `script/bootstrap` COPYs `script/` and the dependency manifests
+  (`package.json` + `yarn.lock`, `go.mod` + `go.sum`, etc.) before running it.
 
-- **Dockerfiles must use a separate lint stage for fail-fast feedback.** Go
-  repos use a multistage build where linting runs in an independent stage based
-  on the `golangci/golangci-lint` image (pinned by hash). This stage runs
-  `make fmt-check` and `make lint` before the full build begins. The build stage
-  then declares an explicit dependency on the lint stage via
-  `COPY --from=lint /src/go.sum /dev/null`, which forces BuildKit to complete
-  linting before proceeding to compilation and tests. This ensures lint failures
-  surface in seconds rather than minutes, without blocking on dependency
-  download or compilation in the build stage.
+- **Linting and testing run in Docker, as phases of the `Dockerfile`.** There is
+  no separate lint file. `script/lint` and `script/test` each build one phase
+  and nothing else:
 
-    The standard pattern for a Go repo Dockerfile is:
+    ```sh
+    docker build --no-cache --target lint -t "$(script/projectname)-lint" .
+    docker build --no-cache --target test -t "$(script/projectname)-test" .
+    ```
+
+    **A stage that is not the last one in the file is built only when the final
+    stage's chain depends on it, or when `--target` names it.** That is why the
+    two gates are always invoked by name here, and why the final stage carries a
+    `COPY --from=` of a harmless file from each of them: without that edge a
+    plain `docker build .` builds the last stage alone and exits 0 having linted
+    and tested nothing.
+
+    **Every `docker build` in `script/` is tagged**, here and in
+    `script/cibuild` and `script/docker`. An untagged build leaves a dangling
+    image behind on every invocation, on every developer host and every CI
+    runner; a tagged one replaces the previous image.
+
+    Inside a phase the tool is invoked directly — `golangci-lint`, `go test`,
+    `eslint`, `prettier` — never through `make lint` or `script/test`, which are
+    themselves a `docker build` and would recurse into a daemon that does not
+    exist in a build step. Formatting is the exception and stays on the host:
+    `script/fmt` writes the working tree, and `script/fmt-check` is its
+    read-only twin.
+
+    **No lint verdict may come from a host invocation of the linter.** On a
+    shared host golangci-lint reads a result cache keyed on file content rather
+    than location, so a second checkout of the same content is served the first
+    one's findings, and a host-global lock in `$TMPDIR` makes concurrent runs
+    exit non-zero with `parallel golangci-lint is running` — a status a caller
+    cannot tell from real findings. Both have produced wrong verdicts in this
+    org, in both directions. A container has its own cache, its own `TMPDIR` and
+    a digest-pinned binary, so neither is reachable.
+
+- **Any build that runs checks is built with `--no-cache`.** Docker invalidates
+  a `COPY` layer only when the copied content changes, so on an unchanged tree
+  the check `RUN` is served from cache, nothing executes, and the build still
+  exits 0. Every `docker build` in `script/` therefore passes `--no-cache`:
+  `script/lint`, `script/test`, `script/cibuild` and `script/docker` are the
+  four, and there is no fifth — `script/check` runs the two gate phases and
+  `script/fmt-check`, and builds no image of its own. A bare `docker build .` is
+  not evidence that anything ran: a sub-second build reporting success is a
+  cache hit, not a result. Never invalidate by pruning — `docker builder prune`
+  and friends destroy a build cache shared with every other build on the host.
+  When a check is added or changed, prove it works by planting a defect it must
+  catch and watching the run fail on it, then revert the defect. A green run
+  alone shows neither that the check ran nor that it covers what it should.
+
+- **The gate phases are separate stages, and the build stage depends on both.**
+  The lint phase is based on the `golangci/golangci-lint` image (pinned by
+  hash), so lint failures surface in seconds rather than after a full compile,
+  and the test phase is based on the Debian Go image. The canonical Go repo
+  `Dockerfile`:
 
     ```dockerfile
-    # Lint stage — fast feedback on formatting and lint issues
+    # Lint phase
     # golangci/golangci-lint:v2.x.x, YYYY-MM-DD
     FROM golangci/golangci-lint@sha256:... AS lint
     WORKDIR /src
     COPY go.mod go.sum ./
     RUN go mod download
     COPY . .
-    RUN make fmt-check
-    RUN make lint
+    RUN golangci-lint run --config .golangci.yml ./...
 
-    # Build stage
-    # golang:1.x-alpine, YYYY-MM-DD
-    FROM golang@sha256:... AS builder
+    # Test phase. -race needs cgo and so a C compiler, which the Debian Go
+    # image ships and the alpine one does not.
+    # golang:1.x, YYYY-MM-DD
+    FROM golang@sha256:... AS test
     WORKDIR /src
-
-    # Force BuildKit to run the lint stage before proceeding
-    COPY --from=lint /src/go.sum /dev/null
-
     COPY go.mod go.sum ./
     RUN go mod download
     COPY . .
-    RUN make test
+    RUN go test -timeout 90s -race -cover ./... || \
+        { echo "--- Rerunning with -v for details ---"; \
+          go test -timeout 90s -race -v ./...; exit 1; }
 
-    ARG VERSION=dev
-    RUN CGO_ENABLED=0 go build -trimpath \
+    # Build stage. Nothing is wanted from either phase above; the copies
+    # are what make BuildKit build them first, so this stage cannot run
+    # unless lint and test passed.
+    # golang:1.x-alpine, YYYY-MM-DD
+    FROM golang@sha256:... AS builder
+    COPY --from=lint /src/go.sum /dev/null
+    COPY --from=test /src/go.sum /dev/null
+    RUN apk add --no-cache git
+    # A tar-stream context keeps the sender's file owners, which git refuses.
+    RUN git config --system --add safe.directory /src
+    WORKDIR /src
+    COPY go.mod go.sum ./
+    RUN go mod download
+    COPY . .
+
+    # The VERSION build arg when one is given, otherwise
+    # `git describe --tags --always` on the .git in the build context. With
+    # .git present, a version that is still empty, dev or unknown fails the
+    # build: git is missing or could not read the checkout.
+    ARG VERSION
+    RUN VERSION="${VERSION:-$(git describe --tags --always)}"; \
+        if [ -e .git ]; then \
+            case "$VERSION" in ""|dev|unknown) \
+                echo "version is '$VERSION' although .git is present" >&2; \
+                exit 1 ;; \
+            esac; \
+        fi; \
+        CGO_ENABLED=0 go build -trimpath \
             -ldflags="-s -w -X main.Version=${VERSION}" \
             -o /app ./cmd/app/
 
-    # Runtime stage
+    # Runtime stage, and the last one
     FROM alpine@sha256:...
     COPY --from=builder /app /usr/local/bin/app
     ENTRYPOINT ["app"]
     ```
 
     Key points:
-    - The lint stage uses the `golangci/golangci-lint` image directly (it
-      includes both Go and the linter), so there is no need to install the
-      linter separately.
-    - `COPY --from=lint /src/go.sum /dev/null` is a no-op file copy that creates
-      a stage dependency. BuildKit runs stages in parallel by default; without
-      this line, the build stage would not wait for lint to finish and a lint
-      failure might not fail the overall build.
+    - The lint phase uses the `golangci/golangci-lint` image directly (it has
+      both Go and the linter), so nothing needs installing.
+    - `COPY --from=<phase> /src/go.sum /dev/null` is a no-op copy whose only
+      purpose is the ordering edge. BuildKit runs stages in parallel by default,
+      and a stage nothing depends on is not built at all, so without these two
+      lines a red gate would not fail the build.
+    - Keep the runtime stage last, and if you add a stage after it, give it the
+      same two copies. A plain `docker build .` builds the last stage's chain
+      and nothing else.
     - If the project uses `//go:embed` directives that reference build artifacts
-      (e.g. a web frontend compiled in a separate stage), the lint stage must
+      (e.g. a web frontend compiled in a separate stage), the lint phase must
       create placeholder files so the embed directives resolve. Example:
       `RUN mkdir -p web/dist && touch web/dist/index.html web/dist/style.css`.
-      The lint stage should not depend on the actual build output — it exists to
-      fail fast.
-    - If the project requires CGO or system libraries for linting (e.g.
-      `vips-dev`), install them in the lint stage with `apk add`.
-    - The build stage runs `make test` after compilation setup. Tests run in the
-      build stage, not the lint stage, because they may require compiled
-      artifacts or heavier dependencies.
+    - If the project requires CGO or system libraries for linting, install them
+      in the lint phase. The `golangci/golangci-lint` image is Debian-based and
+      has no `apk`, so install with `apt-get` under the Debian package name
+      (`libvips-dev`, where alpine says `vips-dev`), and delete the package
+      lists in the same `RUN`, so the layer does not keep them:
+
+        ```dockerfile
+        RUN apt-get update \
+            && apt-get install -y --no-install-recommends libvips-dev \
+            && rm -rf /var/lib/apt/lists/*
+        ```
+
+    - `.dockerignore` lets `.git` into the build context. It keeps out every git
+      `config` at any depth (`**/.git/config`, `**/.git/modules/**/config`): the
+      repository's own, each submodule's under `.git/modules/`, and that of a
+      submodule keeping its own `.git` directory. `git describe` does not need
+      them, and each can hold a credential: a password in a remote URL, or the
+      token the CI checkout step stores there. A submodule whose name has a
+      `config` segment (`config`, `deploy/config`, `config/lib`) loses its whole
+      git directory to `**/.git/modules/**/config`, and Go's version stamping
+      then fails the build: give it a name without that segment
+      (`git submodule add --name`). The stage that compiles has `git` (the
+      Debian Go image has it; an alpine one needs `apk add --no-cache git`) and
+      takes the version from the `VERSION` build argument when one is given,
+      otherwise from `git describe --tags --always`. That gives the tag on a
+      tagged commit; on a later commit, the tag, the number of commits since it
+      and the short commit (`v1.2.3-4-gabc1234`); and the short commit when no
+      tag is reachable. The stage that compiles also marks its working directory
+      safe for git (`git config --system --add safe.directory /src`): a context
+      sent as a tar stream keeps the sender's file owners, and git refuses a
+      checkout owned by another user, so the version would come out empty.
+      `ARG VERSION` has no default, and the build fails if the context carries
+      `.git` and the version still comes out empty, `dev` or `unknown`. A plain
+      `docker build .` with no build arguments must succeed; a Dockerfile that
+      refuses an empty build argument drops that refusal and keeps the argument.
 
 - Every repo should have a Gitea Actions workflow (`.gitea/workflows/`) that
-  runs `script/cibuild` (which runs `docker build .`) on push. Since the
-  Dockerfile already runs `make check`, a successful build implies all checks
-  pass.
+  runs `script/cibuild` on push, and checks out the repo as its only other step.
+  That script bootstraps, runs the gate phases, and then builds the image, so a
+  successful run means every check passed; a bare `docker build .` does not
+  carry the same guarantee, because its gate phases may come from the cache. The
+  image build is uncached and so runs the gate phases a second time. That is the
+  price of the rule above, and it is worth paying: the image that ships is built
+  from a run of its own gates rather than from a cache entry. A separate
+  workflow limited to `main` by a `branches` list under `on: push` cannot be
+  checked by review: to try a change to it, add the feature branch to that list
+  and push, then remove the branch from the list again before merging. Keep any
+  job in it that publishes behind `if: github.ref_name == 'main'`, so the run
+  from the feature branch publishes nothing.
 
 - Use platform-standard formatters: `black` for Python, `prettier` for
   JS/CSS/Markdown/HTML, `go fmt` for Go. Always use default configuration with
@@ -189,14 +311,21 @@ style conventions are in separate documents:
   module under test to verify it compiles/parses. There is no excuse for
   `make test` to be a no-op.
 
-- `make test` must complete in under 20 seconds. Add a 30-second timeout in the
-  Makefile.
+- `make test` must complete in under 60 seconds. That is the hard cap, and a
+  suite that exceeds it fails. Under 20 seconds is the target. A suite between
+  20 and 60 seconds is still green, but the overage must be filed as an
+  improvement bug against that repo. Add a 90-second timeout to the test
+  invocation (`go test -timeout 90s`). The backstop deliberately sits above the
+  hard cap so that it catches a genuinely hung test rather than a merely slow
+  one.
 
-- **`make test` should use the conditional verbose rerun pattern.** Run tests
-  without `-v` (verbose) first. If tests fail, automatically rerun with `-v` to
-  show full output. This keeps CI logs and `docker build` output clean on
-  success (just package/suite summaries) while providing full diagnostic detail
-  on failure (every test case, every assertion). The general shell pattern:
+- **The test command should use the conditional verbose rerun pattern.** Run
+  tests without `-v` (verbose) first. If tests fail, automatically rerun with
+  `-v` to show full output. This keeps CI logs and `docker build` output clean
+  on success (just package/suite summaries) while providing full diagnostic
+  detail on failure (every test case, every assertion). The command lives in the
+  `test` phase of the `Dockerfile`, since `script/test` builds that phase; the
+  Makefile form below is the same pattern for any repo-local invocation:
 
     ```makefile
     test:
@@ -209,11 +338,26 @@ style conventions are in separate documents:
 
     ```makefile
     test:
-    	@go test -timeout 30s -race -cover ./... || \
+    	@go test -count=1 -timeout 90s -race -cover ./... || \
     		{ echo "--- Rerunning with -v for details ---"; \
-    		  go test -timeout 30s -race -v ./...; exit 1; }
+    		  go test -count=1 -timeout 90s -race -v ./...; exit 1; }
     ```
 
+    `-count=1` is required on both invocations: it defeats Go's test _result_
+    cache, so neither run can report a stored pass in place of running the
+    tests. It leaves the build cache alone, so it costs the runtime of the suite
+    and no recompilation.
+
+    That cache is Go's own, separate from Docker's layer cache. Go stores a
+    passing result in its cache directory (`GOCACHE`), and when the same tests
+    run again on unchanged code it prints that result, marked `(cached)`,
+    without running them. That matters on a developer's machine, where this
+    target runs and the directory lasts from one run to the next. The `test`
+    phase of the `Dockerfile` needs no `-count=1`: its base image holds no
+    result for this repo's tests and nothing before its `go test` step runs a
+    test, so there is nothing to replay. `--no-cache` (above) is what makes that
+    step run on an unchanged tree.
+
     Python example:
 
     ```makefile
@@ -239,10 +383,84 @@ style conventions are in separate documents:
   must be in `.gitignore`. No exceptions.
 
 - `.gitignore` should be comprehensive from the start: OS files (`.DS_Store`),
-  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.
+  editor files (`.swp`, `*~`), in-repo agent scratch directories (`.claude/`),
+  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. 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.
+
+- **`.dockerignore` does not use `.gitignore` semantics, and copying patterns
+  across unmodified leaves secrets in the build context.** Docker matches with
+  `moby/patternmatcher`: `filepath.Match` semantics plus a `**` extension, so
+  `*` 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, while `config/.env`
+  and `certs/server.key` still reach the context and can land in an image layer
+  — which is more dangerous than a short file with no secret patterns at all,
+  because it reads as solved and stops anyone looking. Give every
+  depth-independent pattern the `**/` prefix and leave only genuinely
+  root-anchored entries unprefixed: `.claude`, and the repo's own host-built
+  binary, written `/myapp` and never `**/myapp`, which would also match
+  `cmd/myapp/` and delete the package directory from the context. Matching is
+  case-sensitive, and an ALL-CAPS twin per pattern still misses `Server.Key`, so
+  secret names use character ranges — `**/*.[kK][eE][yY]`, `**/*.[pP][eE][mM]`,
+  and likewise for `.envrc` and the extensionless SSH keys. Where such a pattern
+  also catches something the build needs, re-include it with a negation
+  (`!docs/example.env`); deleting the pattern reopens the exposure for every
+  other file it covers. Fetch the standard `.dockerignore` from
+  `https://git.eeqj.de/sneak/prompts/raw/branch/main/.dockerignore` and extend
+  it with the repo's own artifacts.
+
+- **In-repo agent scratch belongs in both files, written to each file's own
+  semantics.** `.claude/` holds one worktree per in-flight agent — an entire
+  additional checkout of the repo — so under `COPY . .` the build context
+  inflates by a multiple of the repo and another session's unreviewed work can
+  be copied into an image layer. In `.gitignore` the entry is `.claude/`,
+  unanchored. In `.dockerignore` it is `.claude`, anchored and with **no** `**/`
+  prefix, because the prefixed form would also delete any nested directory of
+  that name from the build. Anchoring carries a known gap that the canonical
+  `.dockerignore` states in its own comment, since consuming repos receive the
+  file and not the tracker: the directory is created in the agent's working
+  directory, so a repo running agents in subdirectories still ships
+  `services/api/.claude/` and must add its own anchored entry there.
+
+- **A plain `docker build .` of a clone stamps the version that
+  `git describe --tags --always` gives**, derived from the `.git` in the build
+  context as the canonical `Dockerfile` above shows. Without its failure check,
+  a missing `git` or an unreadable checkout would leave `-X main.Version=` empty
+  and the build would still exit 0. `script/docker` and `script/cibuild` pass
+  the version they compute on the host; it takes precedence. They do this
+  byte-identically across repos:
+
+    ```sh
+    # Own line: a failing command substitution inside an argument does not
+    # trip `set -e`, so the inline form degrades to an empty constant.
+    version="$(git describe --tags --always --dirty 2>/dev/null || true)"
+    [ -n "$version" ] || version="unknown"
+    docker build --no-cache \
+        --build-arg VERSION="$version" \
+        -t "$(script/projectname)" .
+    ```
+
+    `--always` makes an untagged repo yield an abbreviated commit hash rather
+    than failing, and the `[ -n "$version" ]` line is the single place the
+    fallback is applied — a live check that fires on a build from an export with
+    no `.git` and on a repository with no commits yet. Do not fold it into the
+    substitution as `|| echo unknown`, which makes the guard unreachable. The
+    Dockerfile's side is `ARG VERSION` in the stage that compiles, declared
+    there because `ARG` is stage-scoped; passing `VERSION` to a repo whose
+    Dockerfile declares no such `ARG` is ignored and costs nothing, which is why
+    the scripts stay byte-identical. One consequence for CI: the standard
+    checkout action clones shallow and fetches no tags, so a repo that embeds a
+    tag-derived version must set `fetch-depth: 0` on its checkout step.
+
+- **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`). 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.
 
 - **No build artifacts in version control.** Code-derived data (compiled
   bundles, minified output, generated assets) must never be committed to the
@@ -258,9 +476,56 @@ style conventions are in separate documents:
 - Make all changes on a feature branch. You can do whatever you want on a
   feature branch.
 
-- `.golangci.yml` is standardized and must _NEVER_ be modified by an agent, only
-  manually by the user. Fetch from
-  `https://git.eeqj.de/sneak/prompts/raw/branch/main/.golangci.yml`.
+- `.golangci.yml` is standardized. The vendored copy in a consuming repo must
+  _NEVER_ be modified by an agent: fetch it from
+  `https://git.eeqj.de/sneak/prompts/raw/branch/main/.golangci.yml` and keep it
+  byte-identical, so that no repo can quietly loosen its own linting. Linter
+  configuration changes are made to the canonical copy in the `prompts` repo and
+  reach consuming repos by re-vendoring; an agent may open a PR against
+  canonical, which only the user merges. One list is exempt from byte-identity,
+  because it cannot be written once for every repo: the `deny` list of the
+  `test-support` depguard rule, where a repo names its own test-support packages
+  by full import path. A repo adds entries there and changes nothing else, and a
+  re-vendor carries its entries forward. The canonical golangci-lint version is
+  v2.14.0 (released 2026-09-24), pinned as the digest of the lint phase's base
+  image
+  (`golangci/golangci-lint@sha256:ad862ba6b3798cbe0fd9fd7408d498fd74fbd2623a92406b2fd3898faf0bf98f`,
+  which reports `2.14.0 built with go1.27.0 from 114493f9`). A module's `go`
+  directive must not name a newer Go minor version than the one golangci-lint
+  was built with, or golangci-lint refuses to lint it: this release lints
+  `go 1.27.1` but not `go 1.28`. That digest is the only pin, since no repo
+  installs golangci-lint on the host. A repo sets the lint phase digest to the
+  one named here and re-vendors `.golangci.yml` in the same commit, whichever of
+  the two prompted the change: the canonical copy can name linters that an older
+  golangci-lint rejects, and a newer golangci-lint can add linters that
+  `default: all` switches on until the canonical copy disables them.
+
+- **`script/bootstrap` installs a pinned tool by comparing versions, never by
+  testing presence.** An `if ! command -v <tool>; then install; fi` guard tests
+  `PATH` only, so on an already-provisioned machine the pin is inert and a
+  version bump is a silent no-op — while the Dockerfile, installing into a clean
+  image, gets the pinned version, so a local `make check` and `make docker` can
+  disagree about what the tool even is. The canonical form:
+    - compares the installed version against the pin over the **whole** version
+      token; a parser that stops at the first `-` reports `2.12.2` for a host
+      running `2.12.2-rc1` and skips the install;
+    - treats absent, non-zero, empty or unrecognised `--version` output as a
+      mismatch, so the failure direction is a redundant install and never a
+      skipped one;
+    - after installing, re-resolves the binary the way callers do — `hash -r`,
+      then through `PATH`, not through the directory the installer wrote to —
+      and fails naming the resolved path, since an install that a shadowing
+      binary hides succeeds while changing nothing any caller sees;
+    - is actually called, and prints the version on both success paths: a
+      function defined and never invoked has the same exit status and the same
+      empty output as one that worked.
+
+    Keep it POSIX sh: no arrays, no `[[`, no `grep -P`.
+
+    A Go tool a repo needs on the host is installed with `go install` pinned to
+    a commit hash (`go install <package>@<commit hash>`). It is never tracked as
+    a `go.mod` tool dependency or through a `tools.go` file, either of which
+    pulls the tool's own dependencies into the repo's `go.mod` and `go.sum`.
 
 - When pinning images or packages by hash, add a comment above the reference
   with the version and date (YYYY-MM-DD).
@@ -374,12 +639,14 @@ style conventions are in separate documents:
   settings.
 
 - Avoid putting files in the repo root unless necessary. Root should contain
-  only project-level config files (`README.md`, `Makefile`, `Dockerfile`,
-  `LICENSE`, `.gitignore`, `.editorconfig`, `REPO_POLICIES.md`, and
-  language-specific config). Everything else goes in a subdirectory. Canonical
-  subdirectory names:
+  only project-level config files (`README.md`, `AGENTS.md`, `Makefile`,
+  `Dockerfile`, `LICENSE`, `.gitignore`, `.editorconfig`, `REPO_POLICIES.md`,
+  and language-specific config). Everything else goes in a subdirectory.
+  Canonical subdirectory names:
     - `bin/` — executable scripts and tools
-    - `cmd/` — Go command entrypoints
+    - `cmd/` — Go command entrypoints; thin only: one `main.go` per binary whose
+      body is a single call into `internal/` or `pkg/`, no project logic in
+      `cmd/`
     - `configs/` — configuration templates and examples
     - `deploy/` — deployment manifests (k8s, compose, terraform)
     - `docs/` — documentation and markdown (README.md stays in root)
@@ -406,3 +673,7 @@ style conventions are in separate documents:
     - Go: `go.mod`, `go.sum`, `.golangci.yml`
     - JS: `package.json`, `yarn.lock`, `.prettierrc`, `.prettierignore`
     - Python: `pyproject.toml`
+
+- Guidance for coding agents lives in one `AGENTS.md` at the repository root. It
+  is never committed under a file or directory named after one agent tool, such
+  as `CLAUDE.md` or `.claude/`, and never split into separate memory files.

TODO.md

@@ -18,413 +18,535 @@ https://git.eeqj.de/sneak/secret/milestone/12
 
 # Completed Steps
 
-- 2026-10-04: Tests check which error a failure returns with `errors.Is`,
-  not by matching words of its message
-  (https://git.eeqj.de/sneak/secret/issues/49). Every exported error that
-  can be returned has a test that the function returns it, and errors
-  wrapping a cause are checked through the wrapping. Checks that still match
-  text, because the error has no exported value the test can name, are
-  listed on the issue.
+- 2026-10-12: A mnemonic typed with extra spaces, tabs or line breaks gives the
+  same long-term key as its words separated by single spaces
+  (https://git.eeqj.de/sneak/secret/issues/135). The key was derived from the
+  text exactly as typed, so a vault made with a double or trailing space did not
+  open with the same words typed normally. `agehd.DeriveEntropy`, which every
+  use of the mnemonic goes through, now joins the words with single spaces and
+  puts them in Unicode NFKD, as BIP39 defines, before making the seed.
+- 2026-10-12: The keychain and Secure Enclave unlockers are gone from the code
+  and the documents (https://git.eeqj.de/sneak/secret/issues/132). They were
+  research: neither works without macOS code signing and entitlements, which
+  `secret` does not have. The last commit that has them is `ef0ae90`, tagged
+  `v1.0.0-rc1`. `secret unlocker add` takes only `passphrase` and `pgp` on every
+  platform, `internal/macse` and those unlockers' files in `internal/secret` are
+  deleted, and `github.com/keybase/go-keychain` left `go.mod` and `go.sum`.
+  `secret` still builds and runs on macOS.
+- 2026-10-07: The part of `github.com/tyler-smith/go-bip39` v1.1.0 that `secret`
+  uses is copied into `internal/bip39`, with upstream's `LICENSE` beside it,
+  because its repository no longer exists
+  (https://git.eeqj.de/sneak/secret/issues/122). Every import moved there, and
+  the module left `go.mod` and `go.sum`. No derived key or mnemonic changes.
+- 2026-10-07: The canonical files are re-vendored from `sneak/prompts` commit
+  `dd4027b` (https://git.eeqj.de/sneak/secret/issues/121), with golangci-lint
+  v2.14.0 in the lint phase. Lint and test are phases of the `Dockerfile`, and
+  `script/lint` and `script/test` each build one with `--no-cache`;
+  `Dockerfile.lint` and `script/lint-darwin` are gone, and the lint phase runs
+  `go vet` and checks the macOS build too. The tests run on the Debian Go image
+  with cgo and the race detector, with the policy's 90-second timeout.
+  `script/cibuild` bootstraps, runs `script/check` and builds the image;
+  `CHECK_EPOCH` and the memlock ulimit are gone. `--no-cache` starts Go's build
+  cache mount empty, so `make test` compiles everything on every run. The rules
+  in `CLAUDE.md` that `AGENTS.md` lacked are in `AGENTS.md`, and `CLAUDE.md` is
+  deleted.
+- 2026-10-06: `script/test` runs the tests with the race detector, a 30-second
+  timeout per package and coverage, as `REPO_POLICIES.md` requires
+  (https://git.eeqj.de/sneak/secret/issues/32). When they fail, it reruns them
+  verbosely for the details and then fails anyway, so a test that fails once and
+  passes on the retry no longer gives a green build. `go vet` still runs first,
+  and every `go test` keeps `-count=1`. The tests that gave the `secret` binary
+  a minute now give it 10 seconds, and the PGP unlocker test's 30-second timer
+  is 10 seconds, so a test that hangs fails with its own message before the
+  package's 30-second timeout ends every test in it.
+- 2026-10-06: `make test` in `script/cibuild` no longer compiles the standard
+  library and every dependency from nothing on every build
+  (https://git.eeqj.de/sneak/secret/issues/124). The `Dockerfile` runs it and
+  `make build` with Go's build cache in a BuildKit cache mount, which docker
+  keeps between builds, so each compiles only what changed since the last build.
+  The mount has an id of its own, so other repositories' builds do not share it.
+  `script/test` passes `-count=1`, so every test runs on every build and no
+  result comes from Go's test cache. A build with an empty cache, such as the
+  first after docker's build cache is cleared, compiles everything in
+  `make test` as before.
+- 2026-10-06: `TestRemoveIgnoresTerminalOnStdout` and
+  `TestRemoveAsksAtTerminalOnStdin` no longer wait until Go's test timeout
+  (https://git.eeqj.de/sneak/secret/issues/126). On Linux, `pty.Open` of
+  `github.com/creack/pty` v1.1.24 passed the address of a local variable to the
+  `ioctl` system call as a plain number, through a function call; when Go moved
+  the goroutine's stack in between, the kernel wrote the terminal's number to
+  the old place, and `pty.Open` opened `/dev/pts/0` instead of the terminal it
+  had created. `secret rm` then wrote to that other terminal, and the test read
+  a terminal no program had open, which never ends. `go.mod` now requires the
+  commit on that library's main branch that passes a pointer instead; no release
+  has it yet. Both tests stop reading the terminal when their one-minute context
+  ends and fail saying so.
+- 2026-10-06: The tests run quickly with the race detector on
+  (https://git.eeqj.de/sneak/secret/issues/120). Most of their time went to
+  deriving keys from passphrases with scrypt, which is slow on purpose. The new
+  `secret.ScryptWorkFactor`, when not zero, replaces age's scrypt work factor
+  when a passphrase encrypts; the tests of `internal/secret`, `internal/vault`
+  and `internal/cli` set it to 1 before any test runs, and the program never
+  sets it; `TestGetCommandOutputsToStdout` checks that the passphrase unlocker
+  the built binary's `secret init` writes names age's work factor, 18.
+  `TestRemovalAsksWithoutHoldingLock` and `TestFailedCommandReleasesLock` no
+  longer run in parallel with other tests: each waits at most 10 seconds for the
+  in-memory lock that every test in the package shares, and other tests'
+  commands held it longer. `TestConcurrentAddsKeepEveryVersion`, which times
+  nothing, and `TestGetCommandOutputsToStdout`, which no longer sets an
+  environment variable its commands do not read, now run in parallel. The
+  `script/cibuild` comment no longer says that tests are skipped without its
+  memlock ulimit.
+- 2026-10-05: No test stores a secret larger than 1 MiB
+  (https://git.eeqj.de/sneak/secret/issues/52). The size tests for `secret add`,
+  `secret import` and the stdin buffer no longer try 2 MB, 10 MB, 99 MB, 100 MB
+  or 101 MB secrets, and nothing tests that a secret over the 100 MB limit is
+  rejected; the limit itself is unchanged. With nothing large left, the size
+  tests no longer skip a case for want of locked memory.
+- 2026-10-05: The Go module path is `sneak.berlin/go/secret`, as
+  `REPO_POLICIES.md` requires, not `git.eeqj.de/sneak/secret`
+  (https://git.eeqj.de/sneak/secret/issues/43). Every import uses it, as do the
+  `-X` flags in `script/build` that stamp the version and commit shown by
+  `secret info`, and the examples in `pkg/agehd/README.md` and
+  `pkg/bip85/README.md`. `go mod tidy` now lists `github.com/dustin/go-humanize`
+  and `github.com/fatih/color`, which `internal/cli` imports, as direct
+  requirements. Code that imported the old path must switch to the new one.
+- 2026-10-04: `make fmt` formats every markdown file with prettier (4-space
+  tabs, `proseWrap: always`) as well as the Go code, and `make fmt-check` checks
+  both, as the model scripts in the `prompts` repo do
+  (https://git.eeqj.de/sneak/secret/issues/110). Prettier is pinned by hash in
+  `package.json` and `yarn.lock`, and `script/bootstrap` installs node, yarn and
+  prettier. The `Dockerfile` lint stage copies node and yarn from a node image
+  pinned by hash and runs `script/bootstrap`, so its `make fmt-check` fails the
+  build on an unformatted markdown file. Every markdown file was formatted once,
+  wording unchanged.
+- 2026-10-04: A mnemonic that cannot be read, in `secret init` and
+  `secret vault create`, gives an error that names the mnemonic only
+  (https://git.eeqj.de/sneak/secret/issues/115). It is read with
+  `secret.ReadMnemonic`, whose every error wraps the new
+  `secret.ErrMnemonicNotRead`; before, it was read with `ReadPassphrase`, so the
+  message said "failed to read mnemonic: failed to read passphrase:" and advised
+  setting `SB_UNLOCK_PASSPHRASE`. Without a terminal it now says "failed to read
+  mnemonic: stdin is not a terminal (piped input or script). Please set the
+  SB_SECRET_MNEMONIC environment variable or run interactively". The passphrase
+  messages no longer repeat "cannot read passphrase" after "failed to read
+  passphrase:", and empty input gives "nothing was entered".
+- 2026-10-04: A failure returns the same error value whichever command hits it
+  (https://git.eeqj.de/sneak/secret/issues/113). `internal/cli` no longer keeps
+  its own copies of `vault.ErrSecretNotFound`, `ErrVaultNotFound`,
+  `ErrVersionNotFound` and `ErrSecretExists`: `secret mv`, `rm`, `decrypt`,
+  `vault import`, `vault remove` and `version list`, `promote` and `rm` wrap the
+  `vault` errors. `errUnsupportedUnlockerType` is removed: `secret unlocker add`
+  gives `errInvalidUnlockerType` for an unknown type, whichever check rejects
+  it. Off macOS, adding a keychain or Secure Enclave unlocker returns the
+  `secret` package's error for it, not an `internal/cli` copy; on macOS, the
+  check that the system is macOS is gone, as it could never fail.
+  `secret vault import` gives `errInvalidMnemonicPhrase` for an invalid
+  mnemonic, as `init` and `vault create` do. `secret generate secret` gives
+  `errLengthTooSmall` for a length below 1 wherever it is checked, and
+  `errUnsupportedSecretType` for `--type mnemonic` too. `secret import` of a
+  file over 100MB wraps `errSecretTooLarge`, as `secret add` returns it.
+  `vault.ErrNilValueBuffer` is replaced by `secret.ErrNilValueBuffer`, which
+  `secret` already returned under another name. Messages are unchanged, except
+  that `secret decrypt` of a missing secret says "not found", as `secret get`
+  does, not "does not exist"; `vault import` of an invalid mnemonic says
+  "invalid BIP39 mnemonic phrase"; `--type mnemonic` says "unsupported type:
+  mnemonic (use 'secret generate mnemonic' instead)"; and a file too large to
+  import says
+  `failed to read secret from file <path>: secret too large: exceeds 100MB limit`.
+  Every error of `secret.ReadPassphrase` wraps `secret.ErrPassphraseNotRead`,
+  which supplies the words "failed to read passphrase" that its callers used to
+  add themselves; so two passphrases that differ now give only "passphrases do
+  not match", the words now follow "failed to read mnemonic:" and "failed to
+  read passphrase confirmation:", and a terminal read error no longer repeats
+  them. A GPG key the keyring does not hold gives `secret.ErrGPGKeyNotFound`,
+  found by gpg's status line for "No public key"; before, the message repeated
+  "failed to resolve GPG key fingerprint" and ended in gpg's exit status. The
+  keychain unlocker returns `errNilDataBuffer` for nil data; this and its test
+  build only on macOS with cgo and were only read. `bip85.ErrPasswordTooShort`
+  and `ErrEncodedTooShort` are removed with their checks: 64 bytes of entropy
+  always give 86 Base64 or 80 Base85 characters, the most a password length may
+  ask for. Tests that matched these errors' text use `errors.Is`.
+- 2026-10-04: Tests check which error a failure returns with `errors.Is`, not by
+  matching words of its message (https://git.eeqj.de/sneak/secret/issues/49).
+  Every exported error that can be returned has a test that the function returns
+  it, and errors wrapping a cause are checked through the wrapping. Checks that
+  still match text, because the error has no exported value the test can name,
+  are listed on the issue.
 - 2026-10-04: When a vault cannot be opened through its current unlocker,
-  because a file the unlocker needs is missing or damaged, its keychain item
-  or Secure Enclave key is gone, or the passphrase is wrong, the error now
-  ends by naming the vault, saying that it still opens with its mnemonic,
-  and that `secret unlocker add passphrase`, run with `SB_SECRET_MNEMONIC`
-  set to it, gives the vault a new unlocker; for a vault that is not the
-  current one, as in `secret move` between vaults, it says to run
-  `secret vault select` first (https://git.eeqj.de/sneak/secret/issues/47).
-  Before, it ended with the bare cause. The advice is given only when the
-  vault metadata records the key the mnemonic derives, so not for a vault
-  created without a mnemonic, and not when the passphrase could not be read
-  at all. `secret vault import` is not named: it refuses a vault that has a
-  long-term key. `secret encrypt` and `secret decrypt` now read the key
-  secret through `vault.GetSecret`, as `secret get` does, so they give the
-  same advice; `Secret.GetValue`, the other way to get the long-term key, is
-  removed. When a secret's `current` file cannot be read, the error says
-  that `secret version list` lists its versions and `secret version promote`
-  makes one current. The causes stay wrapped.
-- 2026-10-04: An unlocker's ID is the name of its directory in `unlockers.d`,
-  so no two unlockers of a vault share one
+  because a file the unlocker needs is missing or damaged, its keychain item or
+  Secure Enclave key is gone, or the passphrase is wrong, the error now ends by
+  naming the vault, saying that it still opens with its mnemonic, and that
+  `secret unlocker add passphrase`, run with `SB_SECRET_MNEMONIC` set to it,
+  gives the vault a new unlocker; for a vault that is not the current one, as in
+  `secret move` between vaults, it says to run `secret vault select` first
+  (https://git.eeqj.de/sneak/secret/issues/47). Before, it ended with the bare
+  cause. The advice is given only when the vault metadata records the key the
+  mnemonic derives, so not for a vault created without a mnemonic, and not when
+  the passphrase could not be read at all. `secret vault import` is not named:
+  it refuses a vault that has a long-term key. `secret encrypt` and
+  `secret decrypt` now read the key secret through `vault.GetSecret`, as
+  `secret get` does, so they give the same advice; `Secret.GetValue`, the other
+  way to get the long-term key, is removed. When a secret's `current` file
+  cannot be read, the error says that `secret version list` lists its versions
+  and `secret version promote` makes one current. The causes stay wrapped.
+- 2026-10-04: An unlocker's ID is the name of its directory in `unlockers.d`, so
+  no two unlockers of a vault share one
   (https://git.eeqj.de/sneak/secret/issues/98). Before, a keychain or Secure
   Enclave unlocker's ID was its creation time to the minute and the host name,
   and a passphrase unlocker's the time to the minute, so two created within a
   minute shared an ID, and `unlocker select`, `unlocker remove` and the
-  selection `unlocker add` makes acted on the older one. A PGP unlocker's ID
-  was `pgp-` and its key's fingerprint; a second PGP unlocker for a key is
-  still refused, now by comparing the fingerprint in the other unlockers'
-  metadata. `unlocker list` and the shell completion of `unlocker select` and
-  `unlocker remove` take each ID from the directory the unlocker was read
-  from, no longer by matching metadata, so two unlockers with the same
-  metadata are listed apart; an unlocker of an unknown type is listed under
-  its directory name, and completion now offers Secure Enclave unlockers too.
-  The keychain and Secure Enclave code was type-checked by
-  `script/lint-darwin`, never run; a test on Linux lists, completes, selects
-  and removes each of two passphrase unlockers with the same metadata by its
-  own ID.
-- 2026-10-04: README's Storage Architecture, `secret version promote`,
-  Technical Details and Testing text matches the code
-  (https://git.eeqj.de/sneak/secret/issues/102). `current` and
-  `currentvault` are plain files holding a name, not symbolic links; a
-  version's metadata is the encrypted `metadata.age`; the state directory is
-  `berlin.sneak.pkg.secret` in the user's configuration directory, not
-  `~/.local/share/secret`, and holds the `lock` file. Also corrected: the
-  code sets up no Touch ID for the keychain or Secure Enclave unlocker, and
-  the Secure Enclave only decrypts; per-version keys give no forward
-  secrecy; `pub.age` is not age-encrypted; vault metadata holds no vault
-  name. Testing lists only `make test`.
+  selection `unlocker add` makes acted on the older one. A PGP unlocker's ID was
+  `pgp-` and its key's fingerprint; a second PGP unlocker for a key is still
+  refused, now by comparing the fingerprint in the other unlockers' metadata.
+  `unlocker list` and the shell completion of `unlocker select` and
+  `unlocker remove` take each ID from the directory the unlocker was read from,
+  no longer by matching metadata, so two unlockers with the same metadata are
+  listed apart; an unlocker of an unknown type is listed under its directory
+  name, and completion now offers Secure Enclave unlockers too. The keychain and
+  Secure Enclave code was type-checked by `script/lint-darwin`, never run; a
+  test on Linux lists, completes, selects and removes each of two passphrase
+  unlockers with the same metadata by its own ID.
+- 2026-10-04: README's Storage Architecture, `secret version promote`, Technical
+  Details and Testing text matches the code
+  (https://git.eeqj.de/sneak/secret/issues/102). `current` and `currentvault`
+  are plain files holding a name, not symbolic links; a version's metadata is
+  the encrypted `metadata.age`; the state directory is `berlin.sneak.pkg.secret`
+  in the user's configuration directory, not `~/.local/share/secret`, and holds
+  the `lock` file. Also corrected: the code sets up no Touch ID for the keychain
+  or Secure Enclave unlocker, and the Secure Enclave only decrypts; per-version
+  keys give no forward secrecy; `pub.age` is not age-encrypted; vault metadata
+  holds no vault name. Testing lists only `make test`.
 - 2026-10-04: `secret init` and `secret vault create` create a vault whole or
-  not at all (https://git.eeqj.de/sneak/secret/issues/105).
-  `vault.CreateVault` now takes the unlocker passphrase too, writes the vault
-  directory with its metadata, long-term public key and passphrase unlocker,
-  `longterm.age` included, into a temporary directory, renames that into
-  `vaults.d` once it is complete, and only then makes the vault current.
-  Before, either command killed after the passphrase prompt but before the
-  unlocker was written left a vault with no unlocker, which `vault create` had
-  already made current and which neither command would create again. Killed
-  part-way now, it leaves no vault, and the next command that takes the lock
-  deletes the temporary directory; or, killed between the rename and making
-  the vault current, a complete vault that is not current, which
-  `secret vault select` makes current.
+  not at all (https://git.eeqj.de/sneak/secret/issues/105). `vault.CreateVault`
+  now takes the unlocker passphrase too, writes the vault directory with its
+  metadata, long-term public key and passphrase unlocker, `longterm.age`
+  included, into a temporary directory, renames that into `vaults.d` once it is
+  complete, and only then makes the vault current. Before, either command killed
+  after the passphrase prompt but before the unlocker was written left a vault
+  with no unlocker, which `vault create` had already made current and which
+  neither command would create again. Killed part-way now, it leaves no vault,
+  and the next command that takes the lock deletes the temporary directory; or,
+  killed between the rename and making the vault current, a complete vault that
+  is not current, which `secret vault select` makes current.
 - 2026-10-04: A failed `secret unlocker add keychain` or
   `secret unlocker add secure-enclave` no longer leaves its keychain item or
   Secure Enclave key behind (https://git.eeqj.de/sneak/secret/issues/89).
   `CreateSecureEnclaveUnlocker` gets the long-term key before it creates the
   Secure Enclave key, so that a wrong passphrase creates none, and deletes the
   key again if encrypting with it or writing the unlocker then fails.
-  `macse.CreateKey` finds the new key's hash right after `sc_auth` creates
-  it, and fails with an error naming the key's label if it cannot; it deletes
-  the key again if getting its public key then fails. The Objective-C was only
-  read, never compiled or run, and so was `macse_darwin.go`, which is cgo only.
+  `macse.CreateKey` finds the new key's hash right after `sc_auth` creates it,
+  and fails with an error naming the key's label if it cannot; it deletes the
+  key again if getting its public key then fails. The Objective-C was only read,
+  never compiled or run, and so was `macse_darwin.go`, which is cgo only.
   `CreateKeychainUnlocker` writes all of the unlocker's files, the metadata
   among them, before it stores the item in the keychain, and deletes the item
   again if moving the unlocker into place then fails. A failure to delete is
-  reported along with the first error. The tests of this run only on macOS:
-  the Secure Enclave one in a build with cgo on a Mac with a Secure Enclave,
-  the keychain one in a build with cgo.
+  reported along with the first error. The tests of this run only on macOS: the
+  Secure Enclave one in a build with cgo on a Mac with a Secure Enclave, the
+  keychain one in a build with cgo.
 - 2026-10-04: What a command killed part-way left under a `.tmp-` name
-  (https://git.eeqj.de/sneak/secret/issues/75), the temporary directories
-  of `secret.TempDirFor` and the temporary files of
-  `secret.WriteFileAtomic`, encrypted keys included, is deleted by the next
-  command that takes the state directory lock. Before, it stayed until
-  deleted by hand. A command writes `finished` into the lock file just
-  before it releases the lock; the next one to take the lock searches only
-  when it does not find that, so after a command that finished nothing is
-  searched, however many secrets and versions there are. The search looks
-  in the state directory, each vault, each secret and each version, the
-  only directories those helpers make them in. A command that only reads
-  takes no lock and deletes nothing. A failure to delete is warned about
+  (https://git.eeqj.de/sneak/secret/issues/75), the temporary directories of
+  `secret.TempDirFor` and the temporary files of `secret.WriteFileAtomic`,
+  encrypted keys included, is deleted by the next command that takes the state
+  directory lock. Before, it stayed until deleted by hand. A command writes
+  `finished` into the lock file just before it releases the lock; the next one
+  to take the lock searches only when it does not find that, so after a command
+  that finished nothing is searched, however many secrets and versions there
+  are. The search looks in the state directory, each vault, each secret and each
+  version, the only directories those helpers make them in. A command that only
+  reads takes no lock and deletes nothing. A failure to delete is warned about
   and the command goes on. An unlocker directory with no metadata file was
-  already removed by `secret unlocker remove` given its directory name; a
-  test now shows it.
-- 2026-10-04: An age identity's private key goes into a locked buffer
-  through `secret.IdentityToLockedBuffer` everywhere
-  (https://git.eeqj.de/sneak/secret/issues/38): the vault's long-term key
-  when a passphrase, PGP, keychain or Secure Enclave unlocker is created,
-  the new unlocker's own key, a new secret version's key, and the key
-  `secret encrypt` generates. Before, each place converted the string age
-  returns to bytes and left the string in ordinary memory. The function
-  moves the string's own bytes into the buffer, which overwrites them; the
-  copies age makes while writing the string remain, as its comment says.
-  The 1.0 memory-security entry below no longer lists these places,
-  `internal/cli/crypto.go` among them, nor `version.go:155`, which was
-  `internal/secret/version.go`, not `internal/cli/version.go`.
+  already removed by `secret unlocker remove` given its directory name; a test
+  now shows it.
+- 2026-10-04: An age identity's private key goes into a locked buffer through
+  `secret.IdentityToLockedBuffer` everywhere
+  (https://git.eeqj.de/sneak/secret/issues/38): the vault's long-term key when a
+  passphrase, PGP, keychain or Secure Enclave unlocker is created, the new
+  unlocker's own key, a new secret version's key, and the key `secret encrypt`
+  generates. Before, each place converted the string age returns to bytes and
+  left the string in ordinary memory. The function moves the string's own bytes
+  into the buffer, which overwrites them; the copies age makes while writing the
+  string remain, as its comment says. The 1.0 memory-security entry below no
+  longer lists these places, `internal/cli/crypto.go` among them, nor
+  `version.go:155`, which was `internal/secret/version.go`, not
+  `internal/cli/version.go`.
 - 2026-10-04: `script/lint-darwin` (`make lint-darwin`) runs `go vet` and
   `golangci-lint` in docker on the code as a macOS build compiles it
-  (`GOOS=darwin`), with cgo off
-  (https://git.eeqj.de/sneak/secret/issues/50). `script/check` runs it, and
-  the `Dockerfile` lint stage runs its commands, so `script/cibuild` does too.
-  Before, CI on Linux never compiled the files built only for macOS. Compiling
-  cgo code for macOS needs Apple's SDK headers, and both `internal/macse` and
-  `github.com/keybase/go-keychain` are cgo on macOS. So the three functions
-  that call `go-keychain` moved from `keychainunlocker.go` to
-  `keychainunlocker_cgo.go`, built only with cgo on macOS like
-  `macse_darwin.go`. A macOS build without cgo, which before did not compile,
-  gets `keychainunlocker_nocgo.go` and the `macse` stub instead, whose errors
-  say the keychain or Secure Enclave needs a macOS build with cgo. The check
-  covers the rest of the keychain unlocker, the Secure Enclave unlocker and
-  the macOS-only tests other than `keychainunlocker_test.go`, whose lint
+  (`GOOS=darwin`), with cgo off (https://git.eeqj.de/sneak/secret/issues/50).
+  `script/check` runs it, and the `Dockerfile` lint stage runs its commands, so
+  `script/cibuild` does too. Before, CI on Linux never compiled the files built
+  only for macOS. Compiling cgo code for macOS needs Apple's SDK headers, and
+  both `internal/macse` and `github.com/keybase/go-keychain` are cgo on macOS.
+  So the three functions that call `go-keychain` moved from
+  `keychainunlocker.go` to `keychainunlocker_cgo.go`, built only with cgo on
+  macOS like `macse_darwin.go`. A macOS build without cgo, which before did not
+  compile, gets `keychainunlocker_nocgo.go` and the `macse` stub instead, whose
+  errors say the keychain or Secure Enclave needs a macOS build with cgo. The
+  check covers the rest of the keychain unlocker, the Secure Enclave unlocker
+  and the macOS-only tests other than `keychainunlocker_test.go`, whose lint
   findings are fixed. For the length and complexity limits, parts of
-  `GetIdentity`, `getLongTermPrivateKey` and `CreateKeychainUnlocker` moved
-  into functions of their own, and the Secure Enclave unlocker derives the
-  long-term key from the mnemonic through the same function as the keychain
-  unlocker instead of a copy of it. Lines over 88 columns in the files the
-  check cannot see are wrapped.
+  `GetIdentity`, `getLongTermPrivateKey` and `CreateKeychainUnlocker` moved into
+  functions of their own, and the Secure Enclave unlocker derives the long-term
+  key from the mnemonic through the same function as the keychain unlocker
+  instead of a copy of it. Lines over 88 columns in the files the check cannot
+  see are wrapped.
 - 2026-10-04: `secret rm`, `secret version rm`, `secret vault remove` and
   `secret unlocker remove` ask `[y/N]` before removing anything
   (https://git.eeqj.de/sneak/secret/issues/39), naming what they remove: the
   secret, its vault and its version count; the version, secret and vault; the
   vault and its secret count; the unlocker, its vault and whether it is the
-  last, and for the last the vault's secret count and that the vault then
-  opens only with its mnemonic. Only `y` or `yes` goes ahead. Without
-  `--force`, a command whose stdin is not a terminal fails at once. `--force`
-  (now also on `rm` and `version rm`) removes without asking; it replaces the
-  old refusals to remove a vault with secrets or the last unlocker of one
-  without `--force`, which the question now covers. The checks run, and the
-  question is asked, before the state directory lock is taken; under the
-  lock the checks run again, and if they would ask a different question,
-  nothing is removed. `secret rm` fails when it cannot count the versions.
+  last, and for the last the vault's secret count and that the vault then opens
+  only with its mnemonic. Only `y` or `yes` goes ahead. Without `--force`, a
+  command whose stdin is not a terminal fails at once. `--force` (now also on
+  `rm` and `version rm`) removes without asking; it replaces the old refusals to
+  remove a vault with secrets or the last unlocker of one without `--force`,
+  which the question now covers. The checks run, and the question is asked,
+  before the state directory lock is taken; under the lock the checks run again,
+  and if they would ask a different question, nothing is removed. `secret rm`
+  fails when it cannot count the versions.
 - 2026-10-04: A crash while an unlocker is being replaced no longer leaves a
   current unlocker that cannot open the vault
   (https://git.eeqj.de/sneak/secret/issues/71). Every new unlocker gets a
   directory of its own, named with the time to the nanosecond:
-  `passphrase-<time>`, `<host>-pgp-<time>`, and for a keychain or Secure
-  Enclave unlocker the keychain item or Secure Enclave key, which names the
-  directory, carries the time instead of the day. `secret.WriteDir` fails on a
-  directory that exists instead of writing into it. `unlocker add passphrase`
-  writes the new unlocker, makes it current, and only then removes the vault's
-  other passphrase unlockers; a crash between the last two steps leaves the old
-  one beside the new, and the old passphrase still opens the vault through it
-  until the next `unlocker add passphrase` or an `unlocker remove` removes it.
-  A PGP, keychain or Secure Enclave unlocker added on the same host and day as
-  another of its type is added beside it instead of replacing it.
-- 2026-10-04: `SB_SECRET_MNEMONIC` and `SB_UNLOCK_PASSPHRASE` are read once
-  per command, in its `RunE`, into locked buffers on the CLI `Instance`, and
-  unset at once, so that no program the command runs, `gpg` included,
-  inherits them (https://git.eeqj.de/sneak/secret/issues/60). Nothing below
-  the command reads the environment; the buffers are passed down:
-  `vault.CreateVault` takes the mnemonic (nil for none), a `Vault` derives its
-  long-term key from its `Mnemonic` and gives its `UnlockPassphrase` to a
-  passphrase unlocker, and the PGP, keychain and Secure Enclave unlocker
-  constructors take both. `CreatePGPUnlocker` sets both on the vault it
-  loads, through `SetMnemonic` and `SetUnlockPassphrase`, now part of
-  `VaultInterface`, before calling its `GetOrDeriveLongTermKey`. `init` and
-  `vault create` no longer put the mnemonic into the environment. Unsetting
-  erases nothing: the starting environment (`/proc/<pid>/environ`) and
-  memory still hold the value. The README warns against both variables.
-- 2026-10-04: `.golangci.yml` is again the canonical file from
-  `sneak/prompts`, byte for byte
-  (https://git.eeqj.de/sneak/secret/issues/66). It runs `gomodguard_v2`
-  in place of the deprecated `gomodguard`, so the lint no longer warns,
-  and enables `depguard` with a rule that keeps `net/http/httptest` out of
-  non-test files. Neither raised a finding in this repo.
+  `passphrase-<time>`, `<host>-pgp-<time>`, and for a keychain or Secure Enclave
+  unlocker the keychain item or Secure Enclave key, which names the directory,
+  carries the time instead of the day. `secret.WriteDir` fails on a directory
+  that exists instead of writing into it. `unlocker add passphrase` writes the
+  new unlocker, makes it current, and only then removes the vault's other
+  passphrase unlockers; a crash between the last two steps leaves the old one
+  beside the new, and the old passphrase still opens the vault through it until
+  the next `unlocker add passphrase` or an `unlocker remove` removes it. A PGP,
+  keychain or Secure Enclave unlocker added on the same host and day as another
+  of its type is added beside it instead of replacing it.
+- 2026-10-04: `SB_SECRET_MNEMONIC` and `SB_UNLOCK_PASSPHRASE` are read once per
+  command, in its `RunE`, into locked buffers on the CLI `Instance`, and unset
+  at once, so that no program the command runs, `gpg` included, inherits them
+  (https://git.eeqj.de/sneak/secret/issues/60). Nothing below the command reads
+  the environment; the buffers are passed down: `vault.CreateVault` takes the
+  mnemonic (nil for none), a `Vault` derives its long-term key from its
+  `Mnemonic` and gives its `UnlockPassphrase` to a passphrase unlocker, and the
+  PGP, keychain and Secure Enclave unlocker constructors take both.
+  `CreatePGPUnlocker` sets both on the vault it loads, through `SetMnemonic` and
+  `SetUnlockPassphrase`, now part of `VaultInterface`, before calling its
+  `GetOrDeriveLongTermKey`. `init` and `vault create` no longer put the mnemonic
+  into the environment. Unsetting erases nothing: the starting environment
+  (`/proc/<pid>/environ`) and memory still hold the value. The README warns
+  against both variables.
+- 2026-10-04: `.golangci.yml` is again the canonical file from `sneak/prompts`,
+  byte for byte (https://git.eeqj.de/sneak/secret/issues/66). It runs
+  `gomodguard_v2` in place of the deprecated `gomodguard`, so the lint no longer
+  warns, and enables `depguard` with a rule that keeps `net/http/httptest` out
+  of non-test files. Neither raised a finding in this repo.
 - 2026-10-04: `secret unlocker add pgp` works on Linux
-  (https://git.eeqj.de/sneak/secret/issues/88). `CreatePGPUnlocker` gets
-  the vault's long-term key as adding a passphrase unlocker does, with the
-  vault's `GetOrDeriveLongTermKey`, now part of `VaultInterface`: from the
-  mnemonic, checked against the vault, or else from the current unlocker.
-  Before, it used the keychain unlocker's helper, which on every platform
-  but macOS always failed. A test adds a PGP unlocker for a throwaway GPG
-  key, getting the long-term key once from the mnemonic and once from a
-  passphrase unlocker, and reads a secret through the new unlocker.
-- 2026-10-04: A vault name may use only lowercase ASCII letters, digits,
-  `.`, `-` and `_`, and must not be empty, `.` or `..`
-  (https://git.eeqj.de/sneak/secret/issues/68); the error and `README.md`
-  state the rule. `vault create`, `vault import`, `vault select`,
-  `vault remove`, both vault names of `mv` and shell completion of a
-  `vault:secret` argument check the name as typed with
-  `vault.ValidateVaultName` before building any path from it. Before,
-  `vault import ..` wrote a long-term key and an unlocker into the state
-  directory itself, and `vault select ..` made that the current vault.
-- 2026-10-04: `script/cibuild` runs the checks again on an unchanged
-  tree (https://git.eeqj.de/sneak/secret/issues/54). It passes the
-  current time as the `CHECK_EPOCH` build argument, which both the lint
-  and the build stage of the `Dockerfile` declare after their module
-  download, so the `RUN` steps below the argument run again on each
-  build while the base images and module downloads stay cached. Before,
-  a second run on the same tree took every check from the build cache
-  and reported success having run nothing.
+  (https://git.eeqj.de/sneak/secret/issues/88). `CreatePGPUnlocker` gets the
+  vault's long-term key as adding a passphrase unlocker does, with the vault's
+  `GetOrDeriveLongTermKey`, now part of `VaultInterface`: from the mnemonic,
+  checked against the vault, or else from the current unlocker. Before, it used
+  the keychain unlocker's helper, which on every platform but macOS always
+  failed. A test adds a PGP unlocker for a throwaway GPG key, getting the
+  long-term key once from the mnemonic and once from a passphrase unlocker, and
+  reads a secret through the new unlocker.
+- 2026-10-04: A vault name may use only lowercase ASCII letters, digits, `.`,
+  `-` and `_`, and must not be empty, `.` or `..`
+  (https://git.eeqj.de/sneak/secret/issues/68); the error and `README.md` state
+  the rule. `vault create`, `vault import`, `vault select`, `vault remove`, both
+  vault names of `mv` and shell completion of a `vault:secret` argument check
+  the name as typed with `vault.ValidateVaultName` before building any path from
+  it. Before, `vault import ..` wrote a long-term key and an unlocker into the
+  state directory itself, and `vault select ..` made that the current vault.
+- 2026-10-04: `script/cibuild` runs the checks again on an unchanged tree
+  (https://git.eeqj.de/sneak/secret/issues/54). It passes the current time as
+  the `CHECK_EPOCH` build argument, which both the lint and the build stage of
+  the `Dockerfile` declare after their module download, so the `RUN` steps below
+  the argument run again on each build while the base images and module
+  downloads stay cached. Before, a second run on the same tree took every check
+  from the build cache and reported success having run nothing.
 - 2026-10-04: A failed unlocker add no longer leaves a partial unlocker
   directory (https://git.eeqj.de/sneak/secret/issues/48).
-  `secret unlocker add pgp` resolves the GPG key's fingerprint once, for
-  its duplicate check, and passes it to `CreatePGPUnlocker` to record.
-  `CreatePGPUnlocker` and `CreateKeychainUnlocker` get the long-term key
-  and encrypt everything before writing anything. All four unlocker
-  types write their files through `secret.WriteDir`: a new unlocker is
-  built in a temporary directory, renamed into place when complete and
-  removed on a failure.
-- 2026-10-04: `secret unlocker select` and `secret unlocker remove`
-  skip, with the warning `unlocker list` gives, an unlocker directory
-  whose metadata file cannot be checked for, read or parsed, instead of
-  failing when it sorts before the unlocker asked for. Such a directory,
-  or one without a metadata file, is removed by its directory name, the
-  name the warning gives; only the directory is removed, since its type
-  is unknown. Removing one whose metadata file is missing or corrupt
-  never counts as removing the last unlocker. Removing one whose metadata
-  file cannot be checked for or read always does, since it may be the
-  only working unlocker, so in a vault with secrets it needs `--force`.
-- 2026-10-04: A failed command prints its error once, without the usage
-  text after it (https://git.eeqj.de/sneak/secret/issues/41). Usage is
-  still printed for a command called wrongly: wrong number of arguments,
-  unknown flag, bad flag value, missing required flag, or flags that
-  break a flag group (mutually exclusive, required together, one
-  required). The root command's `PersistentPreRunE` turns usage off.
-  Cobra checks arguments and flag values before that hook but required
-  flags and flag groups only after it, so the hook checks those two
-  first. Root `SilenceUsage` would have hidden usage for all of these.
-- 2026-10-04: `secret get` keeps the secret in locked memory until it
-  writes it out (https://git.eeqj.de/sneak/secret/issues/37):
-  `Vault.GetSecret` and `Vault.GetSecretVersion` return a
-  `*memguard.LockedBuffer`, which every caller destroys, and `secret get`
-  writes its bytes straight to stdout, still with no trailing newline.
-  Before, the value was copied into ordinary memory that nothing wiped,
-  and `get --version` also wrote it to the debug log.
-- 2026-10-04: The `Makefile` no longer sets `DOCKER_HOST`, so its docker
-  targets use the local docker daemon, or whatever `DOCKER_HOST` the
-  environment sets. `make build` calls the new `script/build`, which
-  stamps the version (`VERSION` from the environment, else
-  `git describe`) and the git commit as before. `build`, `clean`,
-  `install` and `docker-run` are in `.PHONY`; `make install` depends on
-  `build`. The `vet` target is gone: `script/test` runs `go vet` first.
-- 2026-10-04: `.gitignore` is the org's standard file, which ignores
-  `.env`, `.env.*`, `*.pem` and `*.key` and editor and OS files, plus
-  this repo's `/secret`, `*.log`, `*.test` and `settings.local.json`
-  (https://git.eeqj.de/sneak/secret/issues/40). `.dockerignore` also
-  leaves out `node_modules`; `.git` stays in the build context for the
-  version stamp.
+  `secret unlocker add pgp` resolves the GPG key's fingerprint once, for its
+  duplicate check, and passes it to `CreatePGPUnlocker` to record.
+  `CreatePGPUnlocker` and `CreateKeychainUnlocker` get the long-term key and
+  encrypt everything before writing anything. All four unlocker types write
+  their files through `secret.WriteDir`: a new unlocker is built in a temporary
+  directory, renamed into place when complete and removed on a failure.
+- 2026-10-04: `secret unlocker select` and `secret unlocker remove` skip, with
+  the warning `unlocker list` gives, an unlocker directory whose metadata file
+  cannot be checked for, read or parsed, instead of failing when it sorts before
+  the unlocker asked for. Such a directory, or one without a metadata file, is
+  removed by its directory name, the name the warning gives; only the directory
+  is removed, since its type is unknown. Removing one whose metadata file is
+  missing or corrupt never counts as removing the last unlocker. Removing one
+  whose metadata file cannot be checked for or read always does, since it may be
+  the only working unlocker, so in a vault with secrets it needs `--force`.
+- 2026-10-04: A failed command prints its error once, without the usage text
+  after it (https://git.eeqj.de/sneak/secret/issues/41). Usage is still printed
+  for a command called wrongly: wrong number of arguments, unknown flag, bad
+  flag value, missing required flag, or flags that break a flag group (mutually
+  exclusive, required together, one required). The root command's
+  `PersistentPreRunE` turns usage off. Cobra checks arguments and flag values
+  before that hook but required flags and flag groups only after it, so the hook
+  checks those two first. Root `SilenceUsage` would have hidden usage for all of
+  these.
+- 2026-10-04: `secret get` keeps the secret in locked memory until it writes it
+  out (https://git.eeqj.de/sneak/secret/issues/37): `Vault.GetSecret` and
+  `Vault.GetSecretVersion` return a `*memguard.LockedBuffer`, which every caller
+  destroys, and `secret get` writes its bytes straight to stdout, still with no
+  trailing newline. Before, the value was copied into ordinary memory that
+  nothing wiped, and `get --version` also wrote it to the debug log.
+- 2026-10-04: The `Makefile` no longer sets `DOCKER_HOST`, so its docker targets
+  use the local docker daemon, or whatever `DOCKER_HOST` the environment sets.
+  `make build` calls the new `script/build`, which stamps the version (`VERSION`
+  from the environment, else `git describe`) and the git commit as before.
+  `build`, `clean`, `install` and `docker-run` are in `.PHONY`; `make install`
+  depends on `build`. The `vet` target is gone: `script/test` runs `go vet`
+  first.
+- 2026-10-04: `.gitignore` is the org's standard file, which ignores `.env`,
+  `.env.*`, `*.pem` and `*.key` and editor and OS files, plus this repo's
+  `/secret`, `*.log`, `*.test` and `settings.local.json`
+  (https://git.eeqj.de/sneak/secret/issues/40). `.dockerignore` also leaves out
+  `node_modules`; `.git` stays in the build context for the version stamp.
 - 2026-10-04: `secret init` refuses when the default vault exists, and
-  `secret vault create NAME` when `NAME` does, with "vault NAME already
-  exists", before writing anything. The check is in `vault.CreateVault`,
-  which both commands call while holding the state directory lock, so two
-  creates of one vault at once cannot both pass the check. Before, either
-  command replaced the vault's metadata, passphrase unlocker and
-  `longterm.age`, so none of its secrets could be decrypted any more. Both
-  commands now ask for the unlocker passphrase before creating the vault,
-  so one stopped at that prompt leaves no vault behind.
-- 2026-10-04: The `internal/cli` tests are back to about their time
-  before the state directory lock
-  (https://git.eeqj.de/sneak/secret/issues/80). The test that each
-  changing command waits for the lock releases it as soon as it sees the
-  command waiting there, instead of after a fixed 100 ms. The two vaults
-  with passphrase unlockers that the path and move tests start from are
-  made once and copied for each test.
-- 2026-10-04: `secret mv` rejects a move whose destination is the source
-  under another name, such as `foo` for `Foo` on a case-insensitive
-  filesystem (the macOS default) or a name reached through a symbolic
-  link, before changing anything, with or without `--force`, within a
-  vault and between vaults; before, `--force` removed the destination and
-  so deleted the secret. A rename that changes only letter case works on a
-  case-sensitive filesystem as before.
-- 2026-10-04: Lint runs only in docker: `script/lint` builds
-  `Dockerfile.lint`, where golangci-lint is a build step rebuilt on
-  every run (`--no-cache-filter`), so an unchanged tree is linted too;
-  the module download stays cached. `script/bootstrap` no longer
-  installs golangci-lint, and the `Dockerfile` lint stage calls it
-  directly instead of `make lint`. `golangci-lint config verify` is not
-  run: it fetches its schema live over unpinned HTTPS.
-- 2026-10-04: A PGP unlocker whose metadata has no usable GPG key ID
-  no longer panics: `GetID()` warns with the unlocker's directory and
-  returns `pgp-unknown`. `ListUnlockers` skips, with a warning, an
-  unlocker whose metadata file cannot be checked for, read or parsed
-  instead of failing, so `secret unlocker list` still lists the others;
-  the listing's ID lookup no longer warns about that directory again.
-- 2026-10-03: `secret mv` rejects a move whose destination is the
-  source (`mv --force x x`, `mv --force work:x work:`, or an empty
-  destination, which defaults to the source name) before changing
-  anything; before, `--force` removed the destination first and so
-  deleted the secret. Every vault name given with `vault:` must be one
-  of the existing vaults by exact name, so `work:x work/:x` is rejected
-  instead of being taken for a move between two vaults. A move within a
-  named vault no longer makes that vault the current one, whether it
-  succeeds or fails.
-- 2026-10-03: Commands that change the state directory hold one lock
-  (`flock` on `lock` in the state directory; a mutex on the in-memory
-  test filesystem), so concurrent commands no longer lose versions or
-  race on the current pointers. Every file is written through
-  `secret.WriteFileAtomic` (temporary file, sync, rename), so no file
-  is ever half-written and `current`, `currentvault` and
-  `current-unlocker` never go missing. New versions, new secrets and
-  cross-vault copies are built in a temporary directory and renamed
-  into place, and removals rename out of the way first, so a version
-  or secret is never half-added and never half-removed.
-- 2026-10-03: The checks run before changing a vault now stop with an
-  error naming the path and cause when they cannot read what they
-  inspect, instead of reading the failure as "nothing there": the
-  duplicate check before `unlocker add pgp` (an unreadable
-  `unlockers.d` or unlocker metadata file), the secret count that
-  guards removing the last unlocker and removing a vault, and the
-  existing long-term key check before `vault import`.
-- 2026-10-03: `version rm`, `version promote` and `get --version`
-  accept a version only if it is one of the versions `version list`
-  lists for that secret, compared as typed before any path is built
-  (`secret.VersionExists`), and touch nothing otherwise. An empty
-  `--version` is rejected instead of meaning the current version.
-  Before, `secret version rm x ../../..` deleted the whole vault,
-  `secret version rm x ..` the secret, and `.` or `""` every version.
-- 2026-10-03: Key material is wiped on every exit: `Entry()` returns
-  the exit code after its deferred `memguard.Purge()` has run, and only
-  `main` calls `os.Exit`. SIGINT and SIGTERM go through memguard's
-  handler, which wipes every buffer before exiting; when the process is
-  in the terminal's foreground process group it first restores the
-  terminal settings from startup, so an interrupted passphrase prompt no
-  longer leaves echo off.
-- 2026-10-03: Every command that builds a path from a secret name
-  checks the name first with `vault.ValidateSecretName` and touches
-  nothing when it is invalid: `rm`, `mv` (both names, within a vault
-  and between vaults, before switching the current vault), `import`,
-  `version list`/`promote`/`rm`, `encrypt` and `decrypt`. The error
-  and `README.md` state the naming rule. Before, `secret rm ..`
-  deleted the whole vault and `secret rm .` every secret in it.
-- 2026-10-03: The keychain unlocker's age key passphrase stays in
-  locked memory: it is generated into a locked buffer, and the
-  keychain JSON is written and read by `KeychainData` code in
-  `internal/secret/keychaindata.go` (tested on Linux) without
-  `encoding/json` holding it; the JSON field names are unchanged.
-- 2026-10-02: A plain `docker build .` builds again: the size tests
-  skip a case that needs more locked memory than the process can
-  lock, and run every case under `script/cibuild`. The image stamps the
-  `VERSION` build argument, else `git describe --tags --always`, into
-  `Version`, and fails if `.git` is present but yields no version;
-  `make build` stamps `git describe` too, not a fixed `0.1.0`.
-  `.dockerignore` keeps `.git/config` out; `script/docker` is the
+  `secret vault create NAME` when `NAME` does, with "vault NAME already exists",
+  before writing anything. The check is in `vault.CreateVault`, which both
+  commands call while holding the state directory lock, so two creates of one
+  vault at once cannot both pass the check. Before, either command replaced the
+  vault's metadata, passphrase unlocker and `longterm.age`, so none of its
+  secrets could be decrypted any more. Both commands now ask for the unlocker
+  passphrase before creating the vault, so one stopped at that prompt leaves no
+  vault behind.
+- 2026-10-04: The `internal/cli` tests are back to about their time before the
+  state directory lock (https://git.eeqj.de/sneak/secret/issues/80). The test
+  that each changing command waits for the lock releases it as soon as it sees
+  the command waiting there, instead of after a fixed 100 ms. The two vaults
+  with passphrase unlockers that the path and move tests start from are made
+  once and copied for each test.
+- 2026-10-04: `secret mv` rejects a move whose destination is the source under
+  another name, such as `foo` for `Foo` on a case-insensitive filesystem (the
+  macOS default) or a name reached through a symbolic link, before changing
+  anything, with or without `--force`, within a vault and between vaults;
+  before, `--force` removed the destination and so deleted the secret. A rename
+  that changes only letter case works on a case-sensitive filesystem as before.
+- 2026-10-04: Lint runs only in docker: `script/lint` builds `Dockerfile.lint`,
+  where golangci-lint is a build step rebuilt on every run
+  (`--no-cache-filter`), so an unchanged tree is linted too; the module download
+  stays cached. `script/bootstrap` no longer installs golangci-lint, and the
+  `Dockerfile` lint stage calls it directly instead of `make lint`.
+  `golangci-lint config verify` is not run: it fetches its schema live over
+  unpinned HTTPS.
+- 2026-10-04: A PGP unlocker whose metadata has no usable GPG key ID no longer
+  panics: `GetID()` warns with the unlocker's directory and returns
+  `pgp-unknown`. `ListUnlockers` skips, with a warning, an unlocker whose
+  metadata file cannot be checked for, read or parsed instead of failing, so
+  `secret unlocker list` still lists the others; the listing's ID lookup no
+  longer warns about that directory again.
+- 2026-10-03: `secret mv` rejects a move whose destination is the source
+  (`mv --force x x`, `mv --force work:x work:`, or an empty destination, which
+  defaults to the source name) before changing anything; before, `--force`
+  removed the destination first and so deleted the secret. Every vault name
+  given with `vault:` must be one of the existing vaults by exact name, so
+  `work:x work/:x` is rejected instead of being taken for a move between two
+  vaults. A move within a named vault no longer makes that vault the current
+  one, whether it succeeds or fails.
+- 2026-10-03: Commands that change the state directory hold one lock (`flock` on
+  `lock` in the state directory; a mutex on the in-memory test filesystem), so
+  concurrent commands no longer lose versions or race on the current pointers.
+  Every file is written through `secret.WriteFileAtomic` (temporary file, sync,
+  rename), so no file is ever half-written and `current`, `currentvault` and
+  `current-unlocker` never go missing. New versions, new secrets and cross-vault
+  copies are built in a temporary directory and renamed into place, and removals
+  rename out of the way first, so a version or secret is never half-added and
+  never half-removed.
+- 2026-10-03: The checks run before changing a vault now stop with an error
+  naming the path and cause when they cannot read what they inspect, instead of
+  reading the failure as "nothing there": the duplicate check before
+  `unlocker add pgp` (an unreadable `unlockers.d` or unlocker metadata file),
+  the secret count that guards removing the last unlocker and removing a vault,
+  and the existing long-term key check before `vault import`.
+- 2026-10-03: `version rm`, `version promote` and `get --version` accept a
+  version only if it is one of the versions `version list` lists for that
+  secret, compared as typed before any path is built (`secret.VersionExists`),
+  and touch nothing otherwise. An empty `--version` is rejected instead of
+  meaning the current version. Before, `secret version rm x ../../..` deleted
+  the whole vault, `secret version rm x ..` the secret, and `.` or `""` every
+  version.
+- 2026-10-03: Key material is wiped on every exit: `Entry()` returns the exit
+  code after its deferred `memguard.Purge()` has run, and only `main` calls
+  `os.Exit`. SIGINT and SIGTERM go through memguard's handler, which wipes every
+  buffer before exiting; when the process is in the terminal's foreground
+  process group it first restores the terminal settings from startup, so an
+  interrupted passphrase prompt no longer leaves echo off.
+- 2026-10-03: Every command that builds a path from a secret name checks the
+  name first with `vault.ValidateSecretName` and touches nothing when it is
+  invalid: `rm`, `mv` (both names, within a vault and between vaults, before
+  switching the current vault), `import`, `version list`/`promote`/`rm`,
+  `encrypt` and `decrypt`. The error and `README.md` state the naming rule.
+  Before, `secret rm ..` deleted the whole vault and `secret rm .` every secret
+  in it.
+- 2026-10-03: The keychain unlocker's age key passphrase stays in locked memory:
+  it is generated into a locked buffer, and the keychain JSON is written and
+  read by `KeychainData` code in `internal/secret/keychaindata.go` (tested on
+  Linux) without `encoding/json` holding it; the JSON field names are unchanged.
+- 2026-10-02: A plain `docker build .` builds again: the size tests skip a case
+  that needs more locked memory than the process can lock, and run every case
+  under `script/cibuild`. The image stamps the `VERSION` build argument, else
+  `git describe --tags --always`, into `Version`, and fails if `.git` is present
+  but yields no version; `make build` stamps `git describe` too, not a fixed
+  `0.1.0`. `.dockerignore` keeps `.git/config` out; `script/docker` is the
   canonical copy.
 - 2026-08-07: Updated golangci-lint to v2.12.2 with the canonical
-  `.golangci.yml` (all linters enabled minus the standard disable
-  list, `lll` 88, tests linted); bumped the `Dockerfile` lint-stage
-  image to the tagged v2.12.2 Debian digest; fixed all ~1550 new
-  findings across `internal/` and `pkg/` (line wrapping, `wsl_v5`
-  blank lines, sentinel errors for `err113`, `t.Parallel()` where
-  safe, `_test` package conversions, complexity/`dupl` helper
-  extraction) on branch `golangci-v2.12.2`. Reworked after review:
-  the `err113` sentinels in `internal/vault`, `internal/secret`,
-  `internal/cli` and `pkg/bip85` were reshaped so every composed
-  error message is byte-identical to `main`, and
-  `findUnlockerIDByMetadata` now returns an error so `unlocker list`
-  skips an unreadable `unlockers.d` entry with a warning instead of
-  emitting a fabricated fallback ID.
+  `.golangci.yml` (all linters enabled minus the standard disable list, `lll`
+  88, tests linted); bumped the `Dockerfile` lint-stage image to the tagged
+  v2.12.2 Debian digest; fixed all ~1550 new findings across `internal/` and
+  `pkg/` (line wrapping, `wsl_v5` blank lines, sentinel errors for `err113`,
+  `t.Parallel()` where safe, `_test` package conversions, complexity/`dupl`
+  helper extraction) on branch `golangci-v2.12.2`. Reworked after review: the
+  `err113` sentinels in `internal/vault`, `internal/secret`, `internal/cli` and
+  `pkg/bip85` were reshaped so every composed error message is byte-identical to
+  `main`, and `findUnlockerIDByMetadata` now returns an error so `unlocker list`
+  skips an unreadable `unlockers.d` entry with a warning instead of emitting a
+  fabricated fallback ID.
 - 2026-08-07: Added `.editorconfig`
   (https://git.eeqj.de/sneak/secret/issues/27).
-- 2026-07-07 Adopted scripts-to-rule-them-all: `script/` entrypoints,
-  Makefile shims, README Entrypoints section
+- 2026-07-07 Adopted scripts-to-rule-them-all: `script/` entrypoints, Makefile
+  shims, README Entrypoints section
 - 2026-07-07: Added `REPO_POLICIES.md` and the `make hooks` target;
   `.gitea/workflows/check.yml` now runs `script/cibuild`.
 - 2026-03-30: Added the `make fmt-check` target and
   `.gitea/workflows/check.yml`, which runs `docker build` on every push; the
   `Dockerfile` base images are pinned by sha256.
-- 2026-03-11: Secure Enclave unlocker for hardware-backed secret
-  protection, plus review fixes (stub panics, derivation index, tests,
-  README) on branch secure-enclave-unlocker.
+- 2026-03-11: Secure Enclave unlocker for hardware-backed secret protection,
+  plus review fixes (stub panics, derivation index, tests, README) on branch
+  secure-enclave-unlocker.
 - 2026-02-28: Repo cleanup, removed stale .cursorrules and coverage.out.
-- Audit fix wave (issues #1, #2, #3, #13, #14): skip unlockers with
-  missing metadata, allow uppercase secret names, fix hardcoded
-  derivation index, validate names in GetSecretVersion against path
-  traversal, return errors instead of panicking, add Warn() on silent
-  anomalies.
-- Memory security hardening: LockedBuffer used through encrypt/decrypt
-  paths (Save/EncryptWithPassphrase/GetValue/gpg helpers), deprecated
-  bare-[]byte APIs removed.
-- Per-secret keypair architecture, vault package refactor, versioning
-  with --version, comprehensive test suite with in-memory filesystem.
+- Audit fix wave (issues #1, #2, #3, #13, #14): skip unlockers with missing
+  metadata, allow uppercase secret names, fix hardcoded derivation index,
+  validate names in GetSecretVersion against path traversal, return errors
+  instead of panicking, add Warn() on silent anomalies.
+- Memory security hardening: LockedBuffer used through encrypt/decrypt paths
+  (Save/EncryptWithPassphrase/GetValue/gpg helpers), deprecated bare-[]byte APIs
+  removed.
+- Per-secret keypair architecture, vault package refactor, versioning with
+  --version, comprehensive test suite with in-memory filesystem.
 - Debug logging system (slog, GODEBUG flag, TTY-aware output).
 - Renamed SEP unlocker to Keychain, reorganized import commands.
-- 2025-05-28: Initial implementation (vault, age encryption, mnemonic,
-  CLI).
+- 2025-05-28: Initial implementation (vault, age encryption, mnemonic, CLI).
 
 # Future Steps
 
 - Implement version-number shell completion for the second arg of
-  `secret version promote` and `secret version rm`
-  (`internal/cli/version.go`; was an in-code TODO removed for godox).
-- Cover mnemonic-vs-xprv identity consistency in
-  `pkg/agehd/agehd_test.go` `TestMnemonicVsXPRVConsistency` (was an
-  in-code FIXME removed for godox).
-- CI does not compile, lint or test the files built only with cgo on
-  macOS, since compiling them needs Apple's SDK:
+  `secret version promote` and `secret version rm` (`internal/cli/version.go`;
+  was an in-code TODO removed for godox).
+- Cover mnemonic-vs-xprv identity consistency in `pkg/agehd/agehd_test.go`
+  `TestMnemonicVsXPRVConsistency` (was an in-code FIXME removed for godox).
+- CI does not compile, lint or test the files built only with cgo on macOS,
+  since compiling them needs Apple's SDK:
   `internal/secret/keychainunlocker_cgo.go` (the three functions that call
   `go-keychain`) with `keychainunlocker_test.go`, and `internal/macse`
-  (`macse_darwin.go`, `macse_test.go`, the Objective-C sources). Lint has
-  never run on them, so it would likely find more there than the line
-  lengths. No macOS test runs in CI. A macOS runner would cover all of it
-  (asked on https://git.eeqj.de/sneak/secret/issues/50).
+  (`macse_darwin.go`, `macse_test.go`, the Objective-C sources). Lint has never
+  run on them, so it would likely find more there than the line lengths. No
+  macOS test runs in CI. A macOS runner would cover all of it (asked on
+  https://git.eeqj.de/sneak/secret/issues/50).
 - 1.0 critical security blockers (from repo TODO.md):
     - Memory security: age writes an identity's private key out as a string in
       ordinary memory, and the copies it makes on the way stay there
@@ -432,8 +554,8 @@ https://git.eeqj.de/sneak/secret/milestone/12
 - Medium priority:
     - Standardize error messages; stop leaking internals.
     - Split oversized CLI functions.
-- Cleanups: read statedir from environment or default instead of
-  passing it around.
+- Cleanups: read statedir from environment or default instead of passing it
+  around.
 - Enhancements: help examples, colored output, --quiet flag, name suggestions on
   miss, audit logging, hardware integration tests (Keychain, GPG), naming
   consistency, vault export/import, batch operations, search, secret metadata

cmd/secret/main.go

@@ -4,7 +4,7 @@ package main
 import (
 	"os"
 
-	"git.eeqj.de/sneak/secret/internal/cli"
+	"sneak.berlin/go/secret/internal/cli"
 )
 
 func main() {

go.mod

@@ -1,4 +1,4 @@
-module git.eeqj.de/sneak/secret
+module sneak.berlin/go/secret
 
 go 1.24.1
 
@@ -9,16 +9,17 @@ require (
 	github.com/btcsuite/btcd/btcec/v2 v2.1.3
 	github.com/btcsuite/btcd/btcutil v1.1.6
 	github.com/btcsuite/btcutil v0.0.0-20190425235716-9e5f4b9a998d
-	github.com/creack/pty v1.1.24
-	github.com/keybase/go-keychain v0.0.0-20230307172405-3e4884637dd1
+	github.com/creack/pty v1.1.25-0.20260601142114-9246436fffe8 // v1.1.24's Open can return another pty's terminal
+	github.com/dustin/go-humanize v1.0.1
+	github.com/fatih/color v1.18.0
 	github.com/oklog/ulid/v2 v2.1.1
 	github.com/spf13/afero v1.14.0
 	github.com/spf13/cobra v1.9.1
 	github.com/stretchr/testify v1.8.4
-	github.com/tyler-smith/go-bip39 v1.1.0
 	golang.org/x/crypto v0.38.0
 	golang.org/x/sys v0.33.0
 	golang.org/x/term v0.32.0
+	golang.org/x/text v0.25.0
 )
 
 require (
@@ -26,13 +27,10 @@ require (
 	github.com/btcsuite/btcd/chaincfg/chainhash v1.1.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 // indirect
-	github.com/dustin/go-humanize v1.0.1 // indirect
-	github.com/fatih/color v1.18.0 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/spf13/pflag v1.0.6 // indirect
-	golang.org/x/text v0.25.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -35,8 +35,8 @@ github.com/btcsuite/snappy-go v1.0.0/go.mod h1:8woku9dyThutzjeg+3xrA5iCpBRH8XEEg
 github.com/btcsuite/websocket v0.0.0-20150119174127-31079b680792/go.mod h1:ghJtEyQwv5/p4Mg4C0fgbePVuGr935/5ddU9Z3TmDRY=
 github.com/btcsuite/winsvc v1.0.0/go.mod h1:jsenWakMcC0zFBFurPLEAyrnc/teJEM1O46fmI40EZs=
 github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
-github.com/creack/pty v1.1.24 h1:bJrF4RRfyJnbTJqzRLHzcGaZK1NeM5kTC9jGgovnR1s=
-github.com/creack/pty v1.1.24/go.mod h1:08sCNb52WyoAwi2QDyzUCTgcvVFhUzewun7wtTfvcwE=
+github.com/creack/pty v1.1.25-0.20260601142114-9246436fffe8 h1:CY3gjC7naqYGLMiywvj3suPfa1i0p/QEr7o8ujxL/2M=
+github.com/creack/pty v1.1.25-0.20260601142114-9246436fffe8/go.mod h1:08sCNb52WyoAwi2QDyzUCTgcvVFhUzewun7wtTfvcwE=
 github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
@@ -69,8 +69,6 @@ github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLf
 github.com/jessevdk/go-flags v0.0.0-20141203071132-1679536dcc89/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
 github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
 github.com/jrick/logrotate v1.0.0/go.mod h1:LNinyqDIJnpAur+b8yyulnQw/wDuN1+BYKlTRt3OuAQ=
-github.com/keybase/go-keychain v0.0.0-20230307172405-3e4884637dd1 h1:yi1W8qcFJ2plmaGJFN1npm0KQviWPMCtQOYuwDT6Swk=
-github.com/keybase/go-keychain v0.0.0-20230307172405-3e4884637dd1/go.mod h1:qDHUvIjGZJUtdPtuP4WMu5/U4aVWbFw1MhlkJqCGmCQ=
 github.com/kkdai/bstream v0.0.0-20161212061736-f391b8402d23/go.mod h1:J+Gs4SYgM6CZQHDETBtE9HaSEkGmuNXF86RwHhHUvq4=
 github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
 github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
@@ -107,8 +105,6 @@ github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO
 github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
 github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
 github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc=
-github.com/tyler-smith/go-bip39 v1.1.0 h1:5eUemwrMargf3BSLRRCalXT93Ns6pQJIjYQN2nyfOP8=
-github.com/tyler-smith/go-bip39 v1.1.0/go.mod h1:gUYDtqQw1JS3ZJ8UWVcGTGqqr6YIN3CWg+kkNaLt55U=
 golang.org/x/crypto v0.0.0-20170930174604-9419663f5a44/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=

internal/bip39/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-2018 Tyler Smith and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

internal/bip39/bip39.go

@@ -0,0 +1,285 @@
+// Package bip39 is the Golang implementation of the BIP39 spec.
+//
+// The official BIP39 spec can be found at
+// https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki
+//
+// It is a copy of github.com/tyler-smith/go-bip39 v1.1.0, trimmed to what
+// secret uses.
+//
+//nolint:mnd // the numbers are BIP-39's own, written as upstream writes them
+package bip39
+
+import (
+	"crypto/rand"
+	"crypto/sha256"
+	"crypto/sha512"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"math/big"
+	"strings"
+
+	"golang.org/x/crypto/pbkdf2"
+)
+
+var (
+	// ErrInvalidMnemonic is returned when trying to use a malformed mnemonic.
+	ErrInvalidMnemonic = errors.New("invalid mnenomic")
+
+	// ErrEntropyLengthInvalid is returned when trying to use an entropy set with
+	// an invalid size.
+	ErrEntropyLengthInvalid = errors.New(
+		"entropy length must be [128, 256] and a multiple of 32",
+	)
+
+	// ErrChecksumIncorrect is returned when entropy has the incorrect checksum.
+	ErrChecksumIncorrect = errors.New("checksum incorrect")
+)
+
+// NewEntropy will create random entropy bytes
+// so long as the requested size bitSize is an appropriate size.
+//
+// bitSize has to be a multiple 32 and be within the inclusive range of {128, 256}
+func NewEntropy(bitSize int) ([]byte, error) {
+	err := validateEntropyBitSize(bitSize)
+	if err != nil {
+		return nil, err
+	}
+
+	entropy := make([]byte, bitSize/8)
+	_, err = rand.Read(entropy)
+
+	return entropy, err
+}
+
+// EntropyFromMnemonic takes a mnemonic generated by this library,
+// and returns the input entropy used to generate the given mnemonic.
+// An error is returned if the given mnemonic is invalid.
+func EntropyFromMnemonic(mnemonic string) ([]byte, error) {
+	mnemonicSlice, isValid := splitMnemonicWords(mnemonic)
+	if !isValid {
+		return nil, ErrInvalidMnemonic
+	}
+
+	// Some bitwise operands for working with big.Ints
+	shift11BitsMask := big.NewInt(2048)
+	bigOne := big.NewInt(1)
+
+	// used to isolate the checksum bits from the entropy+checksum byte array
+	wordLengthChecksumMasksMapping := map[int]*big.Int{
+		12: big.NewInt(15),
+		15: big.NewInt(31),
+		18: big.NewInt(63),
+		21: big.NewInt(127),
+		24: big.NewInt(255),
+	}
+	// used to use only the desired x of 8 available checksum bits.
+	// 256 bit (word length 24) requires all 8 bits of the checksum,
+	// and thus no shifting is needed for it (we would get a divByZero crash if we did)
+	wordLengthChecksumShiftMapping := map[int]*big.Int{
+		12: big.NewInt(16),
+		15: big.NewInt(8),
+		18: big.NewInt(4),
+		21: big.NewInt(2),
+	}
+
+	// wordMap is a reverse lookup map for the word list
+	wordMap := map[string]int{}
+	for i, v := range English() {
+		wordMap[v] = i
+	}
+
+	// Decode the words into a big.Int.
+	b := big.NewInt(0)
+
+	for _, v := range mnemonicSlice {
+		index, found := wordMap[v]
+		if !found {
+			return nil, fmt.Errorf(
+				"%w: word `%v` not found in reverse map", ErrInvalidMnemonic, v,
+			)
+		}
+
+		var wordBytes [2]byte
+
+		//nolint:gosec // the index of a word in the list is below 2048
+		binary.BigEndian.PutUint16(wordBytes[:], uint16(index))
+
+		b = b.Mul(b, shift11BitsMask)
+		b = b.Or(b, big.NewInt(0).SetBytes(wordBytes[:]))
+	}
+
+	// Build and add the checksum to the big.Int.
+	checksum := big.NewInt(0)
+	checksumMask := wordLengthChecksumMasksMapping[len(mnemonicSlice)]
+	checksum = checksum.And(b, checksumMask)
+
+	b.Div(b, big.NewInt(0).Add(checksumMask, bigOne))
+
+	// The entropy is the underlying bytes of the big.Int. Any upper bytes of
+	// all 0's are not returned so we pad the beginning of the slice with empty
+	// bytes if necessary.
+	entropy := b.Bytes()
+	entropy = padByteSlice(entropy, len(mnemonicSlice)/3*4)
+
+	// Generate the checksum and compare with the one we got from the mneomnic.
+	entropyChecksumBytes := computeChecksum(entropy)
+	entropyChecksum := big.NewInt(int64(entropyChecksumBytes[0]))
+
+	if l := len(mnemonicSlice); l != 24 {
+		checksumShift := wordLengthChecksumShiftMapping[l]
+		entropyChecksum.Div(entropyChecksum, checksumShift)
+	}
+
+	if checksum.Cmp(entropyChecksum) != 0 {
+		return nil, ErrChecksumIncorrect
+	}
+
+	return entropy, nil
+}
+
+// NewMnemonic will return a string consisting of the mnemonic words for
+// the given entropy.
+// If the provide entropy is invalid, an error will be returned.
+func NewMnemonic(entropy []byte) (string, error) {
+	// Compute some lengths for convenience.
+	entropyBitLength := len(entropy) * 8
+	checksumBitLength := entropyBitLength / 32
+	sentenceLength := (entropyBitLength + checksumBitLength) / 11
+
+	// Validate that the requested size is supported.
+	err := validateEntropyBitSize(entropyBitLength)
+	if err != nil {
+		return "", err
+	}
+
+	// Some bitwise operands for working with big.Ints
+	last11BitsMask := big.NewInt(2047)
+	shift11BitsMask := big.NewInt(2048)
+
+	// wordList is the set of words to use
+	wordList := English()
+
+	// Add checksum to entropy.
+	entropy = addChecksum(entropy)
+
+	// Break entropy up into sentenceLength chunks of 11 bits.
+	// For each word AND mask the rightmost 11 bits and find the word at that index.
+	// Then bitshift entropy 11 bits right and repeat.
+	// Add to the last empty slot so we can work with LSBs instead of MSB.
+
+	// Entropy as an int so we can bitmask without worrying about bytes slices.
+	entropyInt := new(big.Int).SetBytes(entropy)
+
+	// Slice to hold words in.
+	words := make([]string, sentenceLength)
+
+	// Throw away big.Int for AND masking.
+	word := big.NewInt(0)
+
+	for i := sentenceLength - 1; i >= 0; i-- {
+		// Get 11 right most bits and bitshift 11 to the right for next time.
+		word.And(entropyInt, last11BitsMask)
+		entropyInt.Div(entropyInt, shift11BitsMask)
+
+		// Get the bytes representing the 11 bits as a 2 byte slice.
+		wordBytes := padByteSlice(word.Bytes(), 2)
+
+		// Convert bytes to an index and add that word to the list.
+		words[i] = wordList[binary.BigEndian.Uint16(wordBytes)]
+	}
+
+	return strings.Join(words, " "), nil
+}
+
+// NewSeed creates a hashed seed output given a provided string and password.
+// No checking is performed to validate that the string provided is a valid mnemonic.
+func NewSeed(mnemonic string, password string) []byte {
+	return pbkdf2.Key([]byte(mnemonic), []byte("mnemonic"+password), 2048, 64, sha512.New)
+}
+
+// IsMnemonicValid attempts to verify that the provided mnemonic is valid.
+// Validity is determined by both the number of words being appropriate,
+// and that all the words in the mnemonic are present in the word list.
+func IsMnemonicValid(mnemonic string) bool {
+	_, err := EntropyFromMnemonic(mnemonic)
+
+	return err == nil
+}
+
+// Appends to data the first (len(data) / 32)bits of the result of sha256(data)
+// Currently only supports data up to 32 bytes
+func addChecksum(data []byte) []byte {
+	// Some bitwise operands for working with big.Ints
+	bigOne := big.NewInt(1)
+	bigTwo := big.NewInt(2)
+
+	// Get first byte of sha256
+	hash := computeChecksum(data)
+	firstChecksumByte := hash[0]
+
+	// len() is in bytes so we divide by 4
+	checksumBitLength := uint(len(data) / 4)
+
+	// For each bit of check sum we want we shift the data one the left
+	// and then set the (new) right most bit equal to checksum bit at that index
+	// staring from the left
+	dataBigInt := new(big.Int).SetBytes(data)
+	for i := range checksumBitLength {
+		// Bitshift 1 left
+		dataBigInt.Mul(dataBigInt, bigTwo)
+
+		// Set rightmost bit if leftmost checksum bit is set
+		if firstChecksumByte&(1<<(7-i)) > 0 {
+			dataBigInt.Or(dataBigInt, bigOne)
+		}
+	}
+
+	return dataBigInt.Bytes()
+}
+
+func computeChecksum(data []byte) []byte {
+	hasher := sha256.New()
+	hasher.Write(data)
+
+	return hasher.Sum(nil)
+}
+
+// validateEntropyBitSize ensures that entropy is the correct size for being a
+// mnemonic.
+func validateEntropyBitSize(bitSize int) error {
+	if (bitSize%32) != 0 || bitSize < 128 || bitSize > 256 {
+		return ErrEntropyLengthInvalid
+	}
+
+	return nil
+}
+
+// padByteSlice returns a byte slice of the given size with contents of the
+// given slice left padded and any empty spaces filled with 0's.
+func padByteSlice(slice []byte, length int) []byte {
+	offset := length - len(slice)
+	if offset <= 0 {
+		return slice
+	}
+
+	newSlice := make([]byte, length)
+	copy(newSlice[offset:], slice)
+
+	return newSlice
+}
+
+func splitMnemonicWords(mnemonic string) ([]string, bool) {
+	// Create a list of all the words in the mnemonic sentence
+	words := strings.Fields(mnemonic)
+
+	// Get num of words
+	numOfWords := len(words)
+
+	// The number of words should be 12, 15, 18, 21 or 24
+	if numOfWords%3 != 0 || numOfWords < 12 || numOfWords > 24 {
+		return nil, false
+	}
+
+	return words, true
+}

internal/bip39/bip39_internal_test.go

@@ -0,0 +1,456 @@
+package bip39
+
+import (
+	"encoding/hex"
+	"testing"
+)
+
+type vector struct {
+	entropy  string
+	mnemonic string
+	seed     string
+}
+
+func TestNewMnemonic(t *testing.T) {
+	t.Parallel()
+
+	for _, vector := range testVectors() {
+		entropy, err := hex.DecodeString(vector.entropy)
+		assertNil(t, err)
+
+		mnemonic, err := NewMnemonic(entropy)
+		assertNil(t, err)
+		assertEqualString(t, vector.mnemonic, mnemonic)
+
+		seed := NewSeed(mnemonic, "TREZOR")
+		assertEqualString(t, vector.seed, hex.EncodeToString(seed))
+	}
+}
+
+func TestNewMnemonicInvalidEntropy(t *testing.T) {
+	t.Parallel()
+
+	_, err := NewMnemonic([]byte{})
+	assertNotNil(t, err)
+}
+
+func TestIsMnemonicValid(t *testing.T) {
+	t.Parallel()
+
+	for _, vector := range badMnemonicSentences() {
+		assertFalse(t, IsMnemonicValid(vector.mnemonic))
+	}
+
+	for _, vector := range testVectors() {
+		assertTrue(t, IsMnemonicValid(vector.mnemonic))
+	}
+}
+
+func TestNewEntropy(t *testing.T) {
+	t.Parallel()
+
+	// Good tests.
+	for i := 128; i <= 256; i += 32 {
+		_, err := NewEntropy(i)
+		assertNil(t, err)
+	}
+	// Bad Values
+	for i := range 257 {
+		if i%8 != 0 {
+			_, err := NewEntropy(i)
+			assertNotNil(t, err)
+		}
+	}
+}
+
+func TestPadByteSlice(t *testing.T) {
+	t.Parallel()
+
+	assertEqualByteSlices(t, []byte{0}, padByteSlice([]byte{}, 1))
+	assertEqualByteSlices(t, []byte{0, 1}, padByteSlice([]byte{1}, 2))
+	assertEqualByteSlices(t, []byte{1, 1}, padByteSlice([]byte{1, 1}, 2))
+	assertEqualByteSlices(t, []byte{1, 1, 1}, padByteSlice([]byte{1, 1, 1}, 2))
+}
+
+//nolint:funlen // the test vectors, kept as upstream wrote them
+func TestMnemonicToByteArrayForZeroLeadingSeeds(t *testing.T) {
+	t.Parallel()
+
+	ms := []string{
+		"00000000000000000000000000000000",
+		"00a84c51041d49acca66e6160c1fa999",
+		"00ca45df1673c76537a2020bfed1dafd",
+		"0019d5871c7b81fd83d474ef1c1e1dae",
+		"00dcb021afb35ffcdd1d032d2056fc86",
+		"0062be7bd09a27288b6cf0eb565ec739",
+		"00dc705b5efa0adf25b9734226ba60d4",
+		"0017747418d54c6003fa64fade83374b",
+		"000d44d3ee7c3dfa45e608c65384431b",
+		"008241c1ef976b0323061affe5bf24b9",
+		"00a6aec77e4d16bea80b50a34991aaba",
+		"0011527b8c6ddecb9d0c20beccdeb58d",
+		"001c938c503c8f5a2bba2248ff621546",
+		"0002f90aaf7a8327698f0031b6317c36",
+		"00bff43071ed7e07f77b14f615993bac",
+		"00da143e00ef17fc63b6fb22dcc2c326",
+		"00ffc6764fb32a354cab1a3ddefb015d",
+		"0062ef47e0985e8953f24760b7598cdd",
+		"003bf9765064f71d304908d906c065f5",
+		"00993851503471439d154b3613947474",
+		"007ad0ffe9eae753a483a76af06dfa67",
+		"00091824db9ec19e663bee51d64c83cc",
+		"00f48ac621f7e3cb39b2012ac3121543",
+		"0072917415cdca24dfa66c4a92c885b4",
+		"0027ced2b279ea8a91d29364487cdbf4",
+		"00b9c0d37fb10ba272e55842ad812583",
+		"004b3d0d2b9285946c687a5350479c8c",
+		"00c7c12a37d3a7f8c1532b17c89b724c",
+		"00f400c5545f06ae17ad00f3041e4e26",
+		"001e290be10df4d209f247ac5878662b",
+		"00bf0f74568e582a7dd1ee64f792ec8b",
+		"00d2e43ecde6b72b847db1539ed89e23",
+		"00cecba6678505bb7bfec8ed307251f6",
+		"000aeed1a9edcbb4bc88f610d3ce84eb",
+		"00d06206aadfc25c2b21805d283f15ae",
+		"00a31789a2ab2d54f8fadd5331010287",
+		"003493c5f520e8d5c0483e895a121dc9",
+		"004706112800b76001ece2e268bc830e",
+		"00ab31e28bb5305be56e38337dbfa486",
+		"006872fe85df6b0fa945248e6f9379d1",
+		"00717e5e375da6934e3cfdf57edaf3bd",
+		"007f1b46e7b9c4c76e77c434b9bccd6b",
+		"00dc93735aa35def3b9a2ff676560205",
+		"002cd5dcd881a49c7b87714c6a570a76",
+		"0013b5af9e13fac87e0c505686cfb6bf",
+		"007ab1ec9526b0bc04b64ae65fd42631",
+		"00abb4e11d8385c1cca905a6a65e9144",
+		"00574fc62a0501ad8afada2e246708c3",
+		"005207e0a815bb2da6b4c35ec1f2bf52",
+		"00f3460f136fb9700080099cbd62bc18",
+		"007a591f204c03ca7b93981237112526",
+		"00cfe0befd428f8e5f83a5bfc801472e",
+		"00987551ac7a879bf0c09b8bc474d9af",
+		"00cadd3ce3d78e49fbc933a85682df3f",
+		"00bfbf2e346c855ccc360d03281455a1",
+		"004cdf55d429d028f715544ce22d4f31",
+		"0075c84a7d15e0ac85e1e41025eed23b",
+		"00807dddd61f71725d336cab844d2cb5",
+		"00422f21b77fe20e367467ed98c18410",
+		"00b44d0ac622907119c626c850a462fd",
+		"00363f5e7f22fc49f3cd662a28956563",
+		"000fe5837e68397bbf58db9f221bdc4e",
+		"0056af33835c888ef0c22599686445d3",
+		"00790a8647fd3dfb38b7e2b6f578f2c6",
+		"00da8d9009675cb7beec930e263014fb",
+		"00d4b384540a5bb54aa760edaa4fb2fe",
+		"00be9b1479ed680fdd5d91a41eb926d0",
+		"009182347502af97077c40a6e74b4b5c",
+		"00f5c90ee1c67fa77fd821f8e9fab4f1",
+		"005568f9a2dd6b0c0cc2f5ba3d9cac38",
+		"008b481f8678577d9cf6aa3f6cd6056b",
+		"00c4323ece5e4fe3b6cd4c5c932931af",
+		"009791f7550c3798c5a214cb2d0ea773",
+		"008a7baab22481f0ad8167dd9f90d55c",
+		"00f0e601519aafdc8ff94975e64c946d",
+		"0083b61e0daa9219df59d697c270cd31",
+	}
+
+	for _, m := range ms {
+		seed, _ := hex.DecodeString(m)
+
+		mnemonic, err := NewMnemonic(seed)
+		if err != nil {
+			t.Errorf("%v", err)
+		}
+
+		_, err = EntropyFromMnemonic(mnemonic)
+		if err != nil {
+			t.Errorf("Failed for %x - %v", seed, mnemonic)
+		}
+	}
+}
+func TestEntropyFromMnemonic128(t *testing.T) {
+	t.Parallel()
+
+	testEntropyFromMnemonic(t, 128)
+}
+
+func TestEntropyFromMnemonic160(t *testing.T) {
+	t.Parallel()
+
+	testEntropyFromMnemonic(t, 160)
+}
+
+func TestEntropyFromMnemonic192(t *testing.T) {
+	t.Parallel()
+
+	testEntropyFromMnemonic(t, 192)
+}
+
+func TestEntropyFromMnemonic224(t *testing.T) {
+	t.Parallel()
+
+	testEntropyFromMnemonic(t, 224)
+}
+
+func TestEntropyFromMnemonic256(t *testing.T) {
+	t.Parallel()
+
+	testEntropyFromMnemonic(t, 256)
+}
+
+//nolint:dupword,lll // the test vector, kept as upstream wrote it
+func TestEntropyFromMnemonicInvalidChecksum(t *testing.T) {
+	t.Parallel()
+
+	_, err := EntropyFromMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon yellow")
+	assertEqual(t, ErrChecksumIncorrect, err)
+}
+
+//nolint:dupword // the test vectors, kept as upstream wrote them
+func TestEntropyFromMnemonicInvalidMnemonicSize(t *testing.T) {
+	t.Parallel()
+
+	for _, mnemonic := range []string{
+		"a a a a a a a a a a a a a a a a a a a a a a a a a", // Too many words
+		"a",                           // Too few
+		"a a a a a a a a a a a a a a", // Not multiple of 3
+	} {
+		_, err := EntropyFromMnemonic(mnemonic)
+		assertEqual(t, ErrInvalidMnemonic, err)
+	}
+}
+
+func testEntropyFromMnemonic(t *testing.T, bitSize int) {
+	t.Helper()
+
+	for range 512 {
+		expectedEntropy, err := NewEntropy(bitSize)
+		assertNil(t, err)
+		assertTrue(t, len(expectedEntropy) != 0)
+
+		mnemonic, err := NewMnemonic(expectedEntropy)
+		assertNil(t, err)
+		assertTrue(t, len(mnemonic) != 0)
+
+		actualEntropy, err := EntropyFromMnemonic(mnemonic)
+		assertNil(t, err)
+		assertEqualByteSlices(t, expectedEntropy, actualEntropy)
+	}
+}
+
+//nolint:dupword,funlen,lll // the BIP-39 test vectors, kept as upstream wrote them
+func testVectors() []vector {
+	return []vector{
+		{
+			entropy:  "00000000000000000000000000000000",
+			mnemonic: "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about",
+			seed:     "c55257c360c07c72029aebc1b53c05ed0362ada38ead3e3e9efa3708e53495531f09a6987599d18264c1e1c92f2cf141630c7a3c4ab7c81b2f001698e7463b04",
+		},
+		{
+			entropy:  "7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f",
+			mnemonic: "legal winner thank year wave sausage worth useful legal winner thank yellow",
+			seed:     "2e8905819b8723fe2c1d161860e5ee1830318dbf49a83bd451cfb8440c28bd6fa457fe1296106559a3c80937a1c1069be3a3a5bd381ee6260e8d9739fce1f607",
+		},
+		{
+			entropy:  "80808080808080808080808080808080",
+			mnemonic: "letter advice cage absurd amount doctor acoustic avoid letter advice cage above",
+			seed:     "d71de856f81a8acc65e6fc851a38d4d7ec216fd0796d0a6827a3ad6ed5511a30fa280f12eb2e47ed2ac03b5c462a0358d18d69fe4f985ec81778c1b370b652a8",
+		},
+		{
+			entropy:  "ffffffffffffffffffffffffffffffff",
+			mnemonic: "zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrong",
+			seed:     "ac27495480225222079d7be181583751e86f571027b0497b5b5d11218e0a8a13332572917f0f8e5a589620c6f15b11c61dee327651a14c34e18231052e48c069",
+		},
+		{
+			entropy:  "000000000000000000000000000000000000000000000000",
+			mnemonic: "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon agent",
+			seed:     "035895f2f481b1b0f01fcf8c289c794660b289981a78f8106447707fdd9666ca06da5a9a565181599b79f53b844d8a71dd9f439c52a3d7b3e8a79c906ac845fa",
+		},
+		{
+			entropy:  "7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f",
+			mnemonic: "legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth useful legal will",
+			seed:     "f2b94508732bcbacbcc020faefecfc89feafa6649a5491b8c952cede496c214a0c7b3c392d168748f2d4a612bada0753b52a1c7ac53c1e93abd5c6320b9e95dd",
+		},
+		{
+			entropy:  "808080808080808080808080808080808080808080808080",
+			mnemonic: "letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic avoid letter always",
+			seed:     "107d7c02a5aa6f38c58083ff74f04c607c2d2c0ecc55501dadd72d025b751bc27fe913ffb796f841c49b1d33b610cf0e91d3aa239027f5e99fe4ce9e5088cd65",
+		},
+		{
+			entropy:  "ffffffffffffffffffffffffffffffffffffffffffffffff",
+			mnemonic: "zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo when",
+			seed:     "0cd6e5d827bb62eb8fc1e262254223817fd068a74b5b449cc2f667c3f1f985a76379b43348d952e2265b4cd129090758b3e3c2c49103b5051aac2eaeb890a528",
+		},
+		{
+			entropy:  "0000000000000000000000000000000000000000000000000000000000000000",
+			mnemonic: "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon art",
+			seed:     "bda85446c68413707090a52022edd26a1c9462295029f2e60cd7c4f2bbd3097170af7a4d73245cafa9c3cca8d561a7c3de6f5d4a10be8ed2a5e608d68f92fcc8",
+		},
+		{
+			entropy:  "7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f",
+			mnemonic: "legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth title",
+			seed:     "bc09fca1804f7e69da93c2f2028eb238c227f2e9dda30cd63699232578480a4021b146ad717fbb7e451ce9eb835f43620bf5c514db0f8add49f5d121449d3e87",
+		},
+		{
+			entropy:  "8080808080808080808080808080808080808080808080808080808080808080",
+			mnemonic: "letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic bless",
+			seed:     "c0c519bd0e91a2ed54357d9d1ebef6f5af218a153624cf4f2da911a0ed8f7a09e2ef61af0aca007096df430022f7a2b6fb91661a9589097069720d015e4e982f",
+		},
+		{
+			entropy:  "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+			mnemonic: "zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo vote",
+			seed:     "dd48c104698c30cfe2b6142103248622fb7bb0ff692eebb00089b32d22484e1613912f0a5b694407be899ffd31ed3992c456cdf60f5d4564b8ba3f05a69890ad",
+		},
+		{
+			entropy:  "77c2b00716cec7213839159e404db50d",
+			mnemonic: "jelly better achieve collect unaware mountain thought cargo oxygen act hood bridge",
+			seed:     "b5b6d0127db1a9d2226af0c3346031d77af31e918dba64287a1b44b8ebf63cdd52676f672a290aae502472cf2d602c051f3e6f18055e84e4c43897fc4e51a6ff",
+		},
+		{
+			entropy:  "b63a9c59a6e641f288ebc103017f1da9f8290b3da6bdef7b",
+			mnemonic: "renew stay biology evidence goat welcome casual join adapt armor shuffle fault little machine walk stumble urge swap",
+			seed:     "9248d83e06f4cd98debf5b6f010542760df925ce46cf38a1bdb4e4de7d21f5c39366941c69e1bdbf2966e0f6e6dbece898a0e2f0a4c2b3e640953dfe8b7bbdc5",
+		},
+		{
+			entropy:  "3e141609b97933b66a060dcddc71fad1d91677db872031e85f4c015c5e7e8982",
+			mnemonic: "dignity pass list indicate nasty swamp pool script soccer toe leaf photo multiply desk host tomato cradle drill spread actor shine dismiss champion exotic",
+			seed:     "ff7f3184df8696d8bef94b6c03114dbee0ef89ff938712301d27ed8336ca89ef9635da20af07d4175f2bf5f3de130f39c9d9e8dd0472489c19b1a020a940da67",
+		},
+		{
+			entropy:  "0460ef47585604c5660618db2e6a7e7f",
+			mnemonic: "afford alter spike radar gate glance object seek swamp infant panel yellow",
+			seed:     "65f93a9f36b6c85cbe634ffc1f99f2b82cbb10b31edc7f087b4f6cb9e976e9faf76ff41f8f27c99afdf38f7a303ba1136ee48a4c1e7fcd3dba7aa876113a36e4",
+		},
+		{
+			entropy:  "72f60ebac5dd8add8d2a25a797102c3ce21bc029c200076f",
+			mnemonic: "indicate race push merry suffer human cruise dwarf pole review arch keep canvas theme poem divorce alter left",
+			seed:     "3bbf9daa0dfad8229786ace5ddb4e00fa98a044ae4c4975ffd5e094dba9e0bb289349dbe2091761f30f382d4e35c4a670ee8ab50758d2c55881be69e327117ba",
+		},
+		{
+			entropy:  "2c85efc7f24ee4573d2b81a6ec66cee209b2dcbd09d8eddc51e0215b0b68e416",
+			mnemonic: "clutch control vehicle tonight unusual clog visa ice plunge glimpse recipe series open hour vintage deposit universe tip job dress radar refuse motion taste",
+			seed:     "fe908f96f46668b2d5b37d82f558c77ed0d69dd0e7e043a5b0511c48c2f1064694a956f86360c93dd04052a8899497ce9e985ebe0c8c52b955e6ae86d4ff4449",
+		},
+		{
+			entropy:  "eaebabb2383351fd31d703840b32e9e2",
+			mnemonic: "turtle front uncle idea crush write shrug there lottery flower risk shell",
+			seed:     "bdfb76a0759f301b0b899a1e3985227e53b3f51e67e3f2a65363caedf3e32fde42a66c404f18d7b05818c95ef3ca1e5146646856c461c073169467511680876c",
+		},
+		{
+			entropy:  "7ac45cfe7722ee6c7ba84fbc2d5bd61b45cb2fe5eb65aa78",
+			mnemonic: "kiss carry display unusual confirm curtain upgrade antique rotate hello void custom frequent obey nut hole price segment",
+			seed:     "ed56ff6c833c07982eb7119a8f48fd363c4a9b1601cd2de736b01045c5eb8ab4f57b079403485d1c4924f0790dc10a971763337cb9f9c62226f64fff26397c79",
+		},
+		{
+			entropy:  "4fa1a8bc3e6d80ee1316050e862c1812031493212b7ec3f3bb1b08f168cabeef",
+			mnemonic: "exile ask congress lamp submit jacket era scheme attend cousin alcohol catch course end lucky hurt sentence oven short ball bird grab wing top",
+			seed:     "095ee6f817b4c2cb30a5a797360a81a40ab0f9a4e25ecd672a3f58a0b5ba0687c096a6b14d2c0deb3bdefce4f61d01ae07417d502429352e27695163f7447a8c",
+		},
+		{
+			entropy:  "18ab19a9f54a9274f03e5209a2ac8a91",
+			mnemonic: "board flee heavy tunnel powder denial science ski answer betray cargo cat",
+			seed:     "6eff1bb21562918509c73cb990260db07c0ce34ff0e3cc4a8cb3276129fbcb300bddfe005831350efd633909f476c45c88253276d9fd0df6ef48609e8bb7dca8",
+		},
+		{
+			entropy:  "18a2e1d81b8ecfb2a333adcb0c17a5b9eb76cc5d05db91a4",
+			mnemonic: "board blade invite damage undo sun mimic interest slam gaze truly inherit resist great inject rocket museum chief",
+			seed:     "f84521c777a13b61564234bf8f8b62b3afce27fc4062b51bb5e62bdfecb23864ee6ecf07c1d5a97c0834307c5c852d8ceb88e7c97923c0a3b496bedd4e5f88a9",
+		},
+		{
+			entropy:  "15da872c95a13dd738fbf50e427583ad61f18fd99f628c417a61cf8343c90419",
+			mnemonic: "beyond stage sleep clip because twist token leaf atom beauty genius food business side grid unable middle armed observe pair crouch tonight away coconut",
+			seed:     "b15509eaa2d09d3efd3e006ef42151b30367dc6e3aa5e44caba3fe4d3e352e65101fbdb86a96776b91946ff06f8eac594dc6ee1d3e82a42dfe1b40fef6bcc3fd",
+		},
+	}
+}
+
+//nolint:dupword,lll // the test vectors, kept as upstream wrote them
+func badMnemonicSentences() []vector {
+	return []vector{
+		{mnemonic: "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon"},
+		{mnemonic: "legal winner thank year wave sausage worth useful legal winner thank yellow yellow"},
+		{mnemonic: "letter advice cage absurd amount doctor acoustic avoid letter advice caged above"},
+		{mnemonic: "zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo, wrong"},
+		{mnemonic: "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon"},
+		{mnemonic: "legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth useful legal will will will"},
+		{mnemonic: "letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic avoid letter always."},
+		{mnemonic: "zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo why"},
+		{mnemonic: "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon art art"},
+		{mnemonic: "legal winner thank year wave sausage worth useful legal winner thanks year wave worth useful legal winner thank year wave sausage worth title"},
+		{mnemonic: "letter advice cage absurd amount doctor acoustic avoid letters advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic bless"},
+		{mnemonic: "zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo voted"},
+		{mnemonic: "jello better achieve collect unaware mountain thought cargo oxygen act hood bridge"},
+		{mnemonic: "renew, stay, biology, evidence, goat, welcome, casual, join, adapt, armor, shuffle, fault, little, machine, walk, stumble, urge, swap"},
+		{mnemonic: "dignity pass list indicate nasty"},
+
+		// From issue 32
+		{mnemonic: "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon letter"},
+	}
+}
+
+func assertNil(t *testing.T, object any) {
+	t.Helper()
+
+	if object != nil {
+		t.Errorf("Expected nil, got %v", object)
+	}
+}
+
+func assertNotNil(t *testing.T, object any) {
+	t.Helper()
+
+	if object == nil {
+		t.Error("Expected not nil")
+	}
+}
+
+func assertTrue(t *testing.T, a bool) {
+	t.Helper()
+
+	if !a {
+		t.Error("Expected true, got false")
+	}
+}
+
+func assertFalse(t *testing.T, a bool) {
+	t.Helper()
+
+	if a {
+		t.Error("Expected false, got true")
+	}
+}
+
+func assertEqual(t *testing.T, a, b any) {
+	t.Helper()
+
+	if a != b {
+		t.Errorf("Objects not equal, expected `%s` and got `%s`", a, b)
+	}
+}
+
+func assertEqualString(t *testing.T, a, b string) {
+	t.Helper()
+
+	if a != b {
+		t.Errorf("Strings not equal, expected `%s` and got `%s`", a, b)
+	}
+}
+
+func assertEqualByteSlices(t *testing.T, a, b []byte) {
+	t.Helper()
+
+	if len(a) != len(b) {
+		t.Errorf("Byte slices not equal, expected %v and got %v", a, b)
+
+		return
+	}
+
+	for i := range a {
+		if a[i] != b[i] {
+			t.Errorf("Byte slices not equal, expected %v and got %v", a, b)
+
+			return
+		}
+	}
+}

internal/bip39/english_internal_test.go

@@ -0,0 +1,19 @@
+package bip39
+
+import (
+	"hash/crc32"
+	"testing"
+)
+
+func TestEnglishChecksum(t *testing.T) {
+	t.Parallel()
+
+	// Ensure word list is correct
+	// $ wget https://raw.githubusercontent.com/bitcoin/bips/master/bip-0039/english.txt
+	// $ crc32 english.txt
+	// c1dbd296
+	checksum := crc32.ChecksumIEEE([]byte(english))
+	if checksum != 0xc1dbd296 {
+		t.Error("english checksum invalid")
+	}
+}

internal/bip39/example_test.go

@@ -0,0 +1,30 @@
+package bip39_test
+
+import (
+	"encoding/hex"
+	"fmt"
+
+	"sneak.berlin/go/secret/internal/bip39"
+)
+
+//nolint:lll // the test vector and its output, kept as upstream wrote them
+func ExampleNewMnemonic() {
+	// the entropy can be any byte slice, generated how pleased,
+	// as long its bit size is a multiple of 32 and is within
+	// the inclusive range of {128,256}
+	entropy, _ := hex.DecodeString("066dca1a2bb7e8a1db2832148ce9933eea0f3ac9548d793112d9a95c9407efad")
+
+	// generate a mnemomic
+	mnemomic, _ := bip39.NewMnemonic(entropy)
+	fmt.Println(mnemomic)
+	// output:
+	// all hour make first leader extend hole alien behind guard gospel lava path output census museum junior mass reopen famous sing advance salt reform
+}
+
+//nolint:lll // the test vector and its output, kept as upstream wrote them
+func ExampleNewSeed() {
+	seed := bip39.NewSeed("all hour make first leader extend hole alien behind guard gospel lava path output census museum junior mass reopen famous sing advance salt reform", "TREZOR")
+	fmt.Println(hex.EncodeToString(seed))
+	// output:
+	// 26e975ec644423f4a4c4f4215ef09b4bd7ef924e85d1d17c4cf3f136c2863cf6df0a475045652c57eb5fb41513ca2a2d67722b77e954b4b3fc11f7590449191d
+}

internal/cli/cli.go

@@ -6,10 +6,10 @@ import (
 	"io"
 	"os"
 
-	"git.eeqj.de/sneak/secret/internal/secret"
 	"github.com/awnumar/memguard"
 	"github.com/spf13/afero"
 	"github.com/spf13/cobra"
+	"sneak.berlin/go/secret/internal/secret"
 )
 
 // Instance encapsulates all CLI functionality and state

internal/cli/cli_test.go

@@ -5,9 +5,9 @@ import (
 	"path/filepath"
 	"testing"
 
-	"git.eeqj.de/sneak/secret/internal/cli"
-	"git.eeqj.de/sneak/secret/internal/secret"
 	"github.com/spf13/afero"
+	"sneak.berlin/go/secret/internal/cli"
+	"sneak.berlin/go/secret/internal/secret"
 )
 
 func TestCLIInstanceStateDir(t *testing.T) {

internal/cli/completions.go

@@ -5,9 +5,9 @@ import (
 	"slices"
 	"strings"
 
-	"git.eeqj.de/sneak/secret/internal/vault"
 	"github.com/spf13/afero"
 	"github.com/spf13/cobra"
+	"sneak.berlin/go/secret/internal/vault"
 )
 
 // getSecretNamesCompletionFunc returns a completion function that provides

internal/cli/confirm.go

@@ -8,9 +8,9 @@ import (
 	"os"
 	"strings"
 
-	"git.eeqj.de/sneak/secret/internal/vault"
 	"github.com/spf13/cobra"
 	"golang.org/x/term"
+	"sneak.berlin/go/secret/internal/vault"
 )
 
 // Sentinel errors for asking the user to confirm a removal

internal/cli/confirm_test.go

@@ -24,12 +24,12 @@ import (
 	"testing"
 	"time"
 
-	"git.eeqj.de/sneak/secret/internal/secret"
-	"git.eeqj.de/sneak/secret/internal/vault"
 	"github.com/spf13/afero"
 	"github.com/spf13/cobra"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/secret/internal/secret"
+	"sneak.berlin/go/secret/internal/vault"
 )
 
 const (
@@ -353,9 +353,9 @@ func TestRemovalWithoutTerminalFailsAtOnce(t *testing.T) {
 // for its answer, another command can take the state directory lock and
 // change the secret, and that the removal then removes nothing, since the
 // secret is no longer what the question named.
+//
+//nolint:paralleltest // times commands against the in-memory lock all tests share
 func TestRemovalAsksWithoutHoldingLock(t *testing.T) {
-	t.Parallel()
-
 	r := newRemoval(t, "rm")
 
 	answers, answerWriter := io.Pipe()

internal/cli/create_vault_test.go

@@ -5,17 +5,18 @@ import (
 	"io"
 	"maps"
 	"os"
+	"os/exec"
 	"slices"
 	"strings"
 	"testing"
 
-	"git.eeqj.de/sneak/secret/internal/cli"
-	"git.eeqj.de/sneak/secret/internal/secret"
-	"git.eeqj.de/sneak/secret/internal/vault"
 	"github.com/awnumar/memguard"
 	"github.com/spf13/afero"
 	"github.com/spf13/cobra"
 	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/secret/internal/cli"
+	"sneak.berlin/go/secret/internal/secret"
+	"sneak.berlin/go/secret/internal/vault"
 )
 
 // TestCreateExistingVaultChangesNothing is a regression test for
@@ -188,12 +189,43 @@ func TestStopAtPassphrasePromptLeavesNothing(t *testing.T) {
 
 			err := tt.run(c)
 
-			require.ErrorContains(t, err, "failed to read passphrase")
+			require.ErrorIs(t, err, secret.ErrPassphraseNotRead)
 			require.Equal(t, before, snapshotStateDir(t, tt.fs))
 		})
 	}
 }
 
+// TestMnemonicNotReadNamesOnlyMnemonic is a regression test for
+// https://git.eeqj.de/sneak/secret/issues/115: `secret init` without
+// SB_SECRET_MNEMONIC and with a stdin that is not a terminal said "failed to
+// read mnemonic: failed to read passphrase: ...". The error must wrap
+// secret.ErrMnemonicNotRead and name the mnemonic only. The message is
+// pinned on the built binary, whose stdin is surely not a terminal.
+func TestMnemonicNotReadNamesOnlyMnemonic(t *testing.T) {
+	t.Parallel()
+
+	c := cli.NewCLIInstanceWithStateDir(afero.NewMemMapFs(), testStateDir)
+	require.ErrorIs(t, c.Init(discardCmd()), secret.ErrMnemonicNotRead)
+
+	stateDir := t.TempDir()
+
+	//nolint:gosec // G204: test executes the freshly built secret binary
+	cmd := exec.CommandContext(t.Context(), secretBinaryPath(t), "init")
+	cmd.Env = []string{
+		secret.EnvStateDir + "=" + stateDir,
+		"PATH=" + os.Getenv("PATH"),
+		"HOME=" + os.Getenv("HOME"),
+	}
+
+	output, err := cmd.CombinedOutput()
+	require.Error(t, err)
+
+	require.Equal(t, "Initialized secrets manager at: "+stateDir+"\n"+
+		"Error: failed to read mnemonic: stdin is not a terminal (piped input "+
+		"or script). Please set the SB_SECRET_MNEMONIC environment variable "+
+		"or run interactively\n", string(output))
+}
+
 // TestStopDuringCreateLeavesWholeVaultOrNone is a regression test for
 // https://git.eeqj.de/sneak/secret/issues/105: `secret init` or `secret vault
 // create` killed after the passphrase prompt but before the unlocker was

internal/cli/crypto.go

@@ -7,17 +7,16 @@ import (
 	"os"
 
 	"filippo.io/age"
-	"git.eeqj.de/sneak/secret/internal/secret"
-	"git.eeqj.de/sneak/secret/internal/vault"
 	"github.com/awnumar/memguard"
 	"github.com/spf13/cobra"
+	"sneak.berlin/go/secret/internal/secret"
+	"sneak.berlin/go/secret/internal/vault"
 )
 
 // Sentinel errors for encrypt/decrypt operations
 var (
 	errNotAgeSecretKey = errors.New(
 		"does not contain a valid age secret key")
-	errSecretDoesNotExist = errors.New("does not exist")
 )
 
 // newCryptoCmd builds an encrypt/decrypt command with input/output flags
@@ -245,7 +244,7 @@ func (cli *Instance) Decrypt(secretName, inputFile, outputFile string) error {
 	}
 
 	if !exists {
-		return fmt.Errorf("secret '%s' %w", secretName, errSecretDoesNotExist)
+		return fmt.Errorf("secret '%s' %w", secretName, vault.ErrSecretNotFound)
 	}
 
 	// Get the age secret key from the secret

internal/cli/entry_test.go

@@ -8,13 +8,12 @@ import (
 	"path/filepath"
 	"strings"
 	"testing"
-	"time"
 
-	"git.eeqj.de/sneak/secret/internal/cli"
-	"git.eeqj.de/sneak/secret/internal/secret"
 	"github.com/awnumar/memguard"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/secret/internal/cli"
+	"sneak.berlin/go/secret/internal/secret"
 )
 
 // Entry must return its exit code rather than exit, so that its deferred
@@ -52,7 +51,7 @@ func TestInterruptExitsThroughMemguard(t *testing.T) {
 
 	const waitingForValue = "Reading secret value from stdin"
 
-	ctx, cancel := context.WithTimeout(t.Context(), time.Minute)
+	ctx, cancel := context.WithTimeout(t.Context(), commandWait)
 	defer cancel()
 
 	wd, err := filepath.Abs("../..")

internal/cli/errors_test.go

@@ -0,0 +1,62 @@
+package cli_test
+
+import (
+	"testing"
+
+	"github.com/spf13/cobra"
+	"sneak.berlin/go/secret/internal/cli"
+	"sneak.berlin/go/secret/internal/vault"
+)
+
+// TestMissingSecretOrVaultErrors checks that a command that finds no such
+// secret or vault returns the vault package's error for it, as `secret get`
+// does, and leaves the vaults unchanged. "default" is the current vault, and
+// both vaults hold the secret "x".
+func TestMissingSecretOrVaultErrors(t *testing.T) {
+	t.Parallel()
+
+	before := snapshotStateDir(t, newTwoVaultFs(t))
+
+	tests := []struct {
+		command string
+		want    error
+		run     func(c *cli.Instance) error
+	}{
+		{
+			"rm --force nosuch", vault.ErrSecretNotFound,
+			func(c *cli.Instance) error {
+				return c.RemoveSecret(&cobra.Command{}, "nosuch", true)
+			},
+		},
+		{
+			"version rm --force nosuch", vault.ErrSecretNotFound,
+			func(c *cli.Instance) error {
+				return c.RemoveVersion(&cobra.Command{}, "nosuch", "20260101.001", true)
+			},
+		},
+		{
+			"mv --force work:nosuch default", vault.ErrSecretNotFound,
+			func(c *cli.Instance) error {
+				return c.MoveSecret(&cobra.Command{}, "work:nosuch", "default", true)
+			},
+		},
+		{
+			"decrypt nosuch", vault.ErrSecretNotFound,
+			func(c *cli.Instance) error { return c.Decrypt("nosuch", "", "") },
+		},
+		{
+			"vault rm --force nosuch", vault.ErrVaultNotFound,
+			func(c *cli.Instance) error {
+				return c.RemoveVault(&cobra.Command{}, "nosuch", true)
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.command, func(t *testing.T) {
+			t.Parallel()
+
+			requireRejectedAndUnchanged(t, before, tt.want, tt.run)
+		})
+	}
+}

internal/cli/generate.go

@@ -7,10 +7,10 @@ import (
 	"math/big"
 	"os"
 
-	"git.eeqj.de/sneak/secret/internal/vault"
 	"github.com/awnumar/memguard"
 	"github.com/spf13/cobra"
-	"github.com/tyler-smith/go-bip39"
+	"sneak.berlin/go/secret/internal/bip39"
+	"sneak.berlin/go/secret/internal/vault"
 )
 
 const (
@@ -21,10 +21,6 @@ const (
 // Sentinel errors for secret generation
 var (
 	errLengthTooSmall        = errors.New("length must be at least 1")
-	errLengthNotPositive        = errors.New("length must be positive")
-	errMnemonicTypeNotSupported = errors.New(
-		"mnemonic type not supported for secret generation, " +
-			"use 'secret generate mnemonic' instead")
 	errUnsupportedSecretType = errors.New("unsupported type")
 )
 
@@ -148,7 +144,8 @@ func (cli *Instance) GenerateSecret(
 	case "alnum":
 		secretValue, err = generateRandomAlnum(length)
 	case "mnemonic":
-		return errMnemonicTypeNotSupported
+		return fmt.Errorf("%w: mnemonic (use 'secret generate mnemonic' instead)",
+			errUnsupportedSecretType)
 	default:
 		return fmt.Errorf("%w: %s (supported: base58, alnum)",
 			errUnsupportedSecretType, secretType)
@@ -204,8 +201,8 @@ func generateRandomAlnum(length int) (string, error) {
 // generateRandomString generates a random string of the specified length
 // using the given character set
 func generateRandomString(length int, charset string) (string, error) {
-	if length <= 0 {
-		return "", errLengthNotPositive
+	if length < 1 {
+		return "", errLengthTooSmall
 	}
 
 	result := make([]byte, length)

internal/cli/info.go

@@ -10,11 +10,11 @@ import (
 	"strings"
 	"time"
 
-	"git.eeqj.de/sneak/secret/internal/vault"
 	"github.com/dustin/go-humanize"
 	"github.com/fatih/color"
 	"github.com/spf13/afero"
 	"github.com/spf13/cobra"
+	"sneak.berlin/go/secret/internal/vault"
 )
 
 // Version info - these are set at build time

internal/cli/info_helper.go

@@ -4,8 +4,8 @@ import (
 	"path/filepath"
 	"time"
 
-	"git.eeqj.de/sneak/secret/internal/secret"
 	"github.com/spf13/afero"
+	"sneak.berlin/go/secret/internal/secret"
 )
 
 // vaultStats accumulates statistics while walking vault directories

internal/cli/init.go

@@ -8,11 +8,11 @@ import (
 	"os"
 	"strings"
 
-	"git.eeqj.de/sneak/secret/internal/secret"
-	"git.eeqj.de/sneak/secret/internal/vault"
 	"github.com/awnumar/memguard"
 	"github.com/spf13/cobra"
-	"github.com/tyler-smith/go-bip39"
+	"sneak.berlin/go/secret/internal/bip39"
+	"sneak.berlin/go/secret/internal/secret"
+	"sneak.berlin/go/secret/internal/vault"
 )
 
 // errPassphraseMismatch is returned when passphrase confirmation fails
@@ -55,11 +55,11 @@ func (cli *Instance) promptMnemonic() (*memguard.LockedBuffer, func(), error) {
 	secret.Debug("Prompting user for mnemonic phrase")
 
 	// Read mnemonic securely without echo
-	mnemonicBuffer, err := secret.ReadPassphrase("Enter your BIP39 mnemonic phrase: ")
+	mnemonicBuffer, err := secret.ReadMnemonic("Enter your BIP39 mnemonic phrase: ")
 	if err != nil {
 		secret.Debug("Failed to read mnemonic from stdin", "error", err)
 
-		return nil, nil, fmt.Errorf("failed to read mnemonic: %w", err)
+		return nil, nil, err
 	}
 
 	fmt.Fprintln(os.Stderr) // Add newline after hidden input

internal/cli/input_errors_test.go

@@ -0,0 +1,67 @@
+//nolint:testpackage // white-box test of unexported internals
+package cli
+
+import (
+	"testing"
+
+	"github.com/awnumar/memguard"
+	"github.com/spf13/afero"
+	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/secret/internal/vault"
+)
+
+// TestInvalidMnemonicError checks that every command that takes a mnemonic
+// returns errInvalidMnemonicPhrase for one that is not valid BIP39. The vault
+// "other" has no long-term key, as vault import needs.
+func TestInvalidMnemonicError(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		command string
+		run     func(c *Instance) error
+	}{
+		{"secret init", func(c *Instance) error { return c.Init(c.cmd) }},
+		{"secret vault create work", func(c *Instance) error {
+			return c.CreateVault(c.cmd, "work")
+		}},
+		{"secret vault import other", func(c *Instance) error {
+			return c.VaultImport(c.cmd, "other")
+		}},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.command, func(t *testing.T) {
+			t.Parallel()
+
+			fs := afero.NewMemMapFs()
+			_, err := vault.CreateVault(fs, listTestStateDir, "other", nil, nil)
+			require.NoError(t, err)
+
+			instance, _ := newTestInstance(fs)
+			instance.Mnemonic = memguard.NewBufferFromBytes([]byte("not a mnemonic"))
+			t.Cleanup(instance.Mnemonic.Destroy)
+
+			require.ErrorIs(t, tt.run(instance), errInvalidMnemonicPhrase)
+		})
+	}
+}
+
+// TestGenerateSecretErrors checks that `secret generate secret` gives one
+// error for a length below 1 and one for a type it cannot generate.
+func TestGenerateSecretErrors(t *testing.T) {
+	t.Parallel()
+
+	instance, cmd := newTestInstance(afero.NewMemMapFs())
+
+	err := instance.GenerateSecret(cmd, "x", 0, "base58", false)
+	require.ErrorIs(t, err, errLengthTooSmall)
+
+	_, err = generateRandomString(0, "ab")
+	require.ErrorIs(t, err, errLengthTooSmall)
+
+	err = instance.GenerateSecret(cmd, "x", defaultSecretLength, "mnemonic", false)
+	require.ErrorIs(t, err, errUnsupportedSecretType)
+
+	err = instance.GenerateSecret(cmd, "x", defaultSecretLength, "hex", false)
+	require.ErrorIs(t, err, errUnsupportedSecretType)
+}

internal/cli/integration_test.go

@@ -17,21 +17,27 @@ import (
 	"testing"
 	"time"
 
-	"git.eeqj.de/sneak/secret/internal/cli"
-	"git.eeqj.de/sneak/secret/internal/secret"
-	"git.eeqj.de/sneak/secret/internal/vault"
-	"git.eeqj.de/sneak/secret/pkg/agehd"
 	"github.com/awnumar/memguard"
 	"github.com/creack/pty"
 	"github.com/spf13/afero"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/secret/internal/cli"
+	"sneak.berlin/go/secret/internal/secret"
+	"sneak.berlin/go/secret/internal/vault"
+	"sneak.berlin/go/secret/pkg/agehd"
 )
 
 const (
 	// testMnemonic is a standard BIP39 mnemonic used for testing
 	//nolint:dupword // BIP39 test mnemonic intentionally repeats a word
 	testMnemonic = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about"
+
+	// commandWait is how long a test lets the secret binary run before it
+	// kills it and fails. It stays well under the 30 seconds script/test
+	// gives the whole package, so a command that hangs fails the test with
+	// the test's own message instead of Go's timeout panic.
+	commandWait = 10 * time.Second
 )
 
 // errEmptyValue indicates a concurrent reader received an empty secret value.
@@ -52,8 +58,12 @@ func runSecretWithStdin(stdin string, env map[string]string, args ...string) (st
 	return cli.ExecuteCommandInProcess(args, stdin, env)
 }
 
-// TestMain runs before all tests and ensures the binary is built
+// TestMain runs before all tests and ensures the binary is built. It also
+// makes passphrase encryption in the tests cheap (see
+// secret.ScryptWorkFactor); the binary keeps age's work factor.
 func TestMain(m *testing.M) {
+	secret.ScryptWorkFactor = 1
+
 	// Get the current working directory
 	wd, err := os.Getwd()
 	if err != nil {
@@ -1216,9 +1226,8 @@ func test12bMoveSecret(t *testing.T, testMnemonic string, runSecret func(...stri
 
 	// Test error cases
 	// Try to move non-existent secret
-	output, err = runSecret("move", "test/nonexistent", "test/destination")
-	require.Error(t, err, "move non-existent should fail")
-	assert.Contains(t, output, "not found", "should indicate source not found")
+	_, err = runSecret("move", "test/nonexistent", "test/destination")
+	require.ErrorIs(t, err, vault.ErrSecretNotFound, "move non-existent should fail")
 
 	// Try to move to existing destination
 	_, err = runSecretWithStdin("dest-value", map[string]string{
@@ -1226,9 +1235,8 @@ func test12bMoveSecret(t *testing.T, testMnemonic string, runSecret func(...stri
 	}, "add", "test/existing-dest")
 	require.NoError(t, err, "add test/existing-dest should succeed")
 
-	output, err = runSecret("move", "test/renamed", "test/existing-dest")
-	require.Error(t, err, "move to existing destination should fail")
-	assert.Contains(t, output, "already exists", "should indicate destination exists")
+	_, err = runSecret("move", "test/renamed", "test/existing-dest")
+	require.ErrorIs(t, err, vault.ErrSecretExists, "move to existing destination should fail")
 
 	// Verify the source wasn't removed since move failed
 	getOutput, err = runSecretWithEnv(map[string]string{
@@ -1933,12 +1941,11 @@ func test23ErrorHandling(t *testing.T, tempDir, secretPath, testMnemonic string,
 
 	// Import to non-existent vault with test passphrase
 	testPassphrase := "test-passphrase-123" // Define testPassphrase locally
-	output, err := runSecretWithEnv(map[string]string{
+	_, err = runSecretWithEnv(map[string]string{
 		secret.EnvMnemonic:         testMnemonic,
 		secret.EnvUnlockPassphrase: testPassphrase,
 	}, "vault", "import", "nonexistent")
-	require.Error(t, err, "import to non-existent vault should fail")
-	assert.Contains(t, output, "does not exist", "should indicate vault doesn't exist")
+	require.ErrorIs(t, err, vault.ErrVaultNotFound, "import to non-existent vault should fail")
 
 	// Get specific version that doesn't exist
 	_, err = runSecretWithEnv(map[string]string{
@@ -1947,11 +1954,10 @@ func test23ErrorHandling(t *testing.T, tempDir, secretPath, testMnemonic string,
 	require.ErrorIs(t, err, vault.ErrVersionNotFound, "get non-existent version should fail")
 
 	// Promote non-existent version
-	output, err = runSecretWithEnv(map[string]string{
+	_, err = runSecretWithEnv(map[string]string{
 		secret.EnvMnemonic: testMnemonic,
 	}, "version", "promote", "database/password", "99999999.999")
-	require.Error(t, err, "promote non-existent version should fail")
-	assert.Contains(t, output, "not found", "should indicate version not found")
+	require.ErrorIs(t, err, vault.ErrVersionNotFound, "promote non-existent version should fail")
 }
 
 func test24EnvironmentVariables(t *testing.T, tempDir, secretPath, testMnemonic, testPassphrase string) {
@@ -2583,7 +2589,7 @@ func TestRemoveWithoutTerminalFailsAtOnce(t *testing.T) {
 		_ = stdin.Close()
 	}()
 
-	ctx, cancel := context.WithTimeout(t.Context(), time.Minute)
+	ctx, cancel := context.WithTimeout(t.Context(), commandWait)
 	defer cancel()
 
 	cmd, secretDir := secretRmCommand(ctx, t)
@@ -2601,7 +2607,13 @@ func TestRemoveWithoutTerminalFailsAtOnce(t *testing.T) {
 // and stderr, not both: whether it asks must depend on stdin alone, where
 // the answer is read from. pty.Open returns the two ends of a new terminal:
 // tty is the end a program uses as its terminal, and ptmx the end the test
-// reads what the terminal shows from and types into.
+// reads what the terminal shows from and types into. Reading ptmx stops at
+// the context's deadline, commandWait (10 seconds) after the test starts,
+// when secret rm is killed too, so a terminal that stays open fails the test
+// then with its own message instead of hanging it. The deadline works only
+// while ptmx stays non-blocking, as pty.Open of the github.com/creack/pty
+// commit in go.mod leaves it: calling ptmx.Fd() or going back to v1.1.24
+// makes the read ignore the deadline, without any error.
 
 // TestRemoveIgnoresTerminalOnStdout runs `echo y | secret rm x` at a
 // terminal. stdin is a pipe, so nobody can answer there, and the command
@@ -2609,7 +2621,7 @@ func TestRemoveWithoutTerminalFailsAtOnce(t *testing.T) {
 func TestRemoveIgnoresTerminalOnStdout(t *testing.T) {
 	t.Parallel()
 
-	ctx, cancel := context.WithTimeout(t.Context(), time.Minute)
+	ctx, cancel := context.WithTimeout(t.Context(), commandWait)
 	defer cancel()
 
 	cmd, secretDir := secretRmCommand(ctx, t)
@@ -2619,6 +2631,9 @@ func TestRemoveIgnoresTerminalOnStdout(t *testing.T) {
 
 	defer func() { _ = ptmx.Close() }()
 
+	deadline, _ := ctx.Deadline()
+	require.NoError(t, ptmx.SetReadDeadline(deadline))
+
 	cmd.Stdin = strings.NewReader("y\n")
 	cmd.Stdout = tty
 	cmd.Stderr = tty
@@ -2628,9 +2643,16 @@ func TestRemoveIgnoresTerminalOnStdout(t *testing.T) {
 	_ = tty.Close()
 
 	// The read ends once secret rm has exited and so closed the terminal.
-	shown, _ := io.ReadAll(ptmx)
+	shown, err := io.ReadAll(ptmx)
+	require.NotErrorIs(t, err, os.ErrDeadlineExceeded,
+		"the terminal was still open %s after secret rm started: %s",
+		commandWait, shown)
 
-	require.Error(t, cmd.Wait())
+	err = cmd.Wait()
+
+	require.NoError(t, ctx.Err(), "secret rm did not exit within %s",
+		commandWait)
+	require.Error(t, err)
 	assert.Contains(t, string(shown), "pass --force")
 	assert.DirExists(t, secretDir)
 }
@@ -2640,7 +2662,7 @@ func TestRemoveIgnoresTerminalOnStdout(t *testing.T) {
 func TestRemoveAsksAtTerminalOnStdin(t *testing.T) {
 	t.Parallel()
 
-	ctx, cancel := context.WithTimeout(t.Context(), time.Minute)
+	ctx, cancel := context.WithTimeout(t.Context(), commandWait)
 	defer cancel()
 
 	cmd, secretDir := secretRmCommand(ctx, t)
@@ -2650,6 +2672,9 @@ func TestRemoveAsksAtTerminalOnStdin(t *testing.T) {
 
 	defer func() { _ = ptmx.Close() }()
 
+	deadline, _ := ctx.Deadline()
+	require.NoError(t, ptmx.SetReadDeadline(deadline))
+
 	cmd.Stdin = tty
 	// Not a file, so exec.Cmd connects stdout through a pipe.
 	cmd.Stdout = io.Discard
@@ -2667,7 +2692,8 @@ func TestRemoveAsksAtTerminalOnStdin(t *testing.T) {
 	terminal := bufio.NewReader(ptmx)
 	for !bytes.HasSuffix(shown, []byte("[y/N] ")) {
 		char, err = terminal.ReadByte()
-		require.NoError(t, err, "secret rm ended without asking: %s", shown)
+		require.NoError(t, err, "secret rm did not ask on the terminal: %s",
+			shown)
 
 		shown = append(shown, char)
 	}

internal/cli/leftovers_test.go

@@ -4,12 +4,12 @@ import (
 	"io"
 	"testing"
 
-	"git.eeqj.de/sneak/secret/internal/cli"
-	"git.eeqj.de/sneak/secret/internal/secret"
-	"git.eeqj.de/sneak/secret/internal/vault"
 	"github.com/spf13/afero"
 	"github.com/spf13/cobra"
 	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/secret/internal/cli"
+	"sneak.berlin/go/secret/internal/secret"
+	"sneak.berlin/go/secret/internal/vault"
 )
 
 // TestLeftoversRemovedByNextChangingCommand is a regression test for

internal/cli/lock_test.go

@@ -13,13 +13,13 @@ import (
 	"testing"
 	"time"
 
-	"git.eeqj.de/sneak/secret/internal/secret"
-	"git.eeqj.de/sneak/secret/internal/vault"
 	"github.com/awnumar/memguard"
 	"github.com/spf13/afero"
 	"github.com/spf13/cobra"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/secret/internal/secret"
+	"sneak.berlin/go/secret/internal/vault"
 )
 
 const (
@@ -94,9 +94,9 @@ func numbered(prefix string, count int) []string {
 // lock, adds of a new secret all find it absent and replace each other, and
 // forced adds read the same highest version number and overwrite each
 // other's version. With it they behave as if run one after another.
-//
-//nolint:paralleltest // times commands against the in-memory lock all tests share
 func TestConcurrentAddsKeepEveryVersion(t *testing.T) {
+	t.Parallel()
+
 	mnemonic := testMnemonicBuffer(t)
 
 	const adds = 8
@@ -110,6 +110,8 @@ func TestConcurrentAddsKeepEveryVersion(t *testing.T) {
 		{"real", afero.NewOsFs(), t.TempDir()},
 	} {
 		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
 			_, err := vault.CreateVault(tc.fs, tc.stateDir, "default", mnemonic, nil)
 			require.NoError(t, err)
 
@@ -235,9 +237,9 @@ func TestEncryptPipedIntoAdd(t *testing.T) {
 
 // TestFailedCommandReleasesLock checks that a command failing after it
 // took the state directory lock leaves the lock free for the next command.
+//
+//nolint:paralleltest // times commands against the in-memory lock all tests share
 func TestFailedCommandReleasesLock(t *testing.T) {
-	t.Parallel()
-
 	fs := afero.NewMemMapFs()
 	cli := NewCLIInstanceWithStateDir(fs, testStateDir)
 

internal/cli/move_test.go

@@ -5,12 +5,12 @@ import (
 	"path/filepath"
 	"testing"
 
-	"git.eeqj.de/sneak/secret/internal/cli"
-	"git.eeqj.de/sneak/secret/internal/vault"
 	"github.com/awnumar/memguard"
 	"github.com/spf13/afero"
 	"github.com/spf13/cobra"
 	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/secret/internal/cli"
+	"sneak.berlin/go/secret/internal/vault"
 )
 
 // TestRejectedMoveWithinVaultLeavesStateUnchanged is a regression test for
@@ -45,15 +45,6 @@ func TestRejectedMoveWithinVaultLeavesStateUnchanged(t *testing.T) {
 		{`mv --force work:x ""`, workX, "", true, ontoItself},
 		// "work" is a vault name, so the destination is work:x.
 		{"mv --force work:x work", workX, "work", true, ontoItself},
-		{
-			"mv work:nosuch work:y", "work:nosuch", "work:y", false,
-			"secret 'nosuch' not found",
-		},
-		// Only an existing vault is used.
-		{
-			"mv --force nosuch:x nosuch:y", "nosuch:x", "nosuch:y", true,
-			"vault 'nosuch' does not exist",
-		},
 	}
 
 	for _, tt := range tests {
@@ -70,6 +61,33 @@ func TestRejectedMoveWithinVaultLeavesStateUnchanged(t *testing.T) {
 		})
 	}
 
+	missing := []struct {
+		command      string
+		source, dest string
+		force        bool
+		want         error
+	}{
+		{
+			"mv work:nosuch work:y", "work:nosuch", "work:y", false,
+			vault.ErrSecretNotFound,
+		},
+		// Only an existing vault is used.
+		{
+			"mv --force nosuch:x nosuch:y", "nosuch:x", "nosuch:y", true,
+			vault.ErrVaultNotFound,
+		},
+	}
+
+	for _, tt := range missing {
+		t.Run(tt.command, func(t *testing.T) {
+			t.Parallel()
+
+			requireRejectedAndUnchanged(t, before, tt.want, func(c *cli.Instance) error {
+				return c.MoveSecret(&cobra.Command{}, tt.source, tt.dest, tt.force)
+			})
+		})
+	}
+
 	// Each of these spells "work" a second way. The spelling is not a valid
 	// vault name, so the move is not taken for a move between two vaults,
 	// which would delete the destination, here the source.

internal/cli/path_traversal_test.go

@@ -9,13 +9,13 @@ import (
 	"sync"
 	"testing"
 
-	"git.eeqj.de/sneak/secret/internal/cli"
-	"git.eeqj.de/sneak/secret/internal/secret"
-	"git.eeqj.de/sneak/secret/internal/vault"
 	"github.com/awnumar/memguard"
 	"github.com/spf13/afero"
 	"github.com/spf13/cobra"
 	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/secret/internal/cli"
+	"sneak.berlin/go/secret/internal/secret"
+	"sneak.berlin/go/secret/internal/vault"
 )
 
 const (
@@ -297,18 +297,8 @@ func TestInvalidVersionLeavesVaultsUnchanged(t *testing.T) {
 	for _, tt := range commands {
 		for _, version := range []string{"", ".", "..", "../../..", "a/b"} {
 			t.Run(fmt.Sprintf("%s %q", tt.command, version), func(t *testing.T) {
-				fs := newFsFromSnapshot(t, before)
-
-				err := tt.run(cli.NewCLIInstanceWithStateDir(fs, testStateDir), version)
-
-				require.Equal(t, before, snapshotStateDir(t, fs))
-
-				// Compared as text: `version rm` and `version promote` return
-				// internal/cli's own error of this text, which errors.Is does
-				// not match to vault.ErrVersionNotFound.
-				want := fmt.Errorf("version '%s' %w '%s'",
-					version, vault.ErrVersionNotFound, "x")
-				require.EqualError(t, err, want.Error())
+				requireRejectedAndUnchanged(t, before, vault.ErrVersionNotFound,
+					func(c *cli.Instance) error { return tt.run(c, version) })
 			})
 		}
 	}

internal/cli/root.go

@@ -3,11 +3,11 @@ package cli
 import (
 	"os"
 
-	"git.eeqj.de/sneak/secret/internal/secret"
 	"github.com/awnumar/memguard"
 	"github.com/spf13/cobra"
 	"golang.org/x/sys/unix"
 	"golang.org/x/term"
+	"sneak.berlin/go/secret/internal/secret"
 )
 
 // Entry runs the secret CLI and returns the process exit code. It wipes

internal/cli/secrets.go

@@ -11,11 +11,11 @@ import (
 	"slices"
 	"strings"
 
-	"git.eeqj.de/sneak/secret/internal/secret"
-	"git.eeqj.de/sneak/secret/internal/vault"
 	"github.com/awnumar/memguard"
 	"github.com/spf13/afero"
 	"github.com/spf13/cobra"
+	"sneak.berlin/go/secret/internal/secret"
+	"sneak.berlin/go/secret/internal/vault"
 )
 
 const (
@@ -33,12 +33,6 @@ const (
 // Sentinel errors for secret operations
 var (
 	errSecretTooLarge              = errors.New("secret too large: exceeds 100MB limit")
-	errSecretFileTooLarge = errors.New(
-		"secret file too large: exceeds 100MB limit")
-	errSecretNotFound      = errors.New("not found")
-	errSecretExistsNoForce = errors.New(
-		"already exists (use --force to overwrite)")
-	errVaultDoesNotExist           = errors.New("does not exist")
 	errCrossVaultSourceUnqualified = errors.New(
 		"source must specify vault (e.g., vault:secret) for cross-vault move")
 	errMoveOntoItself = errors.New("cannot be moved onto itself")
@@ -673,10 +667,6 @@ func (cli *Instance) ImportSecret(
 
 	buffers, totalSize, err := readSecretFromReader(file)
 	if err != nil {
-		if errors.Is(err, errSecretTooLarge) {
-			return errSecretFileTooLarge
-		}
-
 		return fmt.Errorf("failed to read secret from file %s: %w", sourceFile, err)
 	}
 	defer destroyBuffers(buffers)
@@ -776,7 +766,7 @@ func (cli *Instance) findSecretToRemove(
 
 	if !exists {
 		return secretToRemove{},
-			fmt.Errorf("secret '%s' %w", secretName, errSecretNotFound)
+			fmt.Errorf("secret '%s' %w", secretName, vault.ErrSecretNotFound)
 	}
 
 	// A secret without a versions directory has no versions, and can
@@ -907,7 +897,7 @@ func (cli *Instance) existingVault(name string) (*vault.Vault, error) {
 	}
 
 	if !slices.Contains(vaults, name) {
-		return nil, fmt.Errorf("vault '%s' %w", name, errVaultDoesNotExist)
+		return nil, fmt.Errorf("vault '%s' %w", name, vault.ErrVaultNotFound)
 	}
 
 	return vault.NewVault(cli.fs, cli.stateDir, name), nil
@@ -938,7 +928,7 @@ func (cli *Instance) moveSecretWithinVault(
 	}
 
 	if !exists {
-		return fmt.Errorf("secret '%s' %w", source, errSecretNotFound)
+		return fmt.Errorf("secret '%s' %w", source, vault.ErrSecretNotFound)
 	}
 
 	destEncoded := strings.ReplaceAll(dest, "/", "%")
@@ -963,7 +953,8 @@ func (cli *Instance) moveSecretWithinVault(
 
 	if exists {
 		if !force {
-			return fmt.Errorf("secret '%s' %w", dest, errSecretExistsNoForce)
+			return fmt.Errorf("secret '%s' %w (use --force to overwrite)",
+				dest, vault.ErrSecretExists)
 		}
 
 		err = secret.RemoveDirAtomic(cli.fs, destDir)
@@ -1028,7 +1019,7 @@ func (cli *Instance) moveSecretCrossVault(
 	exists, err := afero.DirExists(cli.fs, srcSecretDir)
 	if err != nil || !exists {
 		return fmt.Errorf("secret '%s' %w in vault '%s'",
-			srcSecretName, errSecretNotFound, srcVault.Name)
+			srcSecretName, vault.ErrSecretNotFound, srcVault.Name)
 	}
 
 	// The source is removed after the copy, so a destination that is the

internal/cli/secrets_size_test.go

@@ -10,57 +10,17 @@ import (
 	"strings"
 	"testing"
 
-	"git.eeqj.de/sneak/secret/internal/vault"
-	"git.eeqj.de/sneak/secret/pkg/agehd"
 	"github.com/spf13/afero"
 	"github.com/spf13/cobra"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"golang.org/x/sys/unix"
+	"sneak.berlin/go/secret/internal/vault"
+	"sneak.berlin/go/secret/pkg/agehd"
 )
 
 // testVaultName is the vault name used by the size tests.
 const testVaultName = "test-vault"
 
-// lockedBytesPerSecretByte bounds the locked memory that storing a secret
-// holds at once: the buffers it is read into reach up to 1.5 times its
-// size, and they are then copied into one more buffer of its size.
-const lockedBytesPerSecretByte = 3
-
-// skipIfLockedMemoryTooLow skips the test when this process cannot lock
-// the memory a secret of size bytes needs, found by locking a buffer of
-// that size and releasing it. memguard panics, ending the whole test run,
-// when it cannot lock a buffer, and a plain `docker build .` runs the
-// tests under an 8 MiB locked-memory limit (RLIMIT_MEMLOCK). A process
-// allowed to lock past that limit runs every case.
-func skipIfLockedMemoryTooLow(t *testing.T, size int) {
-	t.Helper()
-
-	need := lockedBytesPerSecretByte * size
-
-	buf, err := unix.Mmap(-1, 0, need,
-		unix.PROT_READ|unix.PROT_WRITE, unix.MAP_PRIVATE|unix.MAP_ANON)
-	require.NoError(t, err)
-
-	lockErr := unix.Mlock(buf)
-
-	// Unmapping the buffer also unlocks it.
-	err = unix.Munmap(buf)
-	require.NoError(t, err)
-
-	if lockErr != nil {
-		var limit unix.Rlimit
-
-		err = unix.Getrlimit(unix.RLIMIT_MEMLOCK, &limit)
-		require.NoError(t, err)
-
-		t.Skipf("a %d-byte secret needs up to %d bytes of locked memory, "+
-			"which could not be locked under the locked-memory limit "+
-			"(RLIMIT_MEMLOCK) of %d bytes: %v",
-			size, need, limit.Cur, lockErr)
-	}
-}
-
 // newSizeTestVault creates an in-memory vault unlocked with the test
 // mnemonic and returns the filesystem and vault.
 //
@@ -93,10 +53,9 @@ func newSizeTestVault(t *testing.T) (afero.Fs, *vault.Vault) {
 }
 
 // runAddSecretSizeCase adds a secret of the given size through stdin and
-// verifies the outcome: wantErr, or the secret stored when wantErr is nil.
-func runAddSecretSizeCase(t *testing.T, size int, wantErr error) {
+// verifies that it is stored.
+func runAddSecretSizeCase(t *testing.T, size int) {
 	t.Helper()
-	skipIfLockedMemoryTooLow(t, size)
 
 	fs, vlt := newSizeTestVault(t)
 
@@ -127,13 +86,6 @@ func runAddSecretSizeCase(t *testing.T, size int, wantErr error) {
 	// Test adding the secret
 	secretName := fmt.Sprintf("test-secret-%d", size)
 	err = cli.AddSecret(secretName, false)
-
-	if wantErr != nil {
-		require.ErrorIs(t, err, wantErr)
-
-		return
-	}
-
 	require.NoError(t, err)
 
 	// Verify the secret was stored correctly
@@ -147,10 +99,9 @@ func runAddSecretSizeCase(t *testing.T, size int, wantErr error) {
 }
 
 // runImportSecretSizeCase imports a secret file of the given size and
-// verifies the outcome: wantErr, or the secret stored when wantErr is nil.
-func runImportSecretSizeCase(t *testing.T, size int, wantErr error) {
+// verifies that it is stored.
+func runImportSecretSizeCase(t *testing.T, size int) {
 	t.Helper()
-	skipIfLockedMemoryTooLow(t, size)
 
 	fs, vlt := newSizeTestVault(t)
 
@@ -179,13 +130,6 @@ func runImportSecretSizeCase(t *testing.T, size int, wantErr error) {
 	// Test importing the secret
 	secretName := fmt.Sprintf("imported-secret-%d", size)
 	err = cli.ImportSecret(cmd, secretName, testFile, false)
-
-	if wantErr != nil {
-		require.ErrorIs(t, err, wantErr)
-
-		return
-	}
-
 	require.NoError(t, err)
 
 	// Verify the secret was stored correctly
@@ -200,12 +144,11 @@ func runImportSecretSizeCase(t *testing.T, size int, wantErr error) {
 
 // TestAddSecretVariousSizes tests adding secrets of various sizes through stdin
 //
-//nolint:paralleltest // together the subtests lock more than the memlock limit
+//nolint:paralleltest // in parallel, size tests could exceed the memlock limit
 func TestAddSecretVariousSizes(t *testing.T) {
 	tests := []struct {
 		name string
 		size int
-		wantErr error
 	}{
 		{
 			name: "1KB secret",
@@ -223,40 +166,22 @@ func TestAddSecretVariousSizes(t *testing.T) {
 			name: "1MB secret",
 			size: 1024 * 1024,
 		},
-		{
-			name: "10MB secret",
-			size: 10 * 1024 * 1024,
-		},
-		{
-			name: "99MB secret",
-			size: 99 * 1024 * 1024,
-		},
-		{
-			name: "100MB secret minus 1 byte",
-			size: 100*1024*1024 - 1,
-		},
-		{
-			name:    "101MB secret - should fail",
-			size:    101 * 1024 * 1024,
-			wantErr: errSecretTooLarge,
-		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			runAddSecretSizeCase(t, tt.size, tt.wantErr)
+			runAddSecretSizeCase(t, tt.size)
 		})
 	}
 }
 
 // TestImportSecretVariousSizes tests importing secrets of various sizes from files
 //
-//nolint:paralleltest // together the subtests lock more than the memlock limit
+//nolint:paralleltest // in parallel, size tests could exceed the memlock limit
 func TestImportSecretVariousSizes(t *testing.T) {
 	tests := []struct {
 		name string
 		size int
-		wantErr error
 	}{
 		{
 			name: "1KB file",
@@ -274,35 +199,18 @@ func TestImportSecretVariousSizes(t *testing.T) {
 			name: "1MB file",
 			size: 1024 * 1024,
 		},
-		{
-			name: "10MB file",
-			size: 10 * 1024 * 1024,
-		},
-		{
-			name: "99MB file",
-			size: 99 * 1024 * 1024,
-		},
-		{
-			name: "100MB file",
-			size: 100 * 1024 * 1024,
-		},
-		{
-			name:    "101MB file - should fail",
-			size:    101 * 1024 * 1024,
-			wantErr: errSecretFileTooLarge,
-		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			runImportSecretSizeCase(t, tt.size, tt.wantErr)
+			runImportSecretSizeCase(t, tt.size)
 		})
 	}
 }
 
 // TestAddSecretBufferGrowth tests that our buffer growth strategy works correctly
 //
-//nolint:paralleltest // together the subtests lock more than the memlock limit
+//nolint:paralleltest // in parallel, size tests could exceed the memlock limit
 func TestAddSecretBufferGrowth(t *testing.T) {
 	// Test various sizes that should trigger buffer growth
 	sizes := []int{
@@ -321,13 +229,10 @@ func TestAddSecretBufferGrowth(t *testing.T) {
 		131072,  // 128KB
 		524288,  // 512KB
 		1048576, // 1MB
-		2097152, // 2MB
 	}
 
 	for _, size := range sizes {
 		t.Run(fmt.Sprintf("size_%d", size), func(t *testing.T) {
-			skipIfLockedMemoryTooLow(t, size)
-
 			fs, vlt := newSizeTestVault(t)
 
 			// Create test data of exactly the specified size

internal/cli/stdout_stderr_test.go

@@ -7,19 +7,19 @@ import (
 	"strings"
 	"testing"
 
-	"git.eeqj.de/sneak/secret/internal/secret"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/secret/internal/secret"
 )
 
 // TestGetCommandOutputsToStdout tests that 'secret get' outputs the secret
 // value to stdout, not stderr
 func TestGetCommandOutputsToStdout(t *testing.T) {
-	// Create a temporary directory for our vault
-	tempDir := t.TempDir()
+	t.Parallel()
 
-	// Set environment variables for the test
-	t.Setenv(secret.EnvStateDir, tempDir)
+	// Create a temporary directory for our vault; each command is given it
+	// in its environment
+	tempDir := t.TempDir()
 
 	// Find the secret binary path
 	wd, err := filepath.Abs("../..")
@@ -41,6 +41,18 @@ func TestGetCommandOutputsToStdout(t *testing.T) {
 	output, err := cmd.CombinedOutput()
 	require.NoError(t, err, "init should succeed: %s", string(output))
 
+	// The binary, unlike these tests, encrypts the passphrase unlocker's key
+	// at age's scrypt work factor, 18. age writes the work factor last on the
+	// second line of priv.age: "-> scrypt <salt> <work factor>".
+	vaultDir := filepath.Join(tempDir, "vaults.d", "default")
+	unlockerName := readFile(t, filepath.Join(vaultDir, "current-unlocker"))
+	unlockerDir := filepath.Join(vaultDir, "unlockers.d", string(unlockerName))
+	privAge := readFile(t, filepath.Join(unlockerDir, "priv.age"))
+	header := strings.SplitN(string(privAge), "\n", 3)
+	require.Len(t, header, 3, "priv.age should start with an age header")
+	assert.Regexp(t, `^-> scrypt \S+ 18$`, header[1],
+		"the passphrase unlocker should be encrypted at scrypt work factor 18")
+
 	// Add a secret
 	//nolint:gosec // G204: test executes the freshly built secret binary
 	cmd = exec.CommandContext(t.Context(), secretPath, "add", "test/secret")

internal/cli/test_helpers.go

@@ -5,7 +5,7 @@ import (
 	"os"
 	"strings"
 
-	"git.eeqj.de/sneak/secret/internal/secret"
+	"sneak.berlin/go/secret/internal/secret"
 )
 
 // ExecuteCommandInProcess executes a CLI command in-process for testing

internal/cli/test_output_test.go

@@ -3,9 +3,9 @@ package cli_test
 import (
 	"testing"
 
-	"git.eeqj.de/sneak/secret/internal/cli"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/secret/internal/cli"
 )
 
 //nolint:paralleltest // executes the CLI in-process against shared state

internal/cli/unlock_failure_test.go

@@ -19,14 +19,14 @@ import (
 	"testing"
 
 	"filippo.io/age"
-	"git.eeqj.de/sneak/secret/internal/cli"
-	"git.eeqj.de/sneak/secret/internal/secret"
-	"git.eeqj.de/sneak/secret/internal/vault"
 	"github.com/awnumar/memguard"
 	"github.com/spf13/afero"
 	"github.com/spf13/cobra"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/secret/internal/cli"
+	"sneak.berlin/go/secret/internal/secret"
+	"sneak.berlin/go/secret/internal/vault"
 )
 
 const (
@@ -260,9 +260,9 @@ func TestPassphraseNotReadNamesNoMnemonic(t *testing.T) {
 
 	assert.Equal(t, "Error: failed to unlock vault: "+
 		"failed to get long-term key: failed to get unlocker identity: "+
-		"failed to read passphrase: cannot read passphrase from non-terminal "+
-		"stdin (piped input or script). Please set the SB_UNLOCK_PASSPHRASE "+
-		"environment variable or run interactively\n", string(output))
+		"failed to read passphrase: stdin is not a terminal (piped input or "+
+		"script). Please set the SB_UNLOCK_PASSPHRASE environment variable or "+
+		"run interactively\n", string(output))
 }
 
 // TestCryptoUnlockFailureNamesMnemonic checks that `secret encrypt` and

internal/cli/unlockers.go

@@ -10,25 +10,20 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
-	"runtime"
 	"slices"
 	"strings"
 	"time"
 
-	"git.eeqj.de/sneak/secret/internal/secret"
-	"git.eeqj.de/sneak/secret/internal/vault"
 	"github.com/spf13/afero"
 	"github.com/spf13/cobra"
+	"sneak.berlin/go/secret/internal/secret"
+	"sneak.berlin/go/secret/internal/vault"
 )
 
-// Unlocker type names and platform identifiers shared across the CLI
+// Unlocker type names shared across the CLI
 const (
 	unlockerTypePassphrase = "passphrase"
-	unlockerTypeKeychain      = "keychain"
 	unlockerTypePGP        = "pgp"
-	unlockerTypeSecureEnclave = "secure-enclave"
-
-	platformDarwin = "darwin"
 
 	cmdUseList = "list"
 )
@@ -39,15 +34,10 @@ var (
 	errInvalidUnlockerType = errors.New("invalid unlocker type")
 	errKeyIDOnlyForPGP     = errors.New(
 		"--keyid flag is only valid for PGP unlockers")
-	errKeychainMacOSOnly = errors.New(
-		"keychain unlockers are only supported on macOS")
-	errSecureEnclaveMacOSOnly = errors.New(
-		"secure enclave unlockers are only supported on macOS")
 	// errGPGKeyAlreadyUnlocker carries only the message tail; the caller
 	// composes "GPG key <id> is already added as an unlocker".
 	errGPGKeyAlreadyUnlocker = errors.New(
 		"is already added as an unlocker")
-	errUnsupportedUnlockerType = errors.New("unsupported unlocker type")
 )
 
 // UnlockerInfo represents unlocker information for display
@@ -148,9 +138,8 @@ func newUnlockerListCmd() *cobra.Command {
 }
 
 // unlockerAddHelp returns the supported unlocker types list and their
-// descriptions for the current platform
+// descriptions
 func unlockerAddHelp() (string, string) {
-	// Build the supported types list based on platform
 	supportedTypes := "passphrase, pgp"
 	typeDescriptions := "Available unlocker types:\n" +
 		"\n" +
@@ -167,43 +156,6 @@ func unlockerAddHelp() (string, string) {
 		"               Use --keyid to specify a particular key, " +
 		"otherwise uses your default GPG key."
 
-	if runtime.GOOS == platformDarwin {
-		supportedTypes = "passphrase, keychain, pgp, secure-enclave"
-		typeDescriptions = "Available unlocker types:\n" +
-			"\n" +
-			"  passphrase      - Traditional password-based encryption\n" +
-			"                    Prompts for a passphrase that will be " +
-			"used to encrypt/decrypt the vault's master key.\n" +
-			"                    The passphrase is never stored in " +
-			"plaintext.\n" +
-			"\n" +
-			"  keychain        - macOS Keychain integration (macOS only)\n" +
-			"                    Stores the vault's master key in the " +
-			"macOS Keychain, protected by your login password.\n" +
-			"                    Automatically unlocks when your Keychain " +
-			"is unlocked (e.g., after login).\n" +
-			"                    Provides seamless integration with macOS " +
-			"security features like Touch ID.\n" +
-			"\n" +
-			"  pgp             - GNU Privacy Guard (GPG) key-based " +
-			"encryption\n" +
-			"                    Uses your existing GPG key to " +
-			"encrypt/decrypt the vault's master key.\n" +
-			"                    Requires gpg to be installed and " +
-			"configured with at least one secret key.\n" +
-			"                    Use --keyid to specify a particular key, " +
-			"otherwise uses your default GPG key.\n" +
-			"\n" +
-			"  secure-enclave  - Apple Secure Enclave hardware protection " +
-			"(macOS only)\n" +
-			"                    Stores the vault's master key encrypted " +
-			"by a non-exportable P-256 key\n" +
-			"                    held in the Secure Enclave. The key " +
-			"never leaves the hardware.\n" +
-			"                    Uses ECIES encryption; decryption is " +
-			"performed inside the SE."
-	}
-
 	return supportedTypes, typeDescriptions
 }
 
@@ -425,21 +377,13 @@ func (cli *Instance) UnlockersAdd(unlockerType string, cmd *cobra.Command) error
 	switch unlockerType {
 	case unlockerTypePassphrase:
 		return cli.addPassphraseUnlocker(cmd)
-	case unlockerTypeKeychain:
-		return cli.addKeychainUnlocker(cmd)
-	case unlockerTypeSecureEnclave:
-		return cli.addSecureEnclaveUnlocker(cmd)
 	case unlockerTypePGP:
 		return cli.addPGPUnlocker(cmd)
 	default:
-		// Build the supported types list based on platform
 		supportedTypes := "passphrase, pgp"
-		if runtime.GOOS == platformDarwin {
-			supportedTypes = "passphrase, keychain, pgp, secure-enclave"
-		}
 
 		return fmt.Errorf("%w: %s (supported: %s)",
-			errUnsupportedUnlockerType, unlockerType, supportedTypes)
+			errInvalidUnlockerType, unlockerType, supportedTypes)
 	}
 }
 
@@ -474,7 +418,7 @@ func (cli *Instance) addPassphraseUnlocker(cmd *cobra.Command) error {
 		// Use secure passphrase input with confirmation
 		passphraseBuffer, err = readSecurePassphrase("Enter passphrase for unlocker: ")
 		if err != nil {
-			return fmt.Errorf("failed to read passphrase: %w", err)
+			return err
 		}
 		defer passphraseBuffer.Destroy()
 	}
@@ -492,61 +436,6 @@ func (cli *Instance) addPassphraseUnlocker(cmd *cobra.Command) error {
 	return nil
 }
 
-// addKeychainUnlocker creates a macOS Keychain unlocker in the current vault
-func (cli *Instance) addKeychainUnlocker(cmd *cobra.Command) error {
-	if runtime.GOOS != platformDarwin {
-		return errKeychainMacOSOnly
-	}
-
-	keychainUnlocker, err := secret.CreateKeychainUnlocker(
-		cli.fs, cli.stateDir, cli.Mnemonic, cli.UnlockPassphrase)
-	if err != nil {
-		return fmt.Errorf("failed to create macOS Keychain unlocker: %w", err)
-	}
-
-	cmd.Printf("Created macOS Keychain unlocker: %s\n", keychainUnlocker.GetID())
-
-	keyName, err := keychainUnlocker.GetKeychainItemName()
-	if err == nil {
-		cmd.Printf("Keychain Item Name: %s\n", keyName)
-	}
-
-	// Auto-select the newly created unlocker
-	vlt, err := vault.GetCurrentVault(cli.fs, cli.stateDir)
-	if err != nil {
-		return fmt.Errorf("failed to get current vault: %w", err)
-	}
-
-	autoSelectUnlocker(cmd, vlt, keychainUnlocker.GetID())
-
-	return nil
-}
-
-// addSecureEnclaveUnlocker creates a Secure Enclave unlocker in the
-// current vault
-func (cli *Instance) addSecureEnclaveUnlocker(cmd *cobra.Command) error {
-	if runtime.GOOS != platformDarwin {
-		return errSecureEnclaveMacOSOnly
-	}
-
-	seUnlocker, err := secret.CreateSecureEnclaveUnlocker(
-		cli.fs, cli.stateDir, cli.Mnemonic, cli.UnlockPassphrase)
-	if err != nil {
-		return fmt.Errorf("failed to create Secure Enclave unlocker: %w", err)
-	}
-
-	cmd.Printf("Created Secure Enclave unlocker: %s\n", seUnlocker.GetID())
-
-	vlt, err := vault.GetCurrentVault(cli.fs, cli.stateDir)
-	if err != nil {
-		return fmt.Errorf("failed to get current vault: %w", err)
-	}
-
-	autoSelectUnlocker(cmd, vlt, seUnlocker.GetID())
-
-	return nil
-}
-
 // addPGPUnlocker creates a PGP unlocker in the current vault
 func (cli *Instance) addPGPUnlocker(cmd *cobra.Command) error {
 	// Get GPG key ID from flag, environment, or default key

internal/cli/unlockers_add_test.go

@@ -3,13 +3,15 @@ package cli
 
 import (
 	"path/filepath"
+	"strings"
 	"testing"
 
-	"git.eeqj.de/sneak/secret/internal/vault"
 	"github.com/awnumar/memguard"
 	"github.com/spf13/afero"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/secret/internal/secret"
+	"sneak.berlin/go/secret/internal/vault"
 )
 
 // unknownTestGPGUserID is a GPG user ID that no key in the test keyring has.
@@ -98,8 +100,45 @@ func TestAddPGPUnlockerUnknownKey(t *testing.T) {
 
 	err := instance.addPGPUnlocker(cmd)
 
-	require.ErrorContains(t, err, "failed to resolve GPG key fingerprint")
+	require.ErrorIs(t, err, secret.ErrGPGKeyNotFound)
 	assertDirEntries(t, base,
 		filepath.Join(testVaultDir(listTestVaultName), listTestUnlockersDirName),
 		listTestUnlockerDirOne)
 }
+
+// TestUnlockerAddKnowsOnlyPassphraseAndPGP is a regression test for
+// https://git.eeqj.de/sneak/secret/issues/132: `secret unlocker add` takes
+// only passphrase and pgp, on every platform. keychain and secure-enclave
+// fail as unknown types, and neither --help nor shell completion offers
+// them.
+//
+//nolint:paralleltest // executes the CLI in-process and sets the environment
+func TestUnlockerAddKnowsOnlyPassphraseAndPGP(t *testing.T) {
+	env := map[string]string{secret.EnvStateDir: t.TempDir()}
+	removedTypes := []string{"keychain", "secure-enclave"}
+
+	for _, unlockerType := range removedTypes {
+		_, err := ExecuteCommandInProcess(
+			[]string{"unlocker", "add", unlockerType}, "", env)
+		require.ErrorIs(t, err, errInvalidUnlockerType)
+
+		instance, cmd := newTestInstance(newListTestVault(t, 1))
+		require.ErrorIs(t, instance.UnlockersAdd(unlockerType, cmd),
+			errInvalidUnlockerType)
+	}
+
+	// --help prints the command's Long text, and shell completion offers
+	// its ValidArgs.
+	addCmd := newUnlockerAddCmd()
+	help := addCmd.Long
+	completions := strings.Join(addCmd.ValidArgs, " ")
+
+	for _, offered := range []string{help, completions} {
+		assert.Contains(t, offered, unlockerTypePassphrase)
+		assert.Contains(t, offered, unlockerTypePGP)
+
+		for _, unlockerType := range removedTypes {
+			assert.NotContains(t, offered, unlockerType)
+		}
+	}
+}

internal/cli/unlockers_corrupt_test.go

@@ -17,10 +17,10 @@ import (
 	"strings"
 	"testing"
 
-	"git.eeqj.de/sneak/secret/internal/vault"
 	"github.com/spf13/afero"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/secret/internal/vault"
 )
 
 // newCorruptUnlockerVault returns the two-unlocker test vault with the

internal/cli/unlockers_ids_test.go

@@ -7,11 +7,11 @@ import (
 	"testing"
 	"time"
 
-	"git.eeqj.de/sneak/secret/internal/secret"
-	"git.eeqj.de/sneak/secret/internal/vault"
 	"github.com/spf13/afero"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/secret/internal/secret"
+	"sneak.berlin/go/secret/internal/vault"
 )
 
 // TestSameMetadataUnlockersHaveTheirOwnIDs writes two passphrase unlockers
@@ -19,8 +19,7 @@ import (
 // copying an unlocker directory leaves them. It asserts that `unlocker
 // list` and the shell completion of `unlocker select` and `unlocker remove`
 // give each its own ID, and that each is selected and removed by its ID
-// alone. Keychain and Secure Enclave unlockers, which only macOS can add,
-// get their IDs the same way.
+// alone.
 func TestSameMetadataUnlockersHaveTheirOwnIDs(t *testing.T) {
 	t.Parallel()
 

internal/cli/unlockers_list_test.go

@@ -21,11 +21,11 @@ import (
 	"testing"
 	"time"
 
-	"git.eeqj.de/sneak/secret/internal/secret"
 	"github.com/spf13/afero"
 	"github.com/spf13/cobra"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/secret/internal/secret"
 )
 
 const (

internal/cli/unreadable_dir_test.go

@@ -28,11 +28,11 @@ import (
 	"testing"
 	"time"
 
-	"git.eeqj.de/sneak/secret/internal/secret"
 	"github.com/spf13/afero"
 	"github.com/spf13/cobra"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/secret/internal/secret"
 )
 
 const (

internal/cli/usage_test.go

@@ -4,10 +4,10 @@ import (
 	"strings"
 	"testing"
 
-	"git.eeqj.de/sneak/secret/internal/cli"
-	"git.eeqj.de/sneak/secret/internal/secret"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/secret/internal/cli"
+	"sneak.berlin/go/secret/internal/secret"
 )
 
 // usageHeading starts the usage text cobra prints after an error.

internal/cli/vault.go

@@ -10,20 +10,19 @@ import (
 	"strings"
 	"time"
 
-	"git.eeqj.de/sneak/secret/internal/secret"
-	"git.eeqj.de/sneak/secret/internal/vault"
-	"git.eeqj.de/sneak/secret/pkg/agehd"
 	"github.com/awnumar/memguard"
 	"github.com/spf13/afero"
 	"github.com/spf13/cobra"
-	"github.com/tyler-smith/go-bip39"
+	"sneak.berlin/go/secret/internal/bip39"
+	"sneak.berlin/go/secret/internal/secret"
+	"sneak.berlin/go/secret/internal/vault"
+	"sneak.berlin/go/secret/pkg/agehd"
 )
 
 // Sentinel errors for vault operations
 var (
 	errMnemonicEmpty         = errors.New("mnemonic cannot be empty")
 	errInvalidMnemonicPhrase = errors.New("invalid BIP39 mnemonic phrase")
-	errInvalidMnemonic       = errors.New("invalid BIP39 mnemonic")
 	errVaultHasLongTermKey   = errors.New(
 		"already has a long-term key configured")
 	errMnemonicEnvNotSet = errors.New(
@@ -250,7 +249,7 @@ func (cli *Instance) resolvePassphrase() (*memguard.LockedBuffer, func(), error)
 	// Use secure passphrase input with confirmation
 	passphraseBuffer, err := readSecurePassphrase("Enter passphrase for unlocker: ")
 	if err != nil {
-		return nil, nil, fmt.Errorf("failed to read passphrase: %w", err)
+		return nil, nil, err
 	}
 
 	return passphraseBuffer, passphraseBuffer.Destroy, nil
@@ -353,7 +352,7 @@ func (cli *Instance) vaultImportPreflight(
 
 	if !exists {
 		return "", "", "", fmt.Errorf("vault '%s' %w",
-			vaultName, errVaultDoesNotExist)
+			vaultName, vault.ErrVaultNotFound)
 	}
 
 	// Check if vault already has a public key
@@ -381,7 +380,7 @@ func (cli *Instance) vaultImportPreflight(
 	secret.Debug("Validating BIP39 mnemonic", "word_count", len(mnemonicWords))
 
 	if !bip39.IsMnemonicValid(mnemonic) {
-		return "", "", "", errInvalidMnemonic
+		return "", "", "", errInvalidMnemonicPhrase
 	}
 
 	return vaultDir, pubKeyPath, mnemonic, nil
@@ -644,7 +643,7 @@ func (cli *Instance) findVaultToRemove(name string) (vaultToRemove, error) {
 
 	if !slices.Contains(vaults, name) {
 		return vaultToRemove{},
-			fmt.Errorf("vault '%s' %w", name, errVaultDoesNotExist)
+			fmt.Errorf("vault '%s' %w", name, vault.ErrVaultNotFound)
 	}
 
 	if len(vaults) == 1 {

internal/cli/version.go

@@ -11,10 +11,10 @@ import (
 	"time"
 
 	"filippo.io/age"
-	"git.eeqj.de/sneak/secret/internal/secret"
-	"git.eeqj.de/sneak/secret/internal/vault"
 	"github.com/spf13/afero"
 	"github.com/spf13/cobra"
+	"sneak.berlin/go/secret/internal/secret"
+	"sneak.berlin/go/secret/internal/vault"
 )
 
 const (
@@ -23,7 +23,6 @@ const (
 
 // Sentinel errors for version operations
 var (
-	errVersionNotFound            = errors.New("not found for secret")
 	errCannotRemoveCurrentVersion = errors.New("promote another version first")
 )
 
@@ -156,7 +155,7 @@ func (cli *Instance) ListVersions(cmd *cobra.Command, secretName string) error {
 	if !exists {
 		secret.Debug("Secret not found", "secret_name", secretName)
 
-		return fmt.Errorf("secret '%s' %w", secretName, errSecretNotFound)
+		return fmt.Errorf("secret '%s' %w", secretName, vault.ErrSecretNotFound)
 	}
 
 	// List all versions
@@ -289,7 +288,7 @@ func (cli *Instance) PromoteVersion(
 
 	if !exists {
 		return fmt.Errorf("version '%s' %w '%s'",
-			version, errVersionNotFound, secretName)
+			version, vault.ErrVersionNotFound, secretName)
 	}
 
 	// Update the current symlink using the proper function
@@ -374,7 +373,7 @@ func (cli *Instance) findVersionToRemove(
 
 	if !exists {
 		return versionToRemove{},
-			fmt.Errorf("secret '%s' %w", secretName, errSecretNotFound)
+			fmt.Errorf("secret '%s' %w", secretName, vault.ErrSecretNotFound)
 	}
 
 	// Check if version exists
@@ -386,7 +385,7 @@ func (cli *Instance) findVersionToRemove(
 
 	if !exists {
 		return versionToRemove{}, fmt.Errorf("version '%s' %w '%s'",
-			version, errVersionNotFound, secretName)
+			version, vault.ErrVersionNotFound, secretName)
 	}
 
 	// Get current version

internal/cli/version_test.go

@@ -26,13 +26,13 @@ import (
 	"time"
 	"unicode/utf8"
 
-	"git.eeqj.de/sneak/secret/internal/secret"
-	"git.eeqj.de/sneak/secret/internal/vault"
-	"git.eeqj.de/sneak/secret/pkg/agehd"
 	"github.com/awnumar/memguard"
 	"github.com/spf13/afero"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/secret/internal/secret"
+	"sneak.berlin/go/secret/internal/vault"
+	"sneak.berlin/go/secret/pkg/agehd"
 )
 
 const (
@@ -171,7 +171,7 @@ func TestListVersionsNonExistentSecret(t *testing.T) {
 
 	// Try to list versions of non-existent secret
 	err := cli.ListVersions(cmd, "nonexistent/secret")
-	require.ErrorIs(t, err, errSecretNotFound)
+	require.ErrorIs(t, err, vault.ErrSecretNotFound)
 }
 
 func TestPromoteVersionCommand(t *testing.T) {
@@ -265,7 +265,7 @@ func TestPromoteNonExistentVersion(t *testing.T) {
 
 	// Try to promote non-existent version
 	err = cli.PromoteVersion(cmd, "test/secret", "20991231.999")
-	require.ErrorIs(t, err, errVersionNotFound)
+	require.ErrorIs(t, err, vault.ErrVersionNotFound)
 }
 
 func TestGetSecretWithVersion(t *testing.T) {

internal/macse/macse_darwin.go

@@ -1,152 +0,0 @@
-//go:build darwin
-
-// Package macse provides Go bindings for macOS Secure Enclave operations
-// using CryptoTokenKit identities created via sc_auth.
-// Key creation and deletion shell out to sc_auth (which has SE entitlements).
-// Encrypt/decrypt use Security.framework ECIES directly (works unsigned).
-package macse
-
-/*
-#cgo CFLAGS: -x objective-c -fobjc-arc
-#cgo LDFLAGS: -framework Security -framework Foundation -framework CoreFoundation
-#include <stdlib.h>
-#include "secure_enclave.h"
-*/
-import "C"
-
-import (
-	"errors"
-	"fmt"
-	"unsafe"
-)
-
-const (
-	// p256UncompressedKeySize is the size of an uncompressed P-256 public key.
-	p256UncompressedKeySize = 65
-
-	// errorBufferSize is the size of the C error message buffer.
-	errorBufferSize = 512
-
-	// hashBufferSize is the size of the hash output buffer.
-	hashBufferSize = 128
-
-	// maxCiphertextSize is the max buffer for ECIES ciphertext.
-	// ECIES overhead for P-256: 65 (ephemeral pub) + 16 (GCM tag) + 16 (IV) + plaintext.
-	maxCiphertextSize = 8192
-
-	// maxPlaintextSize is the max buffer for decrypted plaintext.
-	maxPlaintextSize = 8192
-)
-
-// CreateKey creates a new P-256 non-exportable key in the Secure Enclave via sc_auth.
-// Returns the uncompressed public key bytes (65 bytes) and the identity hash
-// (for deletion). If getting the public key fails, CreateKey deletes the key
-// again; a failure to delete is returned along with the first error.
-func CreateKey(label string) (publicKey []byte, hash string, err error) {
-	var hashBuf [hashBufferSize]C.char
-	var errBuf [errorBufferSize]C.char
-
-	cLabel := C.CString(label)
-	defer C.free(unsafe.Pointer(cLabel)) //nolint:nlreturn // CGo free pattern
-
-	result := C.se_create_key(cLabel,
-		&hashBuf[0], C.int(hashBufferSize),
-		&errBuf[0], C.int(errorBufferSize))
-
-	if result != 0 {
-		return nil, "", fmt.Errorf("secure enclave: %s", C.GoString(&errBuf[0]))
-	}
-
-	h := C.GoString(&hashBuf[0])
-
-	pubKeyBuf := make([]C.uint8_t, p256UncompressedKeySize)
-	pubKeyLen := C.int(p256UncompressedKeySize)
-
-	result = C.se_copy_public_key(cLabel,
-		&pubKeyBuf[0], &pubKeyLen,
-		&errBuf[0], C.int(errorBufferSize))
-
-	if result != 0 {
-		err = fmt.Errorf("secure enclave: %s", C.GoString(&errBuf[0]))
-
-		deleteErr := DeleteKey(h)
-		if deleteErr != nil {
-			err = errors.Join(err,
-				fmt.Errorf("failed to delete key %s: %w", label, deleteErr))
-		}
-
-		return nil, "", err
-	}
-
-	//nolint:nlreturn // CGo result extraction
-	pk := C.GoBytes(unsafe.Pointer(&pubKeyBuf[0]), pubKeyLen)
-
-	return pk, h, nil
-}
-
-// Encrypt encrypts plaintext using the SE-backed public key via ECIES
-// (eciesEncryptionStandardVariableIVX963SHA256AESGCM).
-// Encryption uses only the public key; no SE interaction required.
-func Encrypt(label string, plaintext []byte) ([]byte, error) {
-	ciphertextBuf := make([]C.uint8_t, maxCiphertextSize)
-	ciphertextLen := C.int(maxCiphertextSize)
-	var errBuf [errorBufferSize]C.char
-
-	cLabel := C.CString(label)
-	defer C.free(unsafe.Pointer(cLabel)) //nolint:nlreturn // CGo free pattern
-
-	result := C.se_encrypt(cLabel,
-		(*C.uint8_t)(unsafe.Pointer(&plaintext[0])), C.int(len(plaintext)),
-		&ciphertextBuf[0], &ciphertextLen,
-		&errBuf[0], C.int(errorBufferSize))
-
-	if result != 0 {
-		return nil, fmt.Errorf("secure enclave: %s", C.GoString(&errBuf[0]))
-	}
-
-	//nolint:nlreturn // CGo result extraction
-	out := C.GoBytes(unsafe.Pointer(&ciphertextBuf[0]), ciphertextLen)
-
-	return out, nil
-}
-
-// Decrypt decrypts ECIES ciphertext using the SE-backed private key.
-// The ECDH portion of decryption is performed inside the Secure Enclave.
-func Decrypt(label string, ciphertext []byte) ([]byte, error) {
-	plaintextBuf := make([]C.uint8_t, maxPlaintextSize)
-	plaintextLen := C.int(maxPlaintextSize)
-	var errBuf [errorBufferSize]C.char
-
-	cLabel := C.CString(label)
-	defer C.free(unsafe.Pointer(cLabel)) //nolint:nlreturn // CGo free pattern
-
-	result := C.se_decrypt(cLabel,
-		(*C.uint8_t)(unsafe.Pointer(&ciphertext[0])), C.int(len(ciphertext)),
-		&plaintextBuf[0], &plaintextLen,
-		&errBuf[0], C.int(errorBufferSize))
-
-	if result != 0 {
-		return nil, fmt.Errorf("secure enclave: %s", C.GoString(&errBuf[0]))
-	}
-
-	//nolint:nlreturn // CGo result extraction
-	out := C.GoBytes(unsafe.Pointer(&plaintextBuf[0]), plaintextLen)
-
-	return out, nil
-}
-
-// DeleteKey removes a CTK identity from the Secure Enclave via sc_auth.
-func DeleteKey(hash string) error {
-	var errBuf [errorBufferSize]C.char
-
-	cHash := C.CString(hash)
-	defer C.free(unsafe.Pointer(cHash)) //nolint:nlreturn // CGo free pattern
-
-	result := C.se_delete_key(cHash, &errBuf[0], C.int(errorBufferSize))
-
-	if result != 0 {
-		return fmt.Errorf("secure enclave: %s", C.GoString(&errBuf[0]))
-	}
-
-	return nil
-}

internal/macse/macse_stub.go

@@ -1,28 +0,0 @@
-//go:build !darwin || !cgo
-
-// Package macse provides Go bindings for macOS Secure Enclave operations.
-package macse
-
-import "errors"
-
-var errNotSupported = errors.New("secure enclave needs a macOS build with cgo")
-
-// CreateKey fails: the Secure Enclave needs a macOS build with cgo.
-func CreateKey(_ string) ([]byte, string, error) {
-	return nil, "", errNotSupported
-}
-
-// Encrypt fails: the Secure Enclave needs a macOS build with cgo.
-func Encrypt(_ string, _ []byte) ([]byte, error) {
-	return nil, errNotSupported
-}
-
-// Decrypt fails: the Secure Enclave needs a macOS build with cgo.
-func Decrypt(_ string, _ []byte) ([]byte, error) {
-	return nil, errNotSupported
-}
-
-// DeleteKey fails: the Secure Enclave needs a macOS build with cgo.
-func DeleteKey(_ string) error {
-	return errNotSupported
-}

internal/macse/macse_test.go

@@ -1,164 +0,0 @@
-//go:build darwin && cgo
-
-package macse
-
-import (
-	"bytes"
-	"testing"
-)
-
-const testKeyLabel = "berlin.sneak.app.secret.test.se-key"
-
-// testKeyHash stores the hash of the created test key for cleanup.
-var testKeyHash string //nolint:gochecknoglobals
-
-// skipIfNoSecureEnclave skips the test if SE access is unavailable.
-func skipIfNoSecureEnclave(t *testing.T) {
-	t.Helper()
-
-	probeLabel := "berlin.sneak.app.secret.test.se-probe"
-	_, hash, err := CreateKey(probeLabel)
-	if err != nil {
-		t.Skipf("Secure Enclave unavailable (skipping): %v", err)
-	}
-
-	if hash != "" {
-		_ = DeleteKey(hash)
-	}
-}
-
-func TestCreateAndDeleteKey(t *testing.T) {
-	skipIfNoSecureEnclave(t)
-
-	if testKeyHash != "" {
-		_ = DeleteKey(testKeyHash)
-	}
-
-	pubKey, hash, err := CreateKey(testKeyLabel)
-	if err != nil {
-		t.Fatalf("CreateKey failed: %v", err)
-	}
-
-	testKeyHash = hash
-	t.Logf("Created key with hash: %s", hash)
-
-	// Verify valid uncompressed P-256 public key
-	if len(pubKey) != p256UncompressedKeySize {
-		t.Fatalf("expected public key length %d, got %d",
-			p256UncompressedKeySize, len(pubKey))
-	}
-
-	if pubKey[0] != 0x04 {
-		t.Fatalf("expected uncompressed point prefix 0x04, got 0x%02x", pubKey[0])
-	}
-
-	if hash == "" {
-		t.Fatal("expected non-empty hash")
-	}
-
-	// Delete the key
-	if err := DeleteKey(hash); err != nil {
-		t.Fatalf("DeleteKey failed: %v", err)
-	}
-
-	testKeyHash = ""
-	t.Log("Key created, verified, and deleted successfully")
-}
-
-func TestEncryptDecryptRoundTrip(t *testing.T) {
-	skipIfNoSecureEnclave(t)
-
-	_, hash, err := CreateKey(testKeyLabel)
-	if err != nil {
-		t.Fatalf("CreateKey failed: %v", err)
-	}
-
-	testKeyHash = hash
-
-	defer func() {
-		if testKeyHash != "" {
-			_ = DeleteKey(testKeyHash)
-			testKeyHash = ""
-		}
-	}()
-
-	// Test data simulating an age private key
-	plaintext := []byte("AGE-SECRET-KEY-1" +
-		"QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ")
-
-	// Encrypt
-	ciphertext, err := Encrypt(testKeyLabel, plaintext)
-	if err != nil {
-		t.Fatalf("Encrypt failed: %v", err)
-	}
-
-	t.Logf("Plaintext: %d bytes, Ciphertext: %d bytes", len(plaintext), len(ciphertext))
-
-	if bytes.Equal(ciphertext, plaintext) {
-		t.Fatal("ciphertext should differ from plaintext")
-	}
-
-	// Decrypt
-	decrypted, err := Decrypt(testKeyLabel, ciphertext)
-	if err != nil {
-		t.Fatalf("Decrypt failed: %v", err)
-	}
-
-	if !bytes.Equal(decrypted, plaintext) {
-		t.Fatalf("decrypted data does not match original plaintext")
-	}
-
-	t.Log("ECIES encrypt/decrypt round-trip successful")
-}
-
-func TestEncryptProducesDifferentCiphertexts(t *testing.T) {
-	skipIfNoSecureEnclave(t)
-
-	_, hash, err := CreateKey(testKeyLabel)
-	if err != nil {
-		t.Fatalf("CreateKey failed: %v", err)
-	}
-
-	testKeyHash = hash
-
-	defer func() {
-		if testKeyHash != "" {
-			_ = DeleteKey(testKeyHash)
-			testKeyHash = ""
-		}
-	}()
-
-	plaintext := []byte("test-secret-data")
-
-	ct1, err := Encrypt(testKeyLabel, plaintext)
-	if err != nil {
-		t.Fatalf("first Encrypt failed: %v", err)
-	}
-
-	ct2, err := Encrypt(testKeyLabel, plaintext)
-	if err != nil {
-		t.Fatalf("second Encrypt failed: %v", err)
-	}
-
-	// ECIES uses a random ephemeral key each time, so ciphertexts should differ
-	if bytes.Equal(ct1, ct2) {
-		t.Fatal("two encryptions of same plaintext should produce different ciphertexts")
-	}
-
-	// Both should decrypt to the same plaintext
-	dec1, err := Decrypt(testKeyLabel, ct1)
-	if err != nil {
-		t.Fatalf("first Decrypt failed: %v", err)
-	}
-
-	dec2, err := Decrypt(testKeyLabel, ct2)
-	if err != nil {
-		t.Fatalf("second Decrypt failed: %v", err)
-	}
-
-	if !bytes.Equal(dec1, plaintext) || !bytes.Equal(dec2, plaintext) {
-		t.Fatal("both ciphertexts should decrypt to original plaintext")
-	}
-
-	t.Log("ECIES correctly produces different ciphertexts that decrypt to same plaintext")
-}

internal/macse/secure_enclave.h

@@ -1,69 +0,0 @@
-//go:build darwin
-
-#ifndef SECURE_ENCLAVE_H
-#define SECURE_ENCLAVE_H
-
-#include <stdint.h>
-
-// se_create_key creates a new P-256 key in the Secure Enclave via sc_auth and
-// finds its identity hash. If the hash cannot be found, the key exists but
-// se_create_key fails, with an error naming the label.
-// label: unique identifier for the CTK identity (UTF-8 C string)
-// hash_out: output buffer for the identity hash (for deletion)
-// hash_out_len: size of hash_out buffer
-// error_out: output buffer for error message
-// error_out_len: size of error_out buffer
-// Returns 0 on success, -1 on failure.
-int se_create_key(const char *label,
-                  char *hash_out, int hash_out_len,
-                  char *error_out, int error_out_len);
-
-// se_copy_public_key copies the public key of a CTK identity.
-// label: label of the CTK identity
-// pub_key_out: output buffer for the uncompressed public key (65 bytes for P-256)
-// pub_key_len: on input, size of pub_key_out; on output, actual size written
-// error_out: output buffer for error message
-// error_out_len: size of error_out buffer
-// Returns 0 on success, -1 on failure.
-int se_copy_public_key(const char *label,
-                       uint8_t *pub_key_out, int *pub_key_len,
-                       char *error_out, int error_out_len);
-
-// se_encrypt encrypts data using the SE-backed public key (ECIES).
-// label: label of the CTK identity whose public key to use
-// plaintext: data to encrypt
-// plaintext_len: length of plaintext
-// ciphertext_out: output buffer for the ECIES ciphertext
-// ciphertext_len: on input, size of buffer; on output, actual size written
-// error_out: output buffer for error message
-// error_out_len: size of error_out buffer
-// Returns 0 on success, -1 on failure.
-int se_encrypt(const char *label,
-               const uint8_t *plaintext, int plaintext_len,
-               uint8_t *ciphertext_out, int *ciphertext_len,
-               char *error_out, int error_out_len);
-
-// se_decrypt decrypts ECIES ciphertext using the SE-backed private key.
-// The ECDH portion of decryption is performed inside the Secure Enclave.
-// label: label of the CTK identity whose private key to use
-// ciphertext: ECIES ciphertext produced by se_encrypt
-// ciphertext_len: length of ciphertext
-// plaintext_out: output buffer for decrypted data
-// plaintext_len: on input, size of buffer; on output, actual size written
-// error_out: output buffer for error message
-// error_out_len: size of error_out buffer
-// Returns 0 on success, -1 on failure.
-int se_decrypt(const char *label,
-               const uint8_t *ciphertext, int ciphertext_len,
-               uint8_t *plaintext_out, int *plaintext_len,
-               char *error_out, int error_out_len);
-
-// se_delete_key removes a CTK identity from the Secure Enclave via sc_auth.
-// hash: the identity hash returned by se_create_key
-// error_out: output buffer for error message
-// error_out_len: size of error_out buffer
-// Returns 0 on success, -1 on failure.
-int se_delete_key(const char *hash,
-                  char *error_out, int error_out_len);
-
-#endif // SECURE_ENCLAVE_H

internal/macse/secure_enclave.m

@@ -1,317 +0,0 @@
-//go:build darwin
-
-#import <Foundation/Foundation.h>
-#import <Security/Security.h>
-#include "secure_enclave.h"
-#include <string.h>
-
-// snprintf_error writes an error message string to the output buffer.
-static void snprintf_error(char *error_out, int error_out_len, NSString *msg) {
-    if (error_out && error_out_len > 0) {
-        snprintf(error_out, error_out_len, "%s", msg.UTF8String);
-    }
-}
-
-// lookup_ctk_identity finds a CTK identity by label and returns the private key.
-static SecKeyRef lookup_ctk_private_key(const char *label, char *error_out, int error_out_len) {
-    NSDictionary *query = @{
-        (id)kSecClass:      (id)kSecClassIdentity,
-        (id)kSecAttrLabel:  [NSString stringWithUTF8String:label],
-        (id)kSecMatchLimit: (id)kSecMatchLimitOne,
-        (id)kSecReturnRef:  @YES,
-    };
-
-    SecIdentityRef identity = NULL;
-    OSStatus status = SecItemCopyMatching((__bridge CFDictionaryRef)query, (CFTypeRef *)&identity);
-
-    if (status != errSecSuccess || !identity) {
-        NSString *msg = [NSString stringWithFormat:@"CTK identity '%s' not found: OSStatus %d",
-                         label, (int)status];
-        snprintf_error(error_out, error_out_len, msg);
-        return NULL;
-    }
-
-    SecKeyRef privateKey = NULL;
-    status = SecIdentityCopyPrivateKey(identity, &privateKey);
-    CFRelease(identity);
-
-    if (status != errSecSuccess || !privateKey) {
-        NSString *msg = [NSString stringWithFormat:
-                         @"failed to get private key from CTK identity '%s': OSStatus %d",
-                         label, (int)status];
-        snprintf_error(error_out, error_out_len, msg);
-        return NULL;
-    }
-
-    return privateKey;
-}
-
-int se_create_key(const char *label,
-                  char *hash_out, int hash_out_len,
-                  char *error_out, int error_out_len) {
-    @autoreleasepool {
-        NSString *labelStr = [NSString stringWithUTF8String:label];
-
-        // Shell out to sc_auth (which has SE entitlements) to create the key
-        NSTask *task = [[NSTask alloc] init];
-        task.executableURL = [NSURL fileURLWithPath:@"/usr/sbin/sc_auth"];
-        task.arguments = @[
-            @"create-ctk-identity",
-            @"-k", @"p-256-ne",
-            @"-t", @"none",
-            @"-l", labelStr,
-        ];
-
-        NSPipe *stderrPipe = [NSPipe pipe];
-        task.standardOutput = [NSPipe pipe];
-        task.standardError = stderrPipe;
-
-        NSError *nsError = nil;
-        if (![task launchAndReturnError:&nsError]) {
-            NSString *msg = [NSString stringWithFormat:@"failed to launch sc_auth: %@",
-                             nsError.localizedDescription];
-            snprintf_error(error_out, error_out_len, msg);
-            return -1;
-        }
-
-        [task waitUntilExit];
-
-        if (task.terminationStatus != 0) {
-            NSData *stderrData = [stderrPipe.fileHandleForReading readDataToEndOfFile];
-            NSString *stderrStr = [[NSString alloc] initWithData:stderrData
-                                                        encoding:NSUTF8StringEncoding];
-            NSString *msg = [NSString stringWithFormat:@"sc_auth failed: %@",
-                             stderrStr ?: @"unknown error"];
-            snprintf_error(error_out, error_out_len, msg);
-            return -1;
-        }
-
-        // Get the identity hash, which deleting the key needs, by parsing
-        // sc_auth list output
-        hash_out[0] = '\0';
-        NSTask *listTask = [[NSTask alloc] init];
-        listTask.executableURL = [NSURL fileURLWithPath:@"/usr/sbin/sc_auth"];
-        listTask.arguments = @[@"list-ctk-identities"];
-
-        NSPipe *listPipe = [NSPipe pipe];
-        listTask.standardOutput = listPipe;
-        listTask.standardError = [NSPipe pipe];
-
-        if ([listTask launchAndReturnError:&nsError]) {
-            [listTask waitUntilExit];
-            NSData *listData = [listPipe.fileHandleForReading readDataToEndOfFile];
-            NSString *listStr = [[NSString alloc] initWithData:listData
-                                                      encoding:NSUTF8StringEncoding];
-
-            for (NSString *line in [listStr componentsSeparatedByString:@"\n"]) {
-                if ([line containsString:labelStr]) {
-                    NSMutableArray *tokens = [NSMutableArray array];
-                    for (NSString *part in [line componentsSeparatedByCharactersInSet:
-                                            [NSCharacterSet whitespaceCharacterSet]]) {
-                        if (part.length > 0) {
-                            [tokens addObject:part];
-                        }
-                    }
-                    if (tokens.count > 1) {
-                        snprintf(hash_out, hash_out_len, "%s", [tokens[1] UTF8String]);
-                    }
-                    break;
-                }
-            }
-        }
-
-        if (hash_out[0] == '\0') {
-            NSString *msg = [NSString stringWithFormat:
-                             @"created key '%s' but found no hash for it in sc_auth list-ctk-identities",
-                             label];
-            snprintf_error(error_out, error_out_len, msg);
-            return -1;
-        }
-
-        return 0;
-    }
-}
-
-int se_copy_public_key(const char *label,
-                       uint8_t *pub_key_out, int *pub_key_len,
-                       char *error_out, int error_out_len) {
-    @autoreleasepool {
-        SecKeyRef privateKey = lookup_ctk_private_key(label, error_out, error_out_len);
-        if (!privateKey) {
-            return -1;
-        }
-
-        SecKeyRef publicKey = SecKeyCopyPublicKey(privateKey);
-        CFRelease(privateKey);
-
-        if (!publicKey) {
-            snprintf_error(error_out, error_out_len, @"failed to get public key");
-            return -1;
-        }
-
-        CFErrorRef cfError = NULL;
-        CFDataRef pubKeyData = SecKeyCopyExternalRepresentation(publicKey, &cfError);
-        CFRelease(publicKey);
-
-        if (!pubKeyData) {
-            NSError *err = (__bridge_transfer NSError *)cfError;
-            NSString *msg = [NSString stringWithFormat:@"failed to export public key: %@",
-                             err.localizedDescription];
-            snprintf_error(error_out, error_out_len, msg);
-            return -1;
-        }
-
-        const UInt8 *bytes = CFDataGetBytePtr(pubKeyData);
-        CFIndex length = CFDataGetLength(pubKeyData);
-
-        if (length > *pub_key_len) {
-            CFRelease(pubKeyData);
-            snprintf_error(error_out, error_out_len, @"public key buffer too small");
-            return -1;
-        }
-
-        memcpy(pub_key_out, bytes, length);
-        *pub_key_len = (int)length;
-        CFRelease(pubKeyData);
-
-        return 0;
-    }
-}
-
-int se_encrypt(const char *label,
-               const uint8_t *plaintext, int plaintext_len,
-               uint8_t *ciphertext_out, int *ciphertext_len,
-               char *error_out, int error_out_len) {
-    @autoreleasepool {
-        SecKeyRef privateKey = lookup_ctk_private_key(label, error_out, error_out_len);
-        if (!privateKey) {
-            return -1;
-        }
-
-        SecKeyRef publicKey = SecKeyCopyPublicKey(privateKey);
-        CFRelease(privateKey);
-
-        if (!publicKey) {
-            snprintf_error(error_out, error_out_len, @"failed to get public key for encryption");
-            return -1;
-        }
-
-        NSData *plaintextData = [NSData dataWithBytes:plaintext length:plaintext_len];
-
-        CFErrorRef cfError = NULL;
-        CFDataRef encrypted = SecKeyCreateEncryptedData(
-            publicKey,
-            kSecKeyAlgorithmECIESEncryptionStandardVariableIVX963SHA256AESGCM,
-            (__bridge CFDataRef)plaintextData,
-            &cfError
-        );
-        CFRelease(publicKey);
-
-        if (!encrypted) {
-            NSError *nsError = (__bridge_transfer NSError *)cfError;
-            NSString *msg = [NSString stringWithFormat:@"ECIES encryption failed: %@",
-                             nsError.localizedDescription];
-            snprintf_error(error_out, error_out_len, msg);
-            return -1;
-        }
-
-        const UInt8 *encBytes = CFDataGetBytePtr(encrypted);
-        CFIndex encLength = CFDataGetLength(encrypted);
-
-        if (encLength > *ciphertext_len) {
-            CFRelease(encrypted);
-            snprintf_error(error_out, error_out_len, @"ciphertext buffer too small");
-            return -1;
-        }
-
-        memcpy(ciphertext_out, encBytes, encLength);
-        *ciphertext_len = (int)encLength;
-        CFRelease(encrypted);
-
-        return 0;
-    }
-}
-
-int se_decrypt(const char *label,
-               const uint8_t *ciphertext, int ciphertext_len,
-               uint8_t *plaintext_out, int *plaintext_len,
-               char *error_out, int error_out_len) {
-    @autoreleasepool {
-        SecKeyRef privateKey = lookup_ctk_private_key(label, error_out, error_out_len);
-        if (!privateKey) {
-            return -1;
-        }
-
-        NSData *ciphertextData = [NSData dataWithBytes:ciphertext length:ciphertext_len];
-
-        CFErrorRef cfError = NULL;
-        CFDataRef decrypted = SecKeyCreateDecryptedData(
-            privateKey,
-            kSecKeyAlgorithmECIESEncryptionStandardVariableIVX963SHA256AESGCM,
-            (__bridge CFDataRef)ciphertextData,
-            &cfError
-        );
-        CFRelease(privateKey);
-
-        if (!decrypted) {
-            NSError *nsError = (__bridge_transfer NSError *)cfError;
-            NSString *msg = [NSString stringWithFormat:@"ECIES decryption failed: %@",
-                             nsError.localizedDescription];
-            snprintf_error(error_out, error_out_len, msg);
-            return -1;
-        }
-
-        const UInt8 *decBytes = CFDataGetBytePtr(decrypted);
-        CFIndex decLength = CFDataGetLength(decrypted);
-
-        if (decLength > *plaintext_len) {
-            CFRelease(decrypted);
-            snprintf_error(error_out, error_out_len, @"plaintext buffer too small");
-            return -1;
-        }
-
-        memcpy(plaintext_out, decBytes, decLength);
-        *plaintext_len = (int)decLength;
-        CFRelease(decrypted);
-
-        return 0;
-    }
-}
-
-int se_delete_key(const char *hash,
-                  char *error_out, int error_out_len) {
-    @autoreleasepool {
-        NSTask *task = [[NSTask alloc] init];
-        task.executableURL = [NSURL fileURLWithPath:@"/usr/sbin/sc_auth"];
-        task.arguments = @[
-            @"delete-ctk-identity",
-            @"-h", [NSString stringWithUTF8String:hash],
-        ];
-
-        NSPipe *stderrPipe = [NSPipe pipe];
-        task.standardOutput = [NSPipe pipe];
-        task.standardError = stderrPipe;
-
-        NSError *nsError = nil;
-        if (![task launchAndReturnError:&nsError]) {
-            NSString *msg = [NSString stringWithFormat:@"failed to launch sc_auth: %@",
-                             nsError.localizedDescription];
-            snprintf_error(error_out, error_out_len, msg);
-            return -1;
-        }
-
-        [task waitUntilExit];
-
-        if (task.terminationStatus != 0) {
-            NSData *stderrData = [stderrPipe.fileHandleForReading readDataToEndOfFile];
-            NSString *stderrStr = [[NSString alloc] initWithData:stderrData
-                                                        encoding:NSUTF8StringEncoding];
-            NSString *msg = [NSString stringWithFormat:@"sc_auth delete failed: %@",
-                             stderrStr ?: @"unknown error"];
-            snprintf_error(error_out, error_out_len, msg);
-            return -1;
-        }
-
-        return 0;
-    }
-}

internal/secret/atomic_test.go

@@ -8,13 +8,12 @@ import (
 	"testing"
 
 	"filippo.io/age"
-	"git.eeqj.de/sneak/secret/internal/macse"
-	"git.eeqj.de/sneak/secret/internal/secret"
-	"git.eeqj.de/sneak/secret/internal/vault"
 	"github.com/awnumar/memguard"
 	"github.com/spf13/afero"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/secret/internal/secret"
+	"sneak.berlin/go/secret/internal/vault"
 )
 
 var errInjected = errors.New("injected failure")
@@ -900,42 +899,3 @@ func TestWriteDirRefusesExistingDir(t *testing.T) {
 		})
 	}
 }
-
-// TestSecureEnclaveUnlockerFailureDeletesKey makes moving a new Secure
-// Enclave unlocker into place fail after its Secure Enclave key is created:
-// the key must be deleted again. Skipped when the add fails before that, as
-// it does everywhere but in a macOS build with cgo on a Mac with a Secure
-// Enclave.
-func TestSecureEnclaveUnlockerFailureDeletesKey(t *testing.T) {
-	t.Parallel()
-
-	mnemonic := testMnemonicBuffer(t)
-	base := afero.NewMemMapFs()
-	_, err := vault.CreateVault(base, testVaultStateDir, testVaultName, mnemonic, nil)
-	require.NoError(t, err)
-
-	// The unlocker's directory is named se-<label of its Secure Enclave key>
-	var seKeyLabel string
-
-	fs := hookFs{Fs: base, before: func(op, path string) error {
-		if op == opRename && filepath.Base(filepath.Dir(path)) == "unlockers.d" {
-			seKeyLabel = strings.TrimPrefix(filepath.Base(path), "se-")
-
-			return errInjected
-		}
-
-		return nil
-	}}
-
-	_, err = secret.CreateSecureEnclaveUnlocker(fs, testVaultStateDir, mnemonic,
-		nil)
-
-	if seKeyLabel == "" {
-		t.Skipf("the add failed before moving the unlocker into place: %v", err)
-	}
-
-	require.ErrorIs(t, err, errInjected)
-
-	_, err = macse.Encrypt(seKeyLabel, []byte("test"))
-	assert.Error(t, err, "Secure Enclave key left behind")
-}

internal/secret/constants.go

@@ -18,9 +18,9 @@ const (
 	EnvGPGKeyID = "SB_GPG_KEY_ID"
 
 	// UnlockerTimeFormat is the layout of the time, in UTC, in the name of a
-	// new unlocker's directory, keychain item and Secure Enclave key. It runs
-	// to the nanosecond, so that every new unlocker, even one added right
-	// after another, gets a directory of its own.
+	// new unlocker's directory. It runs to the nanosecond, so that every new
+	// unlocker, even one added right after another, gets a directory of its
+	// own.
 	UnlockerTimeFormat = "2006-01-02.15.04.05.000000000"
 )
 

internal/secret/crypto.go

@@ -17,16 +17,27 @@ import (
 var (
 	errNilPassphraseBuffer = errors.New("passphrase buffer is nil")
 	errStdinNotTerminal    = errors.New(
-		"cannot read passphrase from non-terminal stdin " +
-			"(piped input or script). Please set the SB_UNLOCK_PASSPHRASE " +
-			"environment variable or run interactively")
+		"stdin is not a terminal (piped input or script)")
 	errStderrNotTerminal = errors.New(
-		"cannot prompt for passphrase: stderr is not a terminal " +
-			"(running in non-interactive mode). Please set the " +
-			"SB_UNLOCK_PASSPHRASE environment variable")
-	errEmptyPassphrase = errors.New("passphrase cannot be empty")
+		"stderr is not a terminal (running in non-interactive mode)")
+	errNothingEntered = errors.New("nothing was entered")
 )
 
+// ErrMnemonicNotRead is wrapped in every error of ReadMnemonic: there is no
+// terminal to read the mnemonic from, reading it failed, or it was empty.
+var ErrMnemonicNotRead = errors.New("failed to read mnemonic")
+
+// ScryptWorkFactor is, when not zero, the scrypt work factor that
+// EncryptWithPassphrase uses instead of age's, 18: log2 of scrypt's cost
+// parameter N. Deriving a key with age's takes about a second and 256 MiB, on
+// purpose, since so does every guess at the passphrase. Only tests set it,
+// lower, before any test runs, so that the passphrase unlockers they create
+// cost nothing; the program leaves it zero. Decryption takes the work factor
+// from the encrypted data, so it needs no setting.
+//
+//nolint:gochecknoglobals // set by the tests of the packages that use this one
+var ScryptWorkFactor int
+
 // EncryptToRecipient encrypts data to a recipient using age
 // The data parameter should be a LockedBuffer for secure memory handling
 func EncryptToRecipient(
@@ -141,6 +152,10 @@ func EncryptWithPassphrase(
 		return nil, fmt.Errorf("failed to create scrypt recipient: %w", err)
 	}
 
+	if ScryptWorkFactor != 0 {
+		recipient.SetWorkFactor(ScryptWorkFactor)
+	}
+
 	return EncryptToRecipient(data, recipient)
 }
 
@@ -166,42 +181,61 @@ func DecryptWithPassphrase(
 
 // ReadPassphrase reads a passphrase securely from the terminal without echoing
 // This version is for unlocking and doesn't require confirmation
-// Returns a LockedBuffer containing the passphrase for secure memory handling
+// Returns a LockedBuffer containing the passphrase for secure memory handling.
+// Every error it returns wraps ErrPassphraseNotRead.
 func ReadPassphrase(prompt string) (*memguard.LockedBuffer, error) {
+	return readFromTerminal(prompt, ErrPassphraseNotRead, EnvUnlockPassphrase)
+}
+
+// ReadMnemonic reads a mnemonic from the terminal as ReadPassphrase reads a
+// passphrase. Every error it returns wraps ErrMnemonicNotRead.
+func ReadMnemonic(prompt string) (*memguard.LockedBuffer, error) {
+	return readFromTerminal(prompt, ErrMnemonicNotRead, EnvMnemonic)
+}
+
+// readFromTerminal reads input from the terminal without echoing it. Every
+// error it returns wraps notRead; without a terminal, the error says to set
+// envVar instead.
+func readFromTerminal(
+	prompt string, notRead error, envVar string,
+) (*memguard.LockedBuffer, error) {
 	// Check if stdin is a terminal
 	if !term.IsTerminal(syscall.Stdin) {
-		// Not a terminal - never read passphrases from piped input
+		// Not a terminal - never read secrets from piped input
 		// for security reasons
-		return nil, errStdinNotTerminal
+		return nil, fmt.Errorf(
+			"%w: %w. Please set the %s environment variable or run interactively",
+			notRead, errStdinNotTerminal, envVar)
 	}
 
 	// stdin is a terminal, check if stderr is also a terminal for
 	// interactive prompting
 	if !term.IsTerminal(syscall.Stderr) {
-		return nil, errStderrNotTerminal
+		return nil, fmt.Errorf("%w: %w. Please set the %s environment variable",
+			notRead, errStderrNotTerminal, envVar)
 	}
 
 	// Both stdin and stderr are terminals - use secure password reading
 	fmt.Fprint(os.Stderr, prompt) // Write prompt to stderr, not stdout
 
-	passphrase, err := term.ReadPassword(syscall.Stdin)
+	input, err := term.ReadPassword(syscall.Stdin)
 	if err != nil {
-		return nil, fmt.Errorf("failed to read passphrase: %w", err)
+		return nil, fmt.Errorf("%w: %w", notRead, err)
 	}
 
 	// Print newline to stderr since ReadPassword doesn't echo
 	fmt.Fprintln(os.Stderr)
 
-	if len(passphrase) == 0 {
-		return nil, errEmptyPassphrase
+	if len(input) == 0 {
+		return nil, fmt.Errorf("%w: %w", notRead, errNothingEntered)
 	}
 
-	// Create a secure buffer and copy the passphrase
-	secureBuffer := memguard.NewBufferFromBytes(passphrase)
+	// Create a secure buffer and copy the input
+	secureBuffer := memguard.NewBufferFromBytes(input)
 
-	// Clear the original passphrase slice
-	for i := range passphrase {
-		passphrase[i] = 0
+	// Clear the original input slice
+	for i := range input {
+		input[i] = 0
 	}
 
 	return secureBuffer, nil

internal/secret/crypto_test.go

@@ -4,9 +4,9 @@ import (
 	"testing"
 
 	"filippo.io/age"
-	"git.eeqj.de/sneak/secret/internal/secret"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/secret/internal/secret"
 )
 
 // TestIdentityToLockedBuffer checks that the buffer holds the identity's

internal/secret/derivation_index_test.go

@@ -1,118 +0,0 @@
-//go:build darwin
-
-//nolint:testpackage // white-box test of unexported getLongTermPrivateKey
-package secret
-
-import (
-	"encoding/json"
-	"path/filepath"
-	"testing"
-	"time"
-
-	"filippo.io/age"
-	"git.eeqj.de/sneak/secret/pkg/agehd"
-	"github.com/awnumar/memguard"
-	"github.com/spf13/afero"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// realVault is a minimal VaultInterface backed by a real afero filesystem,
-// using the same directory layout as vault.Vault.
-type realVault struct {
-	name     string
-	stateDir string
-	fs       afero.Fs
-}
-
-func (v *realVault) GetDirectory() (string, error) {
-	return filepath.Join(v.stateDir, "vaults.d", v.name), nil
-}
-func (v *realVault) GetName() string { return v.name }
-
-//nolint:ireturn // implements VaultInterface
-func (v *realVault) GetFilesystem() afero.Fs { return v.fs }
-
-// Unused by getLongTermPrivateKey — these satisfy VaultInterface.
-func (v *realVault) AddSecret(string, *memguard.LockedBuffer, bool) error {
-	panic("not used")
-}
-
-//nolint:ireturn // implements VaultInterface
-func (v *realVault) GetCurrentUnlocker() (Unlocker, error) {
-	panic("not used")
-}
-
-func (v *realVault) GetOrDeriveLongTermKey() (*age.X25519Identity, error) {
-	panic("not used")
-}
-
-func (v *realVault) SetMnemonic(*memguard.LockedBuffer) {
-	panic("not used")
-}
-
-func (v *realVault) SetUnlockPassphrase(*memguard.LockedBuffer) {
-	panic("not used")
-}
-
-func (v *realVault) CreatePassphraseUnlocker(
-	*memguard.LockedBuffer,
-) (*PassphraseUnlocker, error) {
-	panic("not used")
-}
-
-// createRealVault sets up a complete vault directory structure on an in-memory
-// filesystem, identical to what vault.CreateVault produces.
-func createRealVault(
-	t *testing.T, fs afero.Fs, stateDir, name string, derivationIndex uint32,
-) *realVault {
-	t.Helper()
-
-	vaultDir := filepath.Join(stateDir, "vaults.d", name)
-	require.NoError(t, fs.MkdirAll(filepath.Join(vaultDir, "secrets.d"), DirPerms))
-	require.NoError(t, fs.MkdirAll(filepath.Join(vaultDir, "unlockers.d"), DirPerms))
-
-	metadata := VaultMetadata{
-		CreatedAt:       time.Now(),
-		DerivationIndex: derivationIndex,
-	}
-	metaBytes, err := json.Marshal(metadata)
-	require.NoError(t, err)
-	require.NoError(t, afero.WriteFile(fs,
-		filepath.Join(vaultDir, "vault-metadata.json"), metaBytes, FilePerms))
-
-	return &realVault{name: name, stateDir: stateDir, fs: fs}
-}
-
-func TestGetLongTermPrivateKeyUsesVaultDerivationIndex(t *testing.T) {
-	t.Parallel()
-
-	//nolint:dupword // BIP39 test mnemonic repeats words by design
-	const testMnemonic = "abandon abandon abandon abandon abandon abandon " +
-		"abandon abandon abandon abandon abandon about"
-
-	// Derive expected keys at two different indices to prove they differ.
-	key0, err := agehd.DeriveIdentity(testMnemonic, 0)
-	require.NoError(t, err)
-	key5, err := agehd.DeriveIdentity(testMnemonic, 5)
-	require.NoError(t, err)
-	require.NotEqual(t, key0.String(), key5.String(),
-		"sanity check: different derivation indices must produce different keys")
-
-	// Build a real vault with DerivationIndex=5 on an in-memory filesystem.
-	fs := afero.NewMemMapFs()
-	vault := createRealVault(t, fs, "/state", "test-vault", 5)
-
-	mnemonic := memguard.NewBufferFromBytes([]byte(testMnemonic))
-	defer mnemonic.Destroy()
-
-	result, err := getLongTermPrivateKey(fs, vault, mnemonic, nil)
-	require.NoError(t, err)
-
-	defer result.Destroy()
-
-	assert.Equal(t, key5.String(), string(result.Bytes()),
-		"getLongTermPrivateKey should derive at vault's DerivationIndex (5)")
-	assert.NotEqual(t, key0.String(), string(result.Bytes()),
-		"getLongTermPrivateKey must not use hardcoded index 0")
-}

internal/secret/helpers_test.go

@@ -3,7 +3,7 @@ package secret_test
 import (
 	"testing"
 
-	"git.eeqj.de/sneak/secret/internal/secret"
+	"sneak.berlin/go/secret/internal/secret"
 )
 
 func TestDetermineStateDir_ErrorsWhenHomeDirUnavailable(t *testing.T) {

internal/secret/keychaindata.go

@@ -1,142 +0,0 @@
-package secret
-
-import (
-	"bytes"
-	"encoding/hex"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"strings"
-
-	"github.com/awnumar/memguard"
-)
-
-var (
-	errPassphraseLength = errors.New(
-		"passphrase length must be a positive even number")
-	errPassphraseNotHex = errors.New(
-		"keychain passphrase must be lowercase hex")
-	errNoKeychainPassphrase = errors.New(
-		"keychain data has no agePrivKeyPassphrase string")
-)
-
-// KeychainData is what a keychain unlocker stores in the macOS keychain.
-// It is stored as JSON, but encode and decodeKeychainData keep the
-// passphrase out of encoding/json, which would leave copies of it in
-// ordinary memory.
-type KeychainData struct {
-	AgePublicKey         string
-	AgePrivKeyPassphrase *memguard.LockedBuffer
-	EncryptedLongtermKey string
-}
-
-// generateRandomPassphrase returns length random lowercase hex characters
-// in a locked buffer. The caller must destroy it.
-func generateRandomPassphrase(length int) (*memguard.LockedBuffer, error) {
-	// Each random byte becomes two hex characters.
-	randomBytes := hex.DecodedLen(length)
-	if length <= 0 || hex.EncodedLen(randomBytes) != length {
-		return nil, errPassphraseLength
-	}
-
-	random := memguard.NewBufferRandom(randomBytes)
-	defer random.Destroy()
-
-	passphrase := memguard.NewBuffer(length)
-	hex.Encode(passphrase.Bytes(), random.Bytes())
-	passphrase.Freeze()
-
-	return passphrase, nil
-}
-
-// encode returns d as JSON in a locked buffer:
-// {"agePublicKey":"...","agePrivKeyPassphrase":"...","encryptedLongtermKey":"..."}.
-// The passphrase is copied straight into the buffer, so it must be hex,
-// which JSON does not escape. The caller must destroy the returned buffer.
-func (d *KeychainData) encode() (*memguard.LockedBuffer, error) {
-	if d.AgePrivKeyPassphrase == nil {
-		return nil, errNilPassphraseBuffer
-	}
-
-	if d.AgePrivKeyPassphrase.Size() == 0 {
-		return nil, errEmptyPassphrase
-	}
-
-	for _, c := range d.AgePrivKeyPassphrase.Bytes() {
-		if strings.IndexByte("0123456789abcdef", c) < 0 {
-			return nil, errPassphraseNotHex
-		}
-	}
-
-	publicKey, err := json.Marshal(d.AgePublicKey)
-	if err != nil {
-		return nil, fmt.Errorf("failed to encode age public key: %w", err)
-	}
-
-	longtermKey, err := json.Marshal(d.EncryptedLongtermKey)
-	if err != nil {
-		return nil, fmt.Errorf("failed to encode long-term key: %w", err)
-	}
-
-	parts := [][]byte{
-		[]byte(`{"agePublicKey":`), publicKey,
-		[]byte(`,"agePrivKeyPassphrase":"`), d.AgePrivKeyPassphrase.Bytes(),
-		[]byte(`","encryptedLongtermKey":`), longtermKey,
-		[]byte(`}`),
-	}
-
-	size := 0
-	for _, part := range parts {
-		size += len(part)
-	}
-
-	encoded := memguard.NewBuffer(size)
-
-	written := 0
-	for _, part := range parts {
-		written += copy(encoded.Bytes()[written:], part)
-	}
-
-	encoded.Freeze()
-
-	return encoded, nil
-}
-
-// decodeKeychainData parses keychain data written by encode. The caller
-// must destroy the returned AgePrivKeyPassphrase.
-func decodeKeychainData(data *memguard.LockedBuffer) (*KeychainData, error) {
-	if data == nil {
-		return nil, errNilDataBuffer
-	}
-
-	// json.Unmarshal gives a json.RawMessage field the field's JSON text
-	// unchanged, in the one copy RawMessage makes; it is wiped on return.
-	var fields struct {
-		AgePublicKey         string          `json:"agePublicKey"`
-		AgePrivKeyPassphrase json.RawMessage `json:"agePrivKeyPassphrase"`
-		EncryptedLongtermKey string          `json:"encryptedLongtermKey"`
-	}
-
-	defer func() { memguard.WipeBytes(fields.AgePrivKeyPassphrase) }()
-
-	err := json.Unmarshal(data.Bytes(), &fields)
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse keychain data: %w", err)
-	}
-
-	// json.Unmarshal accepted the JSON, so text that starts with a quote is
-	// a whole string. The passphrase is hex, so it is the text between the
-	// quotes.
-	quoted := fields.AgePrivKeyPassphrase
-	if !bytes.HasPrefix(quoted, []byte(`"`)) {
-		return nil, errNoKeychainPassphrase
-	}
-
-	return &KeychainData{
-		AgePublicKey: fields.AgePublicKey,
-		// NewBufferFromBytes wipes the bytes it copies.
-		AgePrivKeyPassphrase: memguard.NewBufferFromBytes(
-			quoted[1 : len(quoted)-1]),
-		EncryptedLongtermKey: fields.EncryptedLongtermKey,
-	}, nil
-}

internal/secret/keychaindata_test.go

@@ -1,118 +0,0 @@
-//nolint:testpackage // white-box test of unexported internals
-package secret
-
-import (
-	"encoding/json"
-	"testing"
-
-	"github.com/awnumar/memguard"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestGenerateRandomPassphrase(t *testing.T) {
-	t.Parallel()
-
-	first, err := generateRandomPassphrase(64)
-	require.NoError(t, err)
-
-	defer first.Destroy()
-
-	second, err := generateRandomPassphrase(64)
-	require.NoError(t, err)
-
-	defer second.Destroy()
-
-	assert.Regexp(t, `^[0-9a-f]{64}$`, first.String())
-	assert.NotEqual(t, first.String(), second.String())
-	assert.False(t, first.IsMutable())
-
-	for _, length := range []int{0, -2, 63} {
-		_, err := generateRandomPassphrase(length)
-		require.ErrorIs(t, err, errPassphraseLength, "length %d", length)
-	}
-}
-
-func TestKeychainDataEncodeDecode(t *testing.T) {
-	t.Parallel()
-
-	passphrase := memguard.NewBufferFromBytes([]byte("0a1b2c3d"))
-	defer passphrase.Destroy()
-
-	data := KeychainData{
-		AgePublicKey:         "age1example",
-		AgePrivKeyPassphrase: passphrase,
-		EncryptedLongtermKey: "beef",
-	}
-
-	encoded, err := data.encode()
-	require.NoError(t, err)
-
-	defer encoded.Destroy()
-
-	assert.JSONEq(t,
-		`{"agePublicKey":"age1example",`+
-			`"agePrivKeyPassphrase":"0a1b2c3d",`+
-			`"encryptedLongtermKey":"beef"}`,
-		encoded.String())
-	assert.False(t, encoded.IsMutable())
-
-	decoded, err := decodeKeychainData(encoded)
-	require.NoError(t, err)
-
-	defer decoded.AgePrivKeyPassphrase.Destroy()
-
-	assert.Equal(t, "age1example", decoded.AgePublicKey)
-	assert.Equal(t, "0a1b2c3d", decoded.AgePrivKeyPassphrase.String())
-	assert.Equal(t, "beef", decoded.EncryptedLongtermKey)
-}
-
-func TestKeychainDataEncodeRejectsBadPassphrase(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name       string
-		passphrase *memguard.LockedBuffer
-		wantErr    error
-	}{
-		{"nil", nil, errNilPassphraseBuffer},
-		{"empty", memguard.NewBuffer(0), errEmptyPassphrase},
-		{
-			"not hex",
-			memguard.NewBufferFromBytes([]byte(`abc"def`)),
-			errPassphraseNotHex,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			data := KeychainData{AgePrivKeyPassphrase: tt.passphrase}
-			_, err := data.encode()
-			require.ErrorIs(t, err, tt.wantErr)
-		})
-	}
-}
-
-func TestDecodeKeychainDataRejectsBadData(t *testing.T) {
-	t.Parallel()
-
-	for _, text := range []string{
-		`{"agePublicKey":"age1example"}`,
-		`{"agePrivKeyPassphrase":42}`,
-	} {
-		data := memguard.NewBufferFromBytes([]byte(text))
-		_, err := decodeKeychainData(data)
-		data.Destroy()
-		require.ErrorIs(t, err, errNoKeychainPassphrase, text)
-	}
-
-	notJSON := memguard.NewBufferFromBytes([]byte(`{"agePrivKeyPassphrase":`))
-	defer notJSON.Destroy()
-
-	_, err := decodeKeychainData(notJSON)
-
-	var syntaxError *json.SyntaxError
-	require.ErrorAs(t, err, &syntaxError)
-}

internal/secret/keychainunlocker.go

@@ -1,579 +0,0 @@
-//go:build darwin
-
-package secret
-
-import (
-	"encoding/hex"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"log/slog"
-	"os"
-	"path/filepath"
-	"regexp"
-	"runtime"
-	"time"
-
-	"filippo.io/age"
-	"git.eeqj.de/sneak/secret/pkg/agehd"
-	"github.com/awnumar/memguard"
-	"github.com/spf13/afero"
-)
-
-const (
-	agePrivKeyPassphraseLength = 64
-	// KEYCHAIN_APP_IDENTIFIER is the service name used for keychain items
-	//
-	//nolint:revive // ALL_CAPS is intentional for this constant
-	KEYCHAIN_APP_IDENTIFIER = "berlin.sneak.app.secret"
-
-	// keychainUnlockerType is the metadata type string for keychain unlockers.
-	keychainUnlockerType = "keychain"
-
-	// macOSFlag is the unlocker metadata flag of the macOS-only unlockers.
-	macOSFlag = "macos"
-)
-
-// keychainItemNameRegex validates keychain item names
-// Allows alphanumeric characters, dots, hyphens, and underscores only
-var keychainItemNameRegex = regexp.MustCompile(`^[A-Za-z0-9._-]+$`)
-
-var (
-	errNotMacOS = errors.New(
-		"keychain unlockers are only supported on macOS")
-	errKeychainItemNameEmpty      = errors.New("keychain item name cannot be empty")
-	errInvalidKeychainItemName    = errors.New("invalid keychain item name format")
-	errUnsupportedCurrentUnlocker = errors.New(
-		"unsupported current unlocker type for keychain unlocker creation")
-)
-
-// KeychainUnlockerMetadata extends UnlockerMetadata with keychain-specific data
-type KeychainUnlockerMetadata struct {
-	UnlockerMetadata
-
-	// Keychain item name
-	KeychainItemName string `json:"keychainItemName"`
-}
-
-// KeychainUnlocker represents a macOS Keychain-protected unlocker
-type KeychainUnlocker struct {
-	Directory string
-	Metadata  UnlockerMetadata
-	fs        afero.Fs
-}
-
-// NewKeychainUnlocker creates a new KeychainUnlocker instance
-func NewKeychainUnlocker(
-	fs afero.Fs, directory string, metadata UnlockerMetadata,
-) *KeychainUnlocker {
-	return &KeychainUnlocker{
-		Directory: directory,
-		Metadata:  metadata,
-		fs:        fs,
-	}
-}
-
-// GetIdentity implements Unlocker interface for Keychain-based unlockers
-func (k *KeychainUnlocker) GetIdentity() (*age.X25519Identity, error) {
-	DebugWith("Getting keychain unlocker identity",
-		slog.String("unlocker_id", k.GetID()),
-		slog.String("unlocker_type", k.GetType()),
-	)
-
-	keychainData, err := k.readKeychainData()
-	if err != nil {
-		return nil, err
-	}
-	defer keychainData.AgePrivKeyPassphrase.Destroy()
-
-	// Step 4: Read the encrypted age private key from filesystem
-	agePrivKeyPath := filepath.Join(k.Directory, "priv.age")
-	Debug("Reading encrypted age private key", "path", agePrivKeyPath)
-
-	encryptedAgePrivKeyData, err := afero.ReadFile(k.fs, agePrivKeyPath)
-	if err != nil {
-		Debug("Failed to read encrypted age private key",
-			"error", err, "path", agePrivKeyPath)
-
-		return nil, fmt.Errorf("failed to read encrypted age private key: %w", err)
-	}
-
-	DebugWith("Read encrypted age private key",
-		slog.String("unlocker_id", k.GetID()),
-		slog.Int("encrypted_length", len(encryptedAgePrivKeyData)),
-	)
-
-	// Step 5: Decrypt the age private key using the passphrase from keychain
-	Debug("Decrypting age private key with keychain passphrase",
-		"unlocker_id", k.GetID())
-
-	agePrivKeyBuffer, err := DecryptWithPassphrase(
-		encryptedAgePrivKeyData, keychainData.AgePrivKeyPassphrase)
-	if err != nil {
-		Debug("Failed to decrypt age private key with keychain passphrase",
-			"error", err, "unlocker_id", k.GetID())
-
-		return nil, fmt.Errorf(
-			"failed to decrypt age private key with keychain passphrase: %w", err)
-	}
-	defer agePrivKeyBuffer.Destroy()
-
-	DebugWith("Successfully decrypted age private key with keychain passphrase",
-		slog.String("unlocker_id", k.GetID()),
-		slog.Int("decrypted_length", agePrivKeyBuffer.Size()),
-	)
-
-	// Step 6: Parse the decrypted age private key
-	Debug("Parsing decrypted age private key", "unlocker_id", k.GetID())
-
-	ageIdentity, err := age.ParseX25519Identity(agePrivKeyBuffer.String())
-	if err != nil {
-		Debug("Failed to parse age private key", "error", err, "unlocker_id", k.GetID())
-
-		return nil, fmt.Errorf("failed to parse age private key: %w", err)
-	}
-
-	DebugWith("Successfully parsed keychain age identity",
-		slog.String("unlocker_id", k.GetID()),
-		slog.String("public_key", ageIdentity.Recipient().String()),
-	)
-
-	return ageIdentity, nil
-}
-
-// GetType implements Unlocker interface
-func (k *KeychainUnlocker) GetType() string {
-	return keychainUnlockerType
-}
-
-// GetMetadata implements Unlocker interface
-func (k *KeychainUnlocker) GetMetadata() UnlockerMetadata {
-	return k.Metadata
-}
-
-// GetDirectory implements Unlocker interface
-func (k *KeychainUnlocker) GetDirectory() string {
-	return k.Directory
-}
-
-// GetID implements Unlocker interface: the name of the unlocker's directory
-func (k *KeychainUnlocker) GetID() string {
-	return filepath.Base(k.Directory)
-}
-
-// Remove implements Unlocker interface - removes the keychain unlocker
-func (k *KeychainUnlocker) Remove() error {
-	// Step 1: Get keychain item name
-	keychainItemName, err := k.GetKeychainItemName()
-	if err != nil {
-		Debug("Failed to get keychain item name during removal",
-			"error", err, "unlocker_id", k.GetID())
-
-		return fmt.Errorf("failed to get keychain item name: %w", err)
-	}
-
-	// Step 2: Remove from keychain
-	Debug("Removing keychain item", "keychain_item", keychainItemName)
-
-	err = deleteFromKeychain(keychainItemName)
-	if err != nil {
-		Debug("Failed to remove keychain item",
-			"error", err, "keychain_item", keychainItemName)
-
-		return fmt.Errorf("failed to remove keychain item: %w", err)
-	}
-
-	// Step 3: Remove directory
-	Debug("Removing keychain unlocker directory", "directory", k.Directory)
-
-	err = RemoveDirAtomic(k.fs, k.Directory)
-	if err != nil {
-		Debug("Failed to remove keychain unlocker directory",
-			"error", err, "directory", k.Directory)
-
-		return fmt.Errorf("failed to remove keychain unlocker directory: %w", err)
-	}
-
-	Debug("Successfully removed keychain unlocker",
-		"unlocker_id", k.GetID(), "keychain_item", keychainItemName)
-
-	return nil
-}
-
-// GetKeychainItemName returns the keychain item name from metadata
-func (k *KeychainUnlocker) GetKeychainItemName() (string, error) {
-	// Load the metadata
-	metadataPath := filepath.Join(k.Directory, "unlocker-metadata.json")
-
-	metadataData, err := afero.ReadFile(k.fs, metadataPath)
-	if err != nil {
-		return "", fmt.Errorf("failed to read keychain metadata: %w", err)
-	}
-
-	var keychainMetadata KeychainUnlockerMetadata
-
-	err = json.Unmarshal(metadataData, &keychainMetadata)
-	if err != nil {
-		return "", fmt.Errorf("failed to parse keychain metadata: %w", err)
-	}
-
-	return keychainMetadata.KeychainItemName, nil
-}
-
-// readKeychainData reads and parses the data this unlocker keeps in the
-// keychain (steps 1 to 3 of GetIdentity). The caller must destroy the
-// returned AgePrivKeyPassphrase.
-func (k *KeychainUnlocker) readKeychainData() (*KeychainData, error) {
-	// Step 1: Get keychain item name
-	keychainItemName, err := k.GetKeychainItemName()
-	if err != nil {
-		Debug("Failed to get keychain item name", "error", err, "unlocker_id", k.GetID())
-
-		return nil, fmt.Errorf("failed to get keychain item name: %w", err)
-	}
-
-	// Step 2: Retrieve data from keychain
-	Debug("Retrieving data from macOS keychain", "keychain_item", keychainItemName)
-
-	keychainDataBytes, err := retrieveFromKeychain(keychainItemName)
-	if err != nil {
-		Debug("Failed to retrieve data from keychain",
-			"error", err, "keychain_item", keychainItemName)
-
-		return nil, fmt.Errorf("failed to retrieve data from keychain: %w", err)
-	}
-
-	DebugWith("Retrieved data from keychain",
-		slog.String("unlocker_id", k.GetID()),
-		slog.Int("data_length", len(keychainDataBytes)),
-	)
-
-	// Move the keychain data into locked memory; this wipes keychainDataBytes
-	keychainDataBuffer := memguard.NewBufferFromBytes(keychainDataBytes)
-	defer keychainDataBuffer.Destroy()
-
-	// Step 3: Parse keychain data
-	keychainData, err := decodeKeychainData(keychainDataBuffer)
-	if err != nil {
-		Debug("Failed to parse keychain data", "error", err, "unlocker_id", k.GetID())
-
-		return nil, fmt.Errorf("failed to parse keychain data: %w", err)
-	}
-
-	Debug("Parsed keychain data successfully", "unlocker_id", k.GetID())
-
-	return keychainData, nil
-}
-
-// generateKeychainUnlockerName generates a unique name for the keychain unlocker
-func generateKeychainUnlockerName(vaultName string) (string, error) {
-	hostname, err := os.Hostname()
-	if err != nil {
-		return "", fmt.Errorf("failed to get hostname: %w", err)
-	}
-
-	// Format: secret-<vault>-<hostname>-<time>
-	enrollmentTime := time.Now().UTC().Format(UnlockerTimeFormat)
-
-	return fmt.Sprintf("secret-%s-%s-%s", vaultName, hostname, enrollmentTime), nil
-}
-
-// getLongTermPrivateKey derives the long-term private key from mnemonic when
-// it is not nil, else gets it through the current unlocker, which is given
-// passphrase when it is a passphrase unlocker.
-// Returns a LockedBuffer to ensure the private key is protected in memory
-func getLongTermPrivateKey(
-	fs afero.Fs, vault VaultInterface, mnemonic, passphrase *memguard.LockedBuffer,
-) (*memguard.LockedBuffer, error) {
-	if mnemonic != nil {
-		return deriveLongTermPrivateKey(fs, vault, mnemonic)
-	}
-
-	// Get the vault to access current unlocker
-	currentUnlocker, err := vault.GetCurrentUnlocker()
-	if err != nil {
-		return nil, fmt.Errorf("failed to get current unlocker: %w", err)
-	}
-
-	if passphraseUnlocker, ok := currentUnlocker.(*PassphraseUnlocker); ok {
-		passphraseUnlocker.Passphrase = passphrase
-	}
-
-	// Get the current unlocker identity
-	currentUnlockerIdentity, err := currentUnlocker.GetIdentity()
-	if err != nil {
-		return nil, fmt.Errorf("failed to get current unlocker identity: %w", err)
-	}
-
-	// Get encrypted long-term key from current unlocker, handling different types
-	var encryptedLtPrivKey []byte
-
-	switch currentUnlocker := currentUnlocker.(type) {
-	case *PassphraseUnlocker:
-		// Read the encrypted long-term private key from passphrase unlocker
-		encryptedLtPrivKey, err = afero.ReadFile(fs,
-			filepath.Join(currentUnlocker.GetDirectory(), "longterm.age"))
-		if err != nil {
-			return nil, fmt.Errorf("failed to read encrypted long-term key "+
-				"from current passphrase unlocker: %w", err)
-		}
-
-	case *PGPUnlocker:
-		// Read the encrypted long-term private key from PGP unlocker
-		encryptedLtPrivKey, err = afero.ReadFile(fs,
-			filepath.Join(currentUnlocker.GetDirectory(), "longterm.age"))
-		if err != nil {
-			return nil, fmt.Errorf("failed to read encrypted long-term key "+
-				"from current PGP unlocker: %w", err)
-		}
-
-	case *KeychainUnlocker:
-		// Read the encrypted long-term private key from another keychain
-		// unlocker
-		encryptedLtPrivKey, err = afero.ReadFile(fs,
-			filepath.Join(currentUnlocker.GetDirectory(), "longterm.age"))
-		if err != nil {
-			return nil, fmt.Errorf("failed to read encrypted long-term key "+
-				"from current keychain unlocker: %w", err)
-		}
-
-	default:
-		return nil, errUnsupportedCurrentUnlocker
-	}
-
-	// Decrypt long-term private key using current unlocker
-	ltPrivKeyBuffer, err := DecryptWithIdentity(
-		encryptedLtPrivKey, currentUnlockerIdentity)
-	if err != nil {
-		return nil, fmt.Errorf("failed to decrypt long-term private key: %w", err)
-	}
-
-	// Return the decrypted key buffer
-	return ltPrivKeyBuffer, nil
-}
-
-// deriveLongTermPrivateKey derives the long-term private key from mnemonic at
-// the vault's derivation index, for getLongTermPrivateKey and
-// getLongTermKeyForSE.
-func deriveLongTermPrivateKey(
-	fs afero.Fs, vault VaultInterface, mnemonic *memguard.LockedBuffer,
-) (*memguard.LockedBuffer, error) {
-	// Read vault metadata to get the correct derivation index
-	vaultDir, err := vault.GetDirectory()
-	if err != nil {
-		return nil, fmt.Errorf("failed to get vault directory: %w", err)
-	}
-
-	metadataPath := filepath.Join(vaultDir, "vault-metadata.json")
-
-	metadataBytes, err := afero.ReadFile(fs, metadataPath)
-	if err != nil {
-		return nil, fmt.Errorf("failed to read vault metadata: %w", err)
-	}
-
-	var metadata VaultMetadata
-
-	err = json.Unmarshal(metadataBytes, &metadata)
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse vault metadata: %w", err)
-	}
-
-	// Use mnemonic with the vault's actual derivation index
-	ltIdentity, err := agehd.DeriveIdentity(mnemonic.String(), metadata.DerivationIndex)
-	if err != nil {
-		return nil, fmt.Errorf(
-			"failed to derive long-term key from mnemonic: %w", err)
-	}
-
-	return IdentityToLockedBuffer(ltIdentity), nil
-}
-
-// CreateKeychainUnlocker creates a new keychain unlocker and stores it in the
-// vault. The long-term key comes from mnemonic when it is not nil, else from
-// the current unlocker, as getLongTermPrivateKey describes.
-func CreateKeychainUnlocker(
-	fs afero.Fs, stateDir string, mnemonic, passphrase *memguard.LockedBuffer,
-) (*KeychainUnlocker, error) {
-	// Check if we're on macOS
-	err := checkMacOSAvailable()
-	if err != nil {
-		return nil, err
-	}
-
-	// Get current vault using the GetCurrentVault function from the same package
-	vault, err := GetCurrentVault(fs, stateDir)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get current vault: %w", err)
-	}
-
-	// Generate the keychain item name
-	keychainItemName, err := generateKeychainUnlockerName(vault.GetName())
-	if err != nil {
-		return nil, fmt.Errorf("failed to generate keychain item name: %w", err)
-	}
-
-	// The unlocker directory is named after the keychain item
-	vaultDir, err := vault.GetDirectory()
-	if err != nil {
-		return nil, fmt.Errorf("failed to get vault directory: %w", err)
-	}
-
-	unlockerDir := filepath.Join(vaultDir, "unlockers.d", keychainItemName)
-
-	// Step 1: Generate a new age keypair for the keychain unlocker
-	ageIdentity, err := age.GenerateX25519Identity()
-	if err != nil {
-		return nil, fmt.Errorf("failed to generate age keypair: %w", err)
-	}
-
-	ageRecipient := ageIdentity.Recipient().String()
-
-	// Step 2: Generate a random passphrase for encrypting the age private key
-	agePrivKeyPassphrase, err := generateRandomPassphrase(agePrivKeyPassphraseLength)
-	if err != nil {
-		return nil, fmt.Errorf("failed to generate age private key passphrase: %w", err)
-	}
-	defer agePrivKeyPassphrase.Destroy()
-
-	// Step 3: Encrypt age private key with the generated passphrase
-	agePrivKeyBuffer := IdentityToLockedBuffer(ageIdentity)
-	defer agePrivKeyBuffer.Destroy()
-
-	encryptedAgePrivKey, err := EncryptWithPassphrase(
-		agePrivKeyBuffer, agePrivKeyPassphrase)
-	if err != nil {
-		return nil, fmt.Errorf("failed to encrypt age private key with passphrase: %w", err)
-	}
-
-	// Step 4: Get or derive the long-term private key
-	ltPrivKeyData, err := getLongTermPrivateKey(fs, vault, mnemonic, passphrase)
-	if err != nil {
-		return nil, err
-	}
-	defer ltPrivKeyData.Destroy()
-
-	// Step 5: Encrypt long-term private key to the new age unlocker
-	encryptedLtPrivKeyToAge, err := EncryptToRecipient(
-		ltPrivKeyData, ageIdentity.Recipient())
-	if err != nil {
-		return nil, fmt.Errorf(
-			"failed to encrypt long-term private key to age unlocker: %w", err)
-	}
-
-	// Step 6: Prepare keychain data
-	keychainData := KeychainData{
-		AgePublicKey:         ageRecipient,
-		AgePrivKeyPassphrase: agePrivKeyPassphrase,
-		EncryptedLongtermKey: hex.EncodeToString(encryptedLtPrivKeyToAge),
-	}
-
-	keychainDataBuffer, err := keychainData.encode()
-	if err != nil {
-		return nil, fmt.Errorf("failed to encode keychain data: %w", err)
-	}
-	defer keychainDataBuffer.Destroy()
-
-	return writeKeychainUnlocker(fs, unlockerDir, keychainItemName, ageRecipient,
-		encryptedAgePrivKey, encryptedLtPrivKeyToAge, keychainDataBuffer)
-}
-
-// writeKeychainUnlocker writes a new keychain unlocker into unlockerDir and
-// stores its data in the keychain (steps 7 and 8 of CreateKeychainUnlocker).
-// The data is stored after the unlocker's files are written, and the keychain
-// item is deleted again if moving the unlocker into place then fails.
-func writeKeychainUnlocker(
-	fs afero.Fs, unlockerDir, keychainItemName, ageRecipient string,
-	encryptedAgePrivKey, encryptedLtPrivKey []byte,
-	keychainDataBuffer *memguard.LockedBuffer,
-) (*KeychainUnlocker, error) {
-	// Step 7: Prepare enhanced metadata
-	keychainMetadata := KeychainUnlockerMetadata{
-		UnlockerMetadata: UnlockerMetadata{
-			Type:      keychainUnlockerType,
-			CreatedAt: time.Now(),
-			Flags:     []string{keychainUnlockerType, macOSFlag},
-		},
-		KeychainItemName: keychainItemName,
-	}
-
-	metadataBytes, err := json.MarshalIndent(keychainMetadata, "", "  ")
-	if err != nil {
-		return nil, fmt.Errorf("failed to marshal unlocker metadata: %w", err)
-	}
-
-	// Step 8: Write the unlocker's files, the metadata last, then store the
-	// data in the keychain
-	stored := false
-
-	err = WriteDir(fs, unlockerDir, func(dir string) error {
-		err := WriteFileAtomic(fs, filepath.Join(dir, "pub.txt"), []byte(ageRecipient))
-		if err != nil {
-			return fmt.Errorf("failed to write age recipient: %w", err)
-		}
-
-		err = WriteFileAtomic(fs, filepath.Join(dir, "priv.age"), encryptedAgePrivKey)
-		if err != nil {
-			return fmt.Errorf("failed to write encrypted age private key: %w", err)
-		}
-
-		err = WriteFileAtomic(fs, filepath.Join(dir, "longterm.age"), encryptedLtPrivKey)
-		if err != nil {
-			return fmt.Errorf("failed to write encrypted long-term private key: %w", err)
-		}
-
-		err = WriteFileAtomic(fs, filepath.Join(dir, "unlocker-metadata.json"),
-			metadataBytes)
-		if err != nil {
-			return fmt.Errorf("failed to write unlocker metadata: %w", err)
-		}
-
-		err = storeInKeychain(keychainItemName, keychainDataBuffer)
-		if err != nil {
-			return fmt.Errorf("failed to store data in keychain: %w", err)
-		}
-
-		stored = true
-
-		return nil
-	})
-	if err != nil && stored {
-		deleteErr := deleteFromKeychain(keychainItemName)
-		if deleteErr != nil {
-			err = errors.Join(err, fmt.Errorf(
-				"failed to delete keychain item %s: %w", keychainItemName, deleteErr))
-		}
-	}
-
-	if err != nil {
-		return nil, err
-	}
-
-	return &KeychainUnlocker{
-		Directory: unlockerDir,
-		Metadata:  keychainMetadata.UnlockerMetadata,
-		fs:        fs,
-	}, nil
-}
-
-// checkMacOSAvailable verifies that we're running on macOS
-func checkMacOSAvailable() error {
-	if runtime.GOOS != "darwin" {
-		return fmt.Errorf("%w, current OS: %s", errNotMacOS, runtime.GOOS)
-	}
-
-	return nil
-}
-
-// validateKeychainItemName validates that a keychain item name is safe for
-// command execution
-func validateKeychainItemName(itemName string) error {
-	if itemName == "" {
-		return errKeychainItemNameEmpty
-	}
-
-	if !keychainItemNameRegex.MatchString(itemName) {
-		return fmt.Errorf("%w: %s", errInvalidKeychainItemName, itemName)
-	}
-
-	return nil
-}

internal/secret/keychainunlocker_cgo.go

@@ -1,104 +0,0 @@
-//go:build darwin && cgo
-
-package secret
-
-import (
-	"fmt"
-
-	"github.com/awnumar/memguard"
-	keychain "github.com/keybase/go-keychain"
-)
-
-// The keychain unlocker's only calls into go-keychain, which is cgo on macOS.
-// A macOS build without cgo gets keychainunlocker_nocgo.go instead.
-
-// storeInKeychain stores data in the macOS keychain using keybase/go-keychain
-func storeInKeychain(itemName string, data *memguard.LockedBuffer) error {
-	if data == nil {
-		return fmt.Errorf("data buffer is nil")
-	}
-	if err := validateKeychainItemName(itemName); err != nil {
-		return fmt.Errorf("invalid keychain item name: %w", err)
-	}
-
-	item := keychain.NewItem()
-	item.SetSecClass(keychain.SecClassGenericPassword)
-	item.SetService(KEYCHAIN_APP_IDENTIFIER)
-	item.SetAccount(itemName)
-	item.SetLabel(fmt.Sprintf("%s - %s", KEYCHAIN_APP_IDENTIFIER, itemName))
-	item.SetDescription("Secret vault keychain data")
-	item.SetData(data.Bytes())
-	item.SetSynchronizable(keychain.SynchronizableNo)
-	// Use AccessibleWhenUnlockedThisDeviceOnly for better security and to trigger auth
-	item.SetAccessible(keychain.AccessibleWhenUnlockedThisDeviceOnly)
-
-	// First try to delete any existing item
-	deleteItem := keychain.NewItem()
-	deleteItem.SetSecClass(keychain.SecClassGenericPassword)
-	deleteItem.SetService(KEYCHAIN_APP_IDENTIFIER)
-	deleteItem.SetAccount(itemName)
-	_ = keychain.DeleteItem(deleteItem) // Ignore error as item might not exist
-
-	// Add the new item
-	if err := keychain.AddItem(item); err != nil {
-		return fmt.Errorf("failed to store item in keychain: %w", err)
-	}
-
-	return nil
-}
-
-// retrieveFromKeychain retrieves data from the macOS keychain using keybase/go-keychain
-func retrieveFromKeychain(itemName string) ([]byte, error) {
-	if err := validateKeychainItemName(itemName); err != nil {
-		return nil, fmt.Errorf("invalid keychain item name: %w", err)
-	}
-
-	query := keychain.NewItem()
-	query.SetSecClass(keychain.SecClassGenericPassword)
-	query.SetService(KEYCHAIN_APP_IDENTIFIER)
-	query.SetAccount(itemName)
-	query.SetMatchLimit(keychain.MatchLimitOne)
-	query.SetReturnData(true)
-
-	results, err := keychain.QueryItem(query)
-	if err != nil {
-		return nil, fmt.Errorf("failed to retrieve item from keychain: %w", err)
-	}
-
-	if len(results) == 0 {
-		return nil, fmt.Errorf("keychain item not found: %s", itemName)
-	}
-
-	return results[0].Data, nil
-}
-
-// deleteFromKeychain removes an item from the macOS keychain using keybase/go-keychain
-// If the item doesn't exist, this function returns nil (not an error) since the goal
-// is to ensure the item is gone, and it already being gone satisfies that goal.
-func deleteFromKeychain(itemName string) error {
-	if err := validateKeychainItemName(itemName); err != nil {
-		return fmt.Errorf("invalid keychain item name: %w", err)
-	}
-
-	item := keychain.NewItem()
-	item.SetSecClass(keychain.SecClassGenericPassword)
-	item.SetService(KEYCHAIN_APP_IDENTIFIER)
-	item.SetAccount(itemName)
-
-	if err := keychain.DeleteItem(item); err != nil {
-		// If the item doesn't exist, that's not an error - the goal is to ensure
-		// the item is gone, and it already being gone satisfies that goal.
-		// This is important for cleaning up unlocker directories when the keychain
-		// item has already been removed (e.g., manually by user, or synced vault
-		// from a different machine).
-		if err == keychain.ErrorItemNotFound {
-			Debug("Keychain item not found during deletion, ignoring", "item_name", itemName)
-
-			return nil
-		}
-
-		return fmt.Errorf("failed to delete item from keychain: %w", err)
-	}
-
-	return nil
-}

internal/secret/keychainunlocker_nocgo.go

@@ -1,30 +0,0 @@
-//go:build darwin && !cgo
-
-package secret
-
-import (
-	"errors"
-
-	"github.com/awnumar/memguard"
-)
-
-// In a macOS build without cgo, these take the place of the functions in
-// keychainunlocker_cgo.go: go-keychain is cgo on macOS, so they can only fail.
-
-var errKeychainNotSupported = errors.New(
-	"keychain unlockers need a macOS build with cgo")
-
-// storeInKeychain fails: the keychain needs a macOS build with cgo.
-func storeInKeychain(_ string, _ *memguard.LockedBuffer) error {
-	return errKeychainNotSupported
-}
-
-// retrieveFromKeychain fails: the keychain needs a macOS build with cgo.
-func retrieveFromKeychain(_ string) ([]byte, error) {
-	return nil, errKeychainNotSupported
-}
-
-// deleteFromKeychain fails: the keychain needs a macOS build with cgo.
-func deleteFromKeychain(_ string) error {
-	return errKeychainNotSupported
-}

internal/secret/keychainunlocker_stub.go

@@ -1,84 +0,0 @@
-//go:build !darwin
-
-package secret
-
-import (
-	"errors"
-	"path/filepath"
-
-	"filippo.io/age"
-	"github.com/awnumar/memguard"
-	"github.com/spf13/afero"
-)
-
-// KeychainUnlockerMetadata is a stub for non-Darwin platforms
-type KeychainUnlockerMetadata struct {
-	UnlockerMetadata
-
-	KeychainItemName string `json:"keychainItemName"`
-}
-
-// KeychainUnlocker is a stub for non-Darwin platforms
-type KeychainUnlocker struct {
-	Directory string
-	Metadata  UnlockerMetadata
-	fs        afero.Fs
-}
-
-var errKeychainNotSupported = errors.New(
-	"keychain unlockers are only supported on macOS")
-
-// NewKeychainUnlocker creates a stub KeychainUnlocker on non-Darwin
-// platforms. The returned instance's methods that require macOS
-// functionality will return errors.
-func NewKeychainUnlocker(
-	fs afero.Fs, directory string, metadata UnlockerMetadata,
-) *KeychainUnlocker {
-	return &KeychainUnlocker{
-		Directory: directory,
-		Metadata:  metadata,
-		fs:        fs,
-	}
-}
-
-// GetIdentity returns an error on non-Darwin platforms
-func (k *KeychainUnlocker) GetIdentity() (*age.X25519Identity, error) {
-	return nil, errKeychainNotSupported
-}
-
-// GetType returns the unlocker type
-func (k *KeychainUnlocker) GetType() string {
-	return "keychain"
-}
-
-// GetMetadata returns the unlocker metadata
-func (k *KeychainUnlocker) GetMetadata() UnlockerMetadata {
-	return k.Metadata
-}
-
-// GetDirectory returns the unlocker directory
-func (k *KeychainUnlocker) GetDirectory() string {
-	return k.Directory
-}
-
-// GetID returns the unlocker ID, the name of the unlocker's directory
-func (k *KeychainUnlocker) GetID() string {
-	return filepath.Base(k.Directory)
-}
-
-// GetKeychainItemName returns an error on non-Darwin platforms
-func (k *KeychainUnlocker) GetKeychainItemName() (string, error) {
-	return "", errKeychainNotSupported
-}
-
-// Remove returns an error on non-Darwin platforms
-func (k *KeychainUnlocker) Remove() error {
-	return errKeychainNotSupported
-}
-
-// CreateKeychainUnlocker returns an error on non-Darwin platforms
-func CreateKeychainUnlocker(
-	_ afero.Fs, _ string, _, _ *memguard.LockedBuffer,
-) (*KeychainUnlocker, error) {
-	return nil, errKeychainNotSupported
-}

internal/secret/keychainunlocker_test.go

@@ -1,216 +0,0 @@
-//go:build darwin && cgo
-
-package secret
-
-import (
-	"encoding/hex"
-	"os"
-	"path/filepath"
-	"runtime"
-	"testing"
-
-	"github.com/awnumar/memguard"
-	"github.com/spf13/afero"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestKeychainStoreRetrieveDelete(t *testing.T) {
-	// Skip test if not on macOS
-	if runtime.GOOS != "darwin" {
-		t.Skip("Keychain tests only run on macOS")
-	}
-
-	// Test data
-	testItemName := "test-secret-keychain-item"
-	testData := "test-secret-data-12345"
-	testBuffer := memguard.NewBufferFromBytes([]byte(testData))
-	defer testBuffer.Destroy()
-
-	// Clean up any existing item first
-	_ = deleteFromKeychain(testItemName)
-
-	// Test 1: Store data in keychain
-	err := storeInKeychain(testItemName, testBuffer)
-	require.NoError(t, err, "Failed to store data in keychain")
-
-	// Test 2: Retrieve data from keychain
-	retrievedData, err := retrieveFromKeychain(testItemName)
-	require.NoError(t, err, "Failed to retrieve data from keychain")
-	assert.Equal(t, testData, string(retrievedData),
-		"Retrieved data doesn't match stored data")
-
-	// Test 3: Update existing item (store again with different data)
-	newTestData := "updated-test-data-67890"
-	newTestBuffer := memguard.NewBufferFromBytes([]byte(newTestData))
-	defer newTestBuffer.Destroy()
-
-	err = storeInKeychain(testItemName, newTestBuffer)
-	require.NoError(t, err, "Failed to update data in keychain")
-
-	// Verify updated data
-	retrievedData, err = retrieveFromKeychain(testItemName)
-	require.NoError(t, err, "Failed to retrieve updated data from keychain")
-	assert.Equal(t, newTestData, string(retrievedData),
-		"Retrieved data doesn't match updated data")
-
-	// Test 4: Delete from keychain
-	err = deleteFromKeychain(testItemName)
-	require.NoError(t, err, "Failed to delete data from keychain")
-
-	// Test 5: Verify item is deleted (should fail to retrieve)
-	_, err = retrieveFromKeychain(testItemName)
-	assert.Error(t, err, "Expected error when retrieving deleted item")
-}
-
-func TestKeychainInvalidItemName(t *testing.T) {
-	// Skip test if not on macOS
-	if runtime.GOOS != "darwin" {
-		t.Skip("Keychain tests only run on macOS")
-	}
-
-	testData := memguard.NewBufferFromBytes([]byte("test"))
-	defer testData.Destroy()
-
-	// Test an empty item name
-	err := storeInKeychain("", testData)
-	require.ErrorIs(t, err, errKeychainItemNameEmpty)
-
-	// Test invalid item names
-	invalidNames := []string{
-		"test space",        // Contains space
-		"test/slash",        // Contains slash
-		"test\\backslash",   // Contains backslash
-		"test:colon",        // Contains colon
-		"test;semicolon",    // Contains semicolon
-		"test|pipe",         // Contains pipe
-		"test@at",           // Contains @
-		"test#hash",         // Contains #
-		"test$dollar",       // Contains $
-		"test&ampersand",    // Contains &
-		"test*asterisk",     // Contains *
-		"test?question",     // Contains ?
-		"test!exclamation",  // Contains !
-		"test'quote",        // Contains single quote
-		"test\"doublequote", // Contains double quote
-		"test(paren",        // Contains parenthesis
-		"test[bracket",      // Contains bracket
-	}
-
-	for _, name := range invalidNames {
-		err := storeInKeychain(name, testData)
-		require.ErrorIs(t, err, errInvalidKeychainItemName,
-			"Expected error for invalid name: %s", name)
-	}
-
-	// Test valid names (should not error on validation)
-	validNames := []string{
-		"test-name",
-		"test_name",
-		"test.name",
-		"TestName123",
-		"TEST_NAME_123",
-		"com.example.test",
-		"secret-vault-hostname-2024-01-01",
-	}
-
-	for _, name := range validNames {
-		err := validateKeychainItemName(name)
-		assert.NoError(t, err, "Expected no error for valid name: %s", name)
-		// Clean up
-		_ = deleteFromKeychain(name)
-	}
-}
-
-func TestKeychainNilData(t *testing.T) {
-	// Skip test if not on macOS
-	if runtime.GOOS != "darwin" {
-		t.Skip("Keychain tests only run on macOS")
-	}
-
-	// Test storing nil data
-	err := storeInKeychain("test-item", nil)
-	assert.Error(t, err, "Expected error when storing nil data")
-	assert.Contains(t, err.Error(), "data buffer is nil")
-}
-
-func TestKeychainLargeData(t *testing.T) {
-	// Skip test if not on macOS
-	if runtime.GOOS != "darwin" {
-		t.Skip("Keychain tests only run on macOS")
-	}
-
-	// Test with larger hex-encoded data (512 bytes of binary data = 1KB hex)
-	largeData := make([]byte, 512)
-	for i := range largeData {
-		largeData[i] = byte(i % 256)
-	}
-
-	// Convert to hex string for storage
-	hexData := hex.EncodeToString(largeData)
-
-	testItemName := "test-large-data"
-	testBuffer := memguard.NewBufferFromBytes([]byte(hexData))
-	defer testBuffer.Destroy()
-
-	// Clean up first
-	_ = deleteFromKeychain(testItemName)
-
-	// Store hex data
-	err := storeInKeychain(testItemName, testBuffer)
-	require.NoError(t, err, "Failed to store large data")
-
-	// Retrieve and verify
-	retrievedData, err := retrieveFromKeychain(testItemName)
-	require.NoError(t, err, "Failed to retrieve large data")
-
-	// Decode hex and compare
-	decodedData, err := hex.DecodeString(string(retrievedData))
-	require.NoError(t, err, "Failed to decode hex data")
-	assert.Equal(t, largeData, decodedData, "Large data mismatch")
-
-	// Clean up
-	_ = deleteFromKeychain(testItemName)
-}
-
-func TestDeleteNonExistentKeychainItem(t *testing.T) {
-	// Skip test if not on macOS
-	if runtime.GOOS != "darwin" {
-		t.Skip("Keychain tests only run on macOS")
-	}
-
-	// Ensure item doesn't exist
-	testItemName := "test-nonexistent-keychain-item-12345"
-	_ = deleteFromKeychain(testItemName)
-
-	// Deleting a non-existent item should NOT return an error
-	// This is important for cleaning up unlocker directories when the keychain item
-	// has already been removed (e.g., manually by user, or on a different machine)
-	err := deleteFromKeychain(testItemName)
-	assert.NoError(t, err,
-		"Deleting non-existent keychain item should not return an error")
-}
-
-// TestWriteKeychainUnlockerFailureDeletesItem makes moving a new keychain
-// unlocker into place fail after its data is stored in the keychain: the
-// keychain item must be deleted again.
-func TestWriteKeychainUnlockerFailureDeletesItem(t *testing.T) {
-	testItemName := "test-secret-keychain-unlocker-cleanup"
-	_ = deleteFromKeychain(testItemName)
-
-	// Moving the unlocker into a read-only directory fails
-	unlockersDir := filepath.Join(t.TempDir(), "unlockers.d")
-	require.NoError(t, os.Mkdir(unlockersDir, 0o500))
-
-	testBuffer := memguard.NewBufferFromBytes([]byte("test-keychain-data"))
-	defer testBuffer.Destroy()
-
-	_, err := writeKeychainUnlocker(afero.NewOsFs(),
-		filepath.Join(unlockersDir, testItemName), testItemName, "age1test",
-		[]byte("test-priv"), []byte("test-longterm"), testBuffer)
-	require.ErrorIs(t, err, os.ErrPermission,
-		"moving the unlocker into place should fail")
-
-	_, err = retrieveFromKeychain(testItemName)
-	assert.Error(t, err, "keychain item left behind")
-}

internal/secret/metadata.go

@@ -17,7 +17,7 @@ type VaultMetadata struct {
 
 // UnlockerMetadata contains information about an unlocker
 type UnlockerMetadata struct {
-	Type      string    `json:"type"` // passphrase, pgp, keychain
+	Type      string    `json:"type"` // passphrase or pgp
 	CreatedAt time.Time `json:"createdAt"`
 	Flags     []string  `json:"flags,omitempty"`
 }

internal/secret/passphrase_test.go

@@ -7,10 +7,10 @@ import (
 	"time"
 
 	"filippo.io/age"
-	"git.eeqj.de/sneak/secret/internal/secret"
-	"git.eeqj.de/sneak/secret/pkg/agehd"
 	"github.com/awnumar/memguard"
 	"github.com/spf13/afero"
+	"sneak.berlin/go/secret/internal/secret"
+	"sneak.berlin/go/secret/pkg/agehd"
 )
 
 // testMnemonic is the standard BIP39 test vector mnemonic.

internal/secret/passphraseunlocker.go

@@ -11,9 +11,9 @@ import (
 	"github.com/spf13/afero"
 )
 
-// ErrPassphraseNotRead is wrapped in the error of a passphrase unlocker
-// that could not read its passphrase from the terminal, for example because
-// there is none. The unlocker itself was not tried.
+// ErrPassphraseNotRead is wrapped in every error of ReadPassphrase: there
+// is no terminal to read the passphrase from, reading it failed, or it was
+// empty. A passphrase unlocker that fails with it was not tried.
 var ErrPassphraseNotRead = errors.New("failed to read passphrase")
 
 // PassphraseUnlocker represents a passphrase-protected unlocker
@@ -128,7 +128,6 @@ func (p *PassphraseUnlocker) Remove() error {
 	}
 
 	// For passphrase unlockers, we just need to remove the directory
-	// No external resources (like keychain items) to clean up
 	err := RemoveDirAtomic(p.fs, p.Directory)
 	if err != nil {
 		return fmt.Errorf("failed to remove passphrase unlocker directory: %w", err)
@@ -155,7 +154,7 @@ func (p *PassphraseUnlocker) getPassphrase() (*memguard.LockedBuffer, error) {
 	if err != nil {
 		Debug("Failed to read passphrase", "error", err, "unlocker_id", p.GetID())
 
-		return nil, fmt.Errorf("%w: %w", ErrPassphraseNotRead, err)
+		return nil, err
 	}
 
 	return secureBuffer, nil

internal/secret/pgpunlock_test.go

@@ -17,11 +17,11 @@ import (
 	"time"
 
 	"filippo.io/age"
-	"git.eeqj.de/sneak/secret/internal/secret"
-	"git.eeqj.de/sneak/secret/internal/vault"
-	"git.eeqj.de/sneak/secret/pkg/agehd"
 	"github.com/awnumar/memguard"
 	"github.com/spf13/afero"
+	"sneak.berlin/go/secret/internal/secret"
+	"sneak.berlin/go/secret/internal/vault"
+	"sneak.berlin/go/secret/pkg/agehd"
 )
 
 // pgpUnlockerType is the type of a PGP unlocker.
@@ -317,8 +317,8 @@ func testCreatePGPUnlocker(
 	t.Helper()
 
 	// Set a limited test timeout to avoid hanging
-	timer := time.AfterFunc(30*time.Second, func() {
-		t.Fatalf("Test timed out after 30 seconds")
+	timer := time.AfterFunc(10*time.Second, func() {
+		t.Fatalf("Test timed out after 10 seconds")
 	})
 	defer timer.Stop()
 

internal/secret/pgpunlocker.go

@@ -18,6 +18,10 @@ import (
 	"github.com/spf13/afero"
 )
 
+// gpgNoPublicKeyStatus is the status line gpg writes when it has no key for
+// the ID it was asked to list: 9 is gpg's error code for "No public key".
+const gpgNoPublicKeyStatus = "[GNUPG:] ERROR keylist.getkey 9\n"
+
 var (
 	errGPGKeyIDEmpty    = errors.New("GPG key ID cannot be empty")
 	errInvalidGPGKeyID  = errors.New("invalid GPG key ID format")
@@ -25,6 +29,10 @@ var (
 	errNilDataBuffer    = errors.New("data buffer is nil")
 )
 
+// ErrGPGKeyNotFound is returned by ResolveGPGKeyFingerprint for a key ID
+// that matches no key in the GPG keyring.
+var ErrGPGKeyNotFound = errors.New("GPG key not found")
+
 // Variables to allow overriding in tests
 var (
 	// GPGEncryptFunc is the function used for GPG encryption
@@ -163,7 +171,6 @@ func (p *PGPUnlocker) GetID() string {
 // Remove implements Unlocker interface - removes the PGP unlocker
 func (p *PGPUnlocker) Remove() error {
 	// For PGP unlockers, we just need to remove the directory
-	// No external resources (like keychain items) to clean up
 	err := RemoveDirAtomic(p.fs, p.Directory)
 	if err != nil {
 		return fmt.Errorf("failed to remove PGP unlocker directory: %w", err)
@@ -367,14 +374,20 @@ func ResolveGPGKeyFingerprint(keyID string) (string, error) {
 		return "", fmt.Errorf("invalid GPG key ID: %w", err)
 	}
 
-	// Use GPG to get the full fingerprint for the key
+	// Use GPG to get the full fingerprint for the key. --status-fd 1 adds
+	// gpg's status lines to the output.
 	cmd := exec.CommandContext( //nolint:gosec // G204: keyID validated above
 		context.Background(),
-		"gpg", "--list-keys", "--with-colons", "--fingerprint", keyID,
+		"gpg", "--status-fd", "1",
+		"--list-keys", "--with-colons", "--fingerprint", keyID,
 	)
 
 	output, err := cmd.Output()
 	if err != nil {
+		if strings.Contains(string(output), gpgNoPublicKeyStatus) {
+			return "", fmt.Errorf("%w: %s", ErrGPGKeyNotFound, keyID)
+		}
+
 		return "", fmt.Errorf("failed to resolve GPG key fingerprint: %w", err)
 	}
 

internal/secret/pgpunlocker_test.go

@@ -5,12 +5,12 @@ import (
 	"path/filepath"
 	"testing"
 
-	"git.eeqj.de/sneak/secret/internal/secret"
-	"git.eeqj.de/sneak/secret/internal/vault"
 	"github.com/awnumar/memguard"
 	"github.com/spf13/afero"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/secret/internal/secret"
+	"sneak.berlin/go/secret/internal/vault"
 )
 
 // The GPG key ID and fingerprint passed to CreatePGPUnlocker.

internal/secret/secret_test.go

@@ -9,9 +9,9 @@ import (
 	"testing"
 
 	"filippo.io/age"
-	"git.eeqj.de/sneak/secret/pkg/agehd"
 	"github.com/awnumar/memguard"
 	"github.com/spf13/afero"
+	"sneak.berlin/go/secret/pkg/agehd"
 )
 
 // testMnemonicValue is the standard BIP39 test vector mnemonic.
@@ -25,6 +25,14 @@ var (
 	errNotImplementedInMock = errors.New("not implemented in mock")
 )
 
+// TestMain makes passphrase encryption in the tests cheap; see
+// ScryptWorkFactor.
+func TestMain(m *testing.M) {
+	ScryptWorkFactor = 1
+
+	os.Exit(m.Run())
+}
+
 // MockVault is a test implementation of the VaultInterface
 type MockVault struct {
 	name            string

internal/secret/seunlocker_darwin.go

@@ -1,402 +0,0 @@
-//go:build darwin
-
-package secret
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"log/slog"
-	"os"
-	"path/filepath"
-	"time"
-
-	"filippo.io/age"
-	"git.eeqj.de/sneak/secret/internal/macse"
-	"github.com/awnumar/memguard"
-	"github.com/spf13/afero"
-)
-
-const (
-	// seKeyLabelPrefix is the prefix for Secure Enclave CTK identity labels.
-	seKeyLabelPrefix = "berlin.sneak.app.secret.se"
-
-	// seUnlockerType is the metadata type string for Secure Enclave unlockers.
-	seUnlockerType = "secure-enclave"
-
-	// seLongtermFilename is the filename for the SE-encrypted vault long-term private key.
-	seLongtermFilename = "longterm.age.se"
-)
-
-// SecureEnclaveUnlockerMetadata extends UnlockerMetadata with SE-specific data.
-type SecureEnclaveUnlockerMetadata struct {
-	UnlockerMetadata
-
-	SEKeyLabel string `json:"seKeyLabel"`
-	SEKeyHash  string `json:"seKeyHash"`
-}
-
-// SecureEnclaveUnlocker represents a Secure Enclave-protected unlocker.
-type SecureEnclaveUnlocker struct {
-	Directory string
-	Metadata  UnlockerMetadata
-	fs        afero.Fs
-}
-
-// NewSecureEnclaveUnlocker creates a new SecureEnclaveUnlocker instance.
-func NewSecureEnclaveUnlocker(
-	fs afero.Fs,
-	directory string,
-	metadata UnlockerMetadata,
-) *SecureEnclaveUnlocker {
-	return &SecureEnclaveUnlocker{
-		Directory: directory,
-		Metadata:  metadata,
-		fs:        fs,
-	}
-}
-
-// GetIdentity implements Unlocker interface for SE-based unlockers.
-// Decrypts the vault's long-term private key directly using the Secure Enclave.
-func (s *SecureEnclaveUnlocker) GetIdentity() (*age.X25519Identity, error) {
-	DebugWith("Getting SE unlocker identity",
-		slog.String("unlocker_id", s.GetID()),
-	)
-
-	// Get SE key label from metadata
-	seKeyLabel, _, err := s.getSEKeyInfo()
-	if err != nil {
-		return nil, fmt.Errorf("failed to get SE key info: %w", err)
-	}
-
-	// Read ECIES-encrypted long-term private key from disk
-	encryptedPath := filepath.Join(s.Directory, seLongtermFilename)
-
-	encryptedData, err := afero.ReadFile(s.fs, encryptedPath)
-	if err != nil {
-		return nil, fmt.Errorf(
-			"failed to read SE-encrypted long-term key: %w",
-			err,
-		)
-	}
-
-	DebugWith("Read SE-encrypted long-term key",
-		slog.Int("encrypted_length", len(encryptedData)),
-	)
-
-	// Decrypt using the Secure Enclave (ECDH happens inside SE hardware)
-	decryptedData, err := macse.Decrypt(seKeyLabel, encryptedData)
-	if err != nil {
-		return nil, fmt.Errorf(
-			"failed to decrypt long-term key with SE: %w",
-			err,
-		)
-	}
-
-	// Parse the decrypted long-term private key
-	ltIdentity, err := age.ParseX25519Identity(string(decryptedData))
-
-	// Clear sensitive data immediately
-	for i := range decryptedData {
-		decryptedData[i] = 0
-	}
-
-	if err != nil {
-		return nil, fmt.Errorf(
-			"failed to parse long-term private key: %w",
-			err,
-		)
-	}
-
-	DebugWith("Successfully decrypted long-term key via SE",
-		slog.String("unlocker_id", s.GetID()),
-	)
-
-	return ltIdentity, nil
-}
-
-// GetType implements Unlocker interface.
-func (s *SecureEnclaveUnlocker) GetType() string {
-	return seUnlockerType
-}
-
-// GetMetadata implements Unlocker interface.
-func (s *SecureEnclaveUnlocker) GetMetadata() UnlockerMetadata {
-	return s.Metadata
-}
-
-// GetDirectory implements Unlocker interface.
-func (s *SecureEnclaveUnlocker) GetDirectory() string {
-	return s.Directory
-}
-
-// GetID implements Unlocker interface: the name of the unlocker's directory.
-func (s *SecureEnclaveUnlocker) GetID() string {
-	return filepath.Base(s.Directory)
-}
-
-// Remove implements Unlocker interface.
-func (s *SecureEnclaveUnlocker) Remove() error {
-	_, seKeyHash, err := s.getSEKeyInfo()
-	if err != nil {
-		Debug("Failed to get SE key info during removal", "error", err)
-
-		return fmt.Errorf("failed to get SE key info: %w", err)
-	}
-
-	if seKeyHash != "" {
-		Debug("Deleting SE key", "hash", seKeyHash)
-
-		err = macse.DeleteKey(seKeyHash)
-		if err != nil {
-			Debug("Failed to delete SE key", "error", err, "hash", seKeyHash)
-
-			return fmt.Errorf("failed to delete SE key: %w", err)
-		}
-	}
-
-	Debug("Removing SE unlocker directory", "directory", s.Directory)
-
-	err = RemoveDirAtomic(s.fs, s.Directory)
-	if err != nil {
-		return fmt.Errorf("failed to remove SE unlocker directory: %w", err)
-	}
-
-	Debug("Successfully removed SE unlocker", "unlocker_id", s.GetID())
-
-	return nil
-}
-
-// getSEKeyInfo reads the SE key label and hash from metadata.
-func (s *SecureEnclaveUnlocker) getSEKeyInfo() (string, string, error) {
-	metadataPath := filepath.Join(s.Directory, "unlocker-metadata.json")
-
-	metadataData, err := afero.ReadFile(s.fs, metadataPath)
-	if err != nil {
-		return "", "", fmt.Errorf("failed to read SE metadata: %w", err)
-	}
-
-	var seMetadata SecureEnclaveUnlockerMetadata
-
-	err = json.Unmarshal(metadataData, &seMetadata)
-	if err != nil {
-		return "", "", fmt.Errorf("failed to parse SE metadata: %w", err)
-	}
-
-	return seMetadata.SEKeyLabel, seMetadata.SEKeyHash, nil
-}
-
-// generateSEKeyLabel generates a unique label for the SE CTK identity.
-func generateSEKeyLabel(vaultName string) (string, error) {
-	hostname, err := os.Hostname()
-	if err != nil {
-		return "", fmt.Errorf("failed to get hostname: %w", err)
-	}
-
-	enrollmentTime := time.Now().UTC().Format(UnlockerTimeFormat)
-
-	return fmt.Sprintf(
-		"%s.%s-%s-%s",
-		seKeyLabelPrefix,
-		vaultName,
-		hostname,
-		enrollmentTime,
-	), nil
-}
-
-// CreateSecureEnclaveUnlocker creates a new SE unlocker.
-// The vault's long-term private key is encrypted directly by the Secure Enclave
-// using ECIES. No intermediate age keypair is used.
-// The long-term key comes from mnemonic when it is not nil, else from the
-// current unlocker, as getLongTermKeyForSE describes.
-// The SE key is created once the long-term key is in hand and the unlocker's
-// path is known, and is deleted again if a later step fails.
-func CreateSecureEnclaveUnlocker(
-	fs afero.Fs,
-	stateDir string,
-	mnemonic, passphrase *memguard.LockedBuffer,
-) (*SecureEnclaveUnlocker, error) {
-	err := checkMacOSAvailable()
-	if err != nil {
-		return nil, err
-	}
-
-	vault, err := GetCurrentVault(fs, stateDir)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get current vault: %w", err)
-	}
-
-	// Generate SE key label
-	seKeyLabel, err := generateSEKeyLabel(vault.GetName())
-	if err != nil {
-		return nil, fmt.Errorf("failed to generate SE key label: %w", err)
-	}
-
-	// Step 1: Get the vault's long-term private key
-	ltPrivKeyData, err := getLongTermKeyForSE(fs, vault, mnemonic, passphrase)
-	if err != nil {
-		return nil, fmt.Errorf(
-			"failed to get long-term private key: %w",
-			err,
-		)
-	}
-	defer ltPrivKeyData.Destroy()
-
-	// Step 2: Prepare the unlocker directory's path
-	vaultDir, err := vault.GetDirectory()
-	if err != nil {
-		return nil, fmt.Errorf("failed to get vault directory: %w", err)
-	}
-
-	unlockerDirName := "se-" + filepath.Base(seKeyLabel)
-	unlockerDir := filepath.Join(vaultDir, "unlockers.d", unlockerDirName)
-
-	// Step 3: Create P-256 key in the Secure Enclave via sc_auth
-	Debug("Creating Secure Enclave key", "label", seKeyLabel)
-
-	_, seKeyHash, err := macse.CreateKey(seKeyLabel)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create SE key: %w", err)
-	}
-
-	Debug("Created SE key", "label", seKeyLabel, "hash", seKeyHash)
-
-	// Steps 4 and 5: Write the unlocker, or delete the SE key if that fails
-	unlocker, err := writeSEUnlocker(fs, unlockerDir, seKeyLabel, seKeyHash,
-		ltPrivKeyData)
-	if err != nil {
-		deleteErr := macse.DeleteKey(seKeyHash)
-		if deleteErr != nil {
-			err = errors.Join(err, fmt.Errorf(
-				"failed to delete SE key %s: %w", seKeyLabel, deleteErr))
-		}
-
-		return nil, err
-	}
-
-	return unlocker, nil
-}
-
-// writeSEUnlocker encrypts the long-term key with the SE key and writes the
-// new unlocker into unlockerDir (steps 4 and 5 of
-// CreateSecureEnclaveUnlocker).
-func writeSEUnlocker(
-	fs afero.Fs, unlockerDir, seKeyLabel, seKeyHash string,
-	ltPrivKeyData *memguard.LockedBuffer,
-) (*SecureEnclaveUnlocker, error) {
-	// Step 4: Encrypt the long-term key directly with the SE (ECIES), and
-	// prepare the metadata
-	encryptedLtKey, err := macse.Encrypt(seKeyLabel, ltPrivKeyData.Bytes())
-	if err != nil {
-		return nil, fmt.Errorf(
-			"failed to encrypt long-term key with SE: %w",
-			err,
-		)
-	}
-
-	seMetadata := SecureEnclaveUnlockerMetadata{
-		UnlockerMetadata: UnlockerMetadata{
-			Type:      seUnlockerType,
-			CreatedAt: time.Now().UTC(),
-			Flags:     []string{seUnlockerType, macOSFlag},
-		},
-		SEKeyLabel: seKeyLabel,
-		SEKeyHash:  seKeyHash,
-	}
-
-	metadataBytes, err := json.MarshalIndent(seMetadata, "", "  ")
-	if err != nil {
-		return nil, fmt.Errorf("failed to marshal metadata: %w", err)
-	}
-
-	// Step 5: Write the SE-encrypted long-term key, then the metadata
-	err = WriteDir(fs, unlockerDir, func(dir string) error {
-		return writeSEUnlockerFiles(fs, dir, encryptedLtKey, metadataBytes)
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return &SecureEnclaveUnlocker{
-		Directory: unlockerDir,
-		Metadata:  seMetadata.UnlockerMetadata,
-		fs:        fs,
-	}, nil
-}
-
-// writeSEUnlockerFiles writes the files of a new SE unlocker into dir: the
-// SE-encrypted long-term key, then the metadata.
-func writeSEUnlockerFiles(
-	fs afero.Fs, dir string, encryptedLtKey, metadataBytes []byte,
-) error {
-	err := WriteFileAtomic(fs, filepath.Join(dir, seLongtermFilename),
-		encryptedLtKey)
-	if err != nil {
-		return fmt.Errorf(
-			"failed to write SE-encrypted long-term key: %w",
-			err,
-		)
-	}
-
-	err = WriteFileAtomic(fs,
-		filepath.Join(dir, "unlocker-metadata.json"), metadataBytes)
-	if err != nil {
-		return fmt.Errorf("failed to write metadata: %w", err)
-	}
-
-	return nil
-}
-
-// getLongTermKeyForSE retrieves the vault's long-term private key, derived
-// from mnemonic when it is not nil, else through the current unlocker, which
-// is given passphrase when it is a passphrase unlocker.
-func getLongTermKeyForSE(
-	fs afero.Fs,
-	vault VaultInterface,
-	mnemonic, passphrase *memguard.LockedBuffer,
-) (*memguard.LockedBuffer, error) {
-	if mnemonic != nil {
-		return deriveLongTermPrivateKey(fs, vault, mnemonic)
-	}
-
-	currentUnlocker, err := vault.GetCurrentUnlocker()
-	if err != nil {
-		return nil, fmt.Errorf("failed to get current unlocker: %w", err)
-	}
-
-	if passphraseUnlocker, ok := currentUnlocker.(*PassphraseUnlocker); ok {
-		passphraseUnlocker.Passphrase = passphrase
-	}
-
-	currentIdentity, err := currentUnlocker.GetIdentity()
-	if err != nil {
-		return nil, fmt.Errorf(
-			"failed to get current unlocker identity: %w",
-			err,
-		)
-	}
-
-	// All unlocker types store longterm.age in their directory
-	longtermPath := filepath.Join(
-		currentUnlocker.GetDirectory(),
-		"longterm.age",
-	)
-
-	encryptedLtKey, err := afero.ReadFile(fs, longtermPath)
-	if err != nil {
-		return nil, fmt.Errorf(
-			"failed to read encrypted long-term key: %w",
-			err,
-		)
-	}
-
-	ltPrivKeyBuffer, err := DecryptWithIdentity(
-		encryptedLtKey,
-		currentIdentity,
-	)
-	if err != nil {
-		return nil, fmt.Errorf("failed to decrypt long-term key: %w", err)
-	}
-
-	return ltPrivKeyBuffer, nil
-}

internal/secret/seunlocker_stub.go

@@ -1,88 +0,0 @@
-//go:build !darwin
-
-package secret
-
-import (
-	"errors"
-	"path/filepath"
-
-	"filippo.io/age"
-	"github.com/awnumar/memguard"
-	"github.com/spf13/afero"
-)
-
-// seUnlockerType is the type string for Secure Enclave unlockers.
-const seUnlockerType = "secure-enclave"
-
-var errSENotSupported = errors.New(
-	"secure enclave unlockers are only supported on macOS",
-)
-
-// SecureEnclaveUnlockerMetadata is a stub for non-Darwin platforms.
-type SecureEnclaveUnlockerMetadata struct {
-	UnlockerMetadata
-
-	SEKeyLabel string `json:"seKeyLabel"`
-	SEKeyHash  string `json:"seKeyHash"`
-}
-
-// SecureEnclaveUnlocker is a stub for non-Darwin platforms.
-type SecureEnclaveUnlocker struct {
-	Directory string
-	Metadata  UnlockerMetadata
-	fs        afero.Fs
-}
-
-// NewSecureEnclaveUnlocker creates a stub SecureEnclaveUnlocker on
-// non-Darwin platforms. The returned instance's methods that require
-// macOS functionality will return errors.
-func NewSecureEnclaveUnlocker(
-	fs afero.Fs,
-	directory string,
-	metadata UnlockerMetadata,
-) *SecureEnclaveUnlocker {
-	return &SecureEnclaveUnlocker{
-		Directory: directory,
-		Metadata:  metadata,
-		fs:        fs,
-	}
-}
-
-// GetIdentity returns an error on non-Darwin platforms.
-func (s *SecureEnclaveUnlocker) GetIdentity() (*age.X25519Identity, error) {
-	return nil, errSENotSupported
-}
-
-// GetType returns the unlocker type.
-func (s *SecureEnclaveUnlocker) GetType() string {
-	return seUnlockerType
-}
-
-// GetMetadata returns the unlocker metadata.
-func (s *SecureEnclaveUnlocker) GetMetadata() UnlockerMetadata {
-	return s.Metadata
-}
-
-// GetDirectory returns the unlocker directory.
-func (s *SecureEnclaveUnlocker) GetDirectory() string {
-	return s.Directory
-}
-
-// GetID returns the unlocker ID, the name of the unlocker's directory.
-func (s *SecureEnclaveUnlocker) GetID() string {
-	return filepath.Base(s.Directory)
-}
-
-// Remove returns an error on non-Darwin platforms.
-func (s *SecureEnclaveUnlocker) Remove() error {
-	return errSENotSupported
-}
-
-// CreateSecureEnclaveUnlocker returns an error on non-Darwin platforms.
-func CreateSecureEnclaveUnlocker(
-	_ afero.Fs,
-	_ string,
-	_, _ *memguard.LockedBuffer,
-) (*SecureEnclaveUnlocker, error) {
-	return nil, errSENotSupported
-}

internal/secret/seunlocker_stub_test.go

@@ -1,99 +0,0 @@
-//go:build !darwin
-
-//nolint:testpackage // white-box test asserting unexported sentinel errors
-package secret
-
-import (
-	"testing"
-	"time"
-
-	"github.com/spf13/afero"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestNewSecureEnclaveUnlocker(t *testing.T) {
-	t.Parallel()
-
-	fs := afero.NewMemMapFs()
-	dir := "/tmp/test-se-unlocker"
-	metadata := UnlockerMetadata{
-		Type:      seUnlockerType,
-		CreatedAt: time.Date(2026, 1, 15, 10, 30, 0, 0, time.UTC),
-		Flags:     []string{seUnlockerType, "macos"},
-	}
-
-	unlocker := NewSecureEnclaveUnlocker(fs, dir, metadata)
-	require.NotNil(t, unlocker, "NewSecureEnclaveUnlocker should return a valid instance")
-
-	// Test GetType returns correct type
-	assert.Equal(t, seUnlockerType, unlocker.GetType())
-
-	// Test GetMetadata returns the metadata we passed in
-	assert.Equal(t, metadata, unlocker.GetMetadata())
-
-	// Test GetDirectory returns the directory we passed in
-	assert.Equal(t, dir, unlocker.GetDirectory())
-
-	// Test GetID returns the name of the unlocker's directory
-	assert.Equal(t, "test-se-unlocker", unlocker.GetID())
-}
-
-func TestSecureEnclaveUnlockerGetIdentityReturnsError(t *testing.T) {
-	t.Parallel()
-
-	fs := afero.NewMemMapFs()
-	metadata := UnlockerMetadata{
-		Type:      seUnlockerType,
-		CreatedAt: time.Now().UTC(),
-	}
-
-	unlocker := NewSecureEnclaveUnlocker(fs, "/tmp/test", metadata)
-
-	identity, err := unlocker.GetIdentity()
-	assert.Nil(t, identity)
-	require.Error(t, err)
-	require.ErrorIs(t, err, errSENotSupported)
-}
-
-func TestSecureEnclaveUnlockerRemoveReturnsError(t *testing.T) {
-	t.Parallel()
-
-	fs := afero.NewMemMapFs()
-	metadata := UnlockerMetadata{
-		Type:      seUnlockerType,
-		CreatedAt: time.Now().UTC(),
-	}
-
-	unlocker := NewSecureEnclaveUnlocker(fs, "/tmp/test", metadata)
-
-	err := unlocker.Remove()
-	require.Error(t, err)
-	require.ErrorIs(t, err, errSENotSupported)
-}
-
-func TestCreateSecureEnclaveUnlockerReturnsError(t *testing.T) {
-	t.Parallel()
-
-	fs := afero.NewMemMapFs()
-
-	unlocker, err := CreateSecureEnclaveUnlocker(fs, "/tmp/test", nil, nil)
-	assert.Nil(t, unlocker)
-	require.Error(t, err)
-	require.ErrorIs(t, err, errSENotSupported)
-}
-
-func TestSecureEnclaveUnlockerImplementsInterface(t *testing.T) {
-	t.Parallel()
-
-	fs := afero.NewMemMapFs()
-	metadata := UnlockerMetadata{
-		Type:      seUnlockerType,
-		CreatedAt: time.Now().UTC(),
-	}
-
-	unlocker := NewSecureEnclaveUnlocker(fs, "/tmp/test", metadata)
-
-	// Verify the stub implements the Unlocker interface
-	var _ Unlocker = unlocker
-}

internal/secret/seunlocker_test.go

@@ -1,117 +0,0 @@
-//go:build darwin
-
-//nolint:testpackage // white-box test of unexported Secure Enclave helpers
-package secret
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-	"time"
-
-	"github.com/spf13/afero"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestNewSecureEnclaveUnlocker(t *testing.T) {
-	t.Parallel()
-
-	fs := afero.NewMemMapFs()
-	dir := "/tmp/test-se-unlocker"
-	metadata := UnlockerMetadata{
-		Type:      seUnlockerType,
-		CreatedAt: time.Date(2026, 1, 15, 10, 30, 0, 0, time.UTC),
-		Flags:     []string{seUnlockerType, "macos"},
-	}
-
-	unlocker := NewSecureEnclaveUnlocker(fs, dir, metadata)
-	require.NotNil(t, unlocker, "NewSecureEnclaveUnlocker should return a valid instance")
-
-	// Test GetType returns correct type
-	assert.Equal(t, seUnlockerType, unlocker.GetType())
-
-	// Test GetMetadata returns the metadata we passed in
-	assert.Equal(t, metadata, unlocker.GetMetadata())
-
-	// Test GetDirectory returns the directory we passed in
-	assert.Equal(t, dir, unlocker.GetDirectory())
-}
-
-func TestSecureEnclaveUnlockerImplementsInterface(t *testing.T) {
-	t.Parallel()
-
-	fs := afero.NewMemMapFs()
-	metadata := UnlockerMetadata{
-		Type:      seUnlockerType,
-		CreatedAt: time.Now().UTC(),
-	}
-
-	unlocker := NewSecureEnclaveUnlocker(fs, "/tmp/test", metadata)
-
-	// Verify the darwin implementation implements the Unlocker interface
-	var _ Unlocker = unlocker
-}
-
-func TestSecureEnclaveUnlockerGetIDFormat(t *testing.T) {
-	t.Parallel()
-
-	fs := afero.NewMemMapFs()
-	metadata := UnlockerMetadata{
-		Type:      seUnlockerType,
-		CreatedAt: time.Date(2026, 3, 10, 14, 30, 0, 0, time.UTC),
-	}
-
-	unlocker := NewSecureEnclaveUnlocker(fs, "/tmp/test", metadata)
-
-	// The ID is the name of the unlocker's directory
-	assert.Equal(t, "test", unlocker.GetID())
-}
-
-func TestGenerateSEKeyLabel(t *testing.T) {
-	t.Parallel()
-
-	label, err := generateSEKeyLabel("test-vault")
-	require.NoError(t, err)
-
-	// Label should contain the prefix and vault name
-	assert.Contains(t, label, seKeyLabelPrefix)
-	assert.Contains(t, label, "test-vault")
-}
-
-func TestSecureEnclaveUnlockerGetIdentityMissingFile(t *testing.T) {
-	t.Parallel()
-
-	fs := afero.NewMemMapFs()
-	dir := "/tmp/test-se-unlocker-missing"
-
-	// Create unlocker directory with metadata but no encrypted key file
-	require.NoError(t, fs.MkdirAll(dir, DirPerms))
-
-	metadataJSON := `{
-		"type": "secure-enclave",
-		"createdAt": "2026-01-15T10:30:00Z",
-		"seKeyLabel": "berlin.sneak.app.secret.se.test",
-		"seKeyHash": "abc123"
-	}`
-	require.NoError(t, afero.WriteFile(
-		fs, dir+"/unlocker-metadata.json", []byte(metadataJSON), FilePerms,
-	))
-
-	metadata := UnlockerMetadata{
-		Type:      seUnlockerType,
-		CreatedAt: time.Date(2026, 1, 15, 10, 30, 0, 0, time.UTC),
-	}
-
-	unlocker := NewSecureEnclaveUnlocker(fs, dir, metadata)
-
-	// GetIdentity should fail because the encrypted longterm key file is missing
-	identity, err := unlocker.GetIdentity()
-	assert.Nil(t, identity)
-
-	var cause *os.PathError
-
-	require.ErrorAs(t, err, &cause)
-	require.ErrorIs(t, err, os.ErrNotExist)
-	assert.Equal(t, filepath.Join(dir, seLongtermFilename), cause.Path)
-}

internal/secret/validation_darwin_test.go

@@ -1,57 +0,0 @@
-//go:build darwin
-
-//nolint:testpackage // white-box test of unexported validateKeychainItemName
-package secret
-
-import (
-	"testing"
-)
-
-func TestValidateKeychainItemName(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name     string
-		itemName string
-		wantErr  bool
-	}{
-		// Valid cases
-		{name: "valid simple name", itemName: "my-secret-key", wantErr: false},
-		{name: "valid name with dots", itemName: "com.example.app.key", wantErr: false},
-		{name: "valid name with underscores", itemName: "my_secret_key_123", wantErr: false},
-		{name: "valid alphanumeric", itemName: "Secret123Key", wantErr: false},
-		{name: "valid with hyphen at start", itemName: "-my-key", wantErr: false},
-		{name: "valid with dot at start", itemName: ".hidden-key", wantErr: false},
-
-		// Invalid cases
-		{name: "empty item name", itemName: "", wantErr: true},
-		{name: "item name with spaces", itemName: "my secret key", wantErr: true},
-		{name: "item name with semicolon", itemName: "key;rm -rf /", wantErr: true},
-		{name: "item name with pipe", itemName: "key|cat /etc/passwd", wantErr: true},
-		{name: "item name with backticks", itemName: "key`whoami`", wantErr: true},
-		{name: "item name with dollar sign", itemName: "key$(whoami)", wantErr: true},
-		{name: "item name with quotes", itemName: "key\"name", wantErr: true},
-		{name: "item name with single quotes", itemName: "key'name", wantErr: true},
-		{name: "item name with backslash", itemName: "key\\name", wantErr: true},
-		{name: "item name with newline", itemName: "key\nname", wantErr: true},
-		{name: "item name with carriage return", itemName: "key\rname", wantErr: true},
-		{name: "item name with ampersand", itemName: "key&echo test", wantErr: true},
-		{name: "item name with redirect", itemName: "key>/tmp/test", wantErr: true},
-		{name: "item name with null byte", itemName: "key\x00name", wantErr: true},
-		{name: "item name with parentheses", itemName: "key(test)", wantErr: true},
-		{name: "item name with brackets", itemName: "key[test]", wantErr: true},
-		{name: "item name with asterisk", itemName: "key*", wantErr: true},
-		{name: "item name with question mark", itemName: "key?", wantErr: true},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			err := validateKeychainItemName(tt.itemName)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("validateKeychainItemName() error = %v, wantErr %v", err, tt.wantErr)
-			}
-		})
-	}
-}

internal/secret/version.go

@@ -22,10 +22,10 @@ const (
 	maxVersionsPerDay = 999
 )
 
-var (
-	errMaxVersionsPerDay = errors.New("exceeded maximum versions per day (999)")
-	errNilValueBuffer    = errors.New("value buffer is nil")
-)
+var errMaxVersionsPerDay = errors.New("exceeded maximum versions per day (999)")
+
+// ErrNilValueBuffer is returned when a secret's value is given as nil.
+var ErrNilValueBuffer = errors.New("value buffer is nil")
 
 // VersionMetadata contains information about a secret version
 type VersionMetadata struct {
@@ -138,7 +138,7 @@ func GenerateVersionName(fs afero.Fs, secretDir string) (string, error) {
 // process dies part-way.
 func (sv *Version) Save(value *memguard.LockedBuffer) error {
 	if value == nil {
-		return errNilValueBuffer
+		return ErrNilValueBuffer
 	}
 
 	DebugWith("Saving secret version",

internal/secret/version_test.go

@@ -41,11 +41,11 @@ import (
 	"time"
 
 	"filippo.io/age"
-	"git.eeqj.de/sneak/secret/internal/secret"
 	"github.com/awnumar/memguard"
 	"github.com/spf13/afero"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/secret/internal/secret"
 )
 
 const (

internal/vault/errors.go

@@ -36,9 +36,6 @@ var (
 	// it unlocks. Composed as "vault <name> needs a mnemonic for an unlocker".
 	ErrUnlockerWithoutMnemonic = errors.New("needs a mnemonic for an unlocker")
 
-	// ErrNilValueBuffer indicates a nil value buffer was supplied.
-	ErrNilValueBuffer = errors.New("value buffer is nil")
-
 	// ErrInvalidSecretName indicates a secret name that breaks the naming
 	// rule: only ASCII letters, digits, '.', '-', '_' and '/'; not empty;
 	// no leading '.' or '/', no trailing '/', no '//', no '..' path segment.

internal/vault/errors_test.go

@@ -4,11 +4,11 @@ import (
 	"path/filepath"
 	"testing"
 
-	"git.eeqj.de/sneak/secret/internal/secret"
-	"git.eeqj.de/sneak/secret/internal/vault"
 	"github.com/awnumar/memguard"
 	"github.com/spf13/afero"
 	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/secret/internal/secret"
+	"sneak.berlin/go/secret/internal/vault"
 )
 
 const (
@@ -60,7 +60,7 @@ func TestVaultErrors(t *testing.T) {
 		}, vault.ErrVaultNotFound},
 		{"add a nil value", func(vlt *vault.Vault) error {
 			return vlt.AddSecret(missingName, nil, false)
-		}, vault.ErrNilValueBuffer},
+		}, secret.ErrNilValueBuffer},
 		{"get a missing secret", func(vlt *vault.Vault) error {
 			_, err := vlt.GetSecret(missingName)
 

internal/vault/integration_test.go

@@ -9,10 +9,10 @@ import (
 	"testing"
 
 	"filippo.io/age"
-	"git.eeqj.de/sneak/secret/internal/vault"
-	"git.eeqj.de/sneak/secret/pkg/agehd"
 	"github.com/awnumar/memguard"
 	"github.com/spf13/afero"
+	"sneak.berlin/go/secret/internal/vault"
+	"sneak.berlin/go/secret/pkg/agehd"
 )
 
 // deriveVaultIdentity derives the long-term identity for the given vault

internal/vault/integration_version_test.go

@@ -30,12 +30,12 @@ import (
 	"time"
 
 	"filippo.io/age"
-	"git.eeqj.de/sneak/secret/internal/secret"
-	"git.eeqj.de/sneak/secret/pkg/agehd"
 	"github.com/awnumar/memguard"
 	"github.com/spf13/afero"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/secret/internal/secret"
+	"sneak.berlin/go/secret/pkg/agehd"
 )
 
 // errUnexpectedValue is returned by concurrent readers when a secret value

internal/vault/lock.go

@@ -8,8 +8,8 @@ import (
 	"sync"
 	"syscall"
 
-	"git.eeqj.de/sneak/secret/internal/secret"
 	"github.com/spf13/afero"
+	"sneak.berlin/go/secret/internal/secret"
 )
 
 // lockFileName is the file in the state directory that LockStateDir locks.

internal/vault/lock_test.go

@@ -5,11 +5,11 @@ import (
 	"testing"
 	"time"
 
-	"git.eeqj.de/sneak/secret/internal/secret"
-	"git.eeqj.de/sneak/secret/internal/vault"
 	"github.com/spf13/afero"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/secret/internal/secret"
+	"sneak.berlin/go/secret/internal/vault"
 )
 
 const (

internal/vault/management.go

@@ -9,10 +9,10 @@ import (
 	"time"
 
 	"filippo.io/age"
-	"git.eeqj.de/sneak/secret/internal/secret"
-	"git.eeqj.de/sneak/secret/pkg/agehd"
 	"github.com/awnumar/memguard"
 	"github.com/spf13/afero"
+	"sneak.berlin/go/secret/internal/secret"
+	"sneak.berlin/go/secret/pkg/agehd"
 )
 
 // Register the GetCurrentVault function with the secret package

internal/vault/metadata.go

@@ -7,9 +7,9 @@ import (
 	"fmt"
 	"path/filepath"
 
-	"git.eeqj.de/sneak/secret/internal/secret"
-	"git.eeqj.de/sneak/secret/pkg/agehd"
 	"github.com/spf13/afero"
+	"sneak.berlin/go/secret/internal/secret"
+	"sneak.berlin/go/secret/pkg/agehd"
 )
 
 // Metadata is an alias for secret.VaultMetadata

internal/vault/metadata_test.go

@@ -5,9 +5,9 @@ import (
 	"strings"
 	"testing"
 
-	"git.eeqj.de/sneak/secret/internal/vault"
-	"git.eeqj.de/sneak/secret/pkg/agehd"
 	"github.com/spf13/afero"
+	"sneak.berlin/go/secret/internal/vault"
+	"sneak.berlin/go/secret/pkg/agehd"
 )
 
 //nolint:paralleltest // subtests share an in-memory filesystem sequentially

internal/vault/path_traversal_test.go

@@ -3,10 +3,10 @@ package vault_test
 import (
 	"testing"
 
-	"git.eeqj.de/sneak/secret/internal/vault"
 	"github.com/awnumar/memguard"
 	"github.com/spf13/afero"
 	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/secret/internal/vault"
 )
 
 // TestGetSecretVersionRejectsPathTraversal verifies that GetSecretVersion