MCP server de keysmith
Commit 15 nov 2026Proporciona a los agentes de IA un sistema seguro de gestión de secretos mediante el uso de cifrado age, vistas enmascaradas y redención de tokens local para evitar la filtración de credenciales.
También conocido como sscodeai/keysmith
- Stars
- 0
- Herramientas
- 5
- Descargas, 30 días
- —
- Última versión
- —
- Último commit
- 15 nov 2026
- Licencia
- Apache-2.0
¿Qué es keysmith MCP?
Proporciona a los agentes de IA un sistema seguro de gestión de secretos mediante el uso de cifrado age, vistas enmascaradas y redención de tokens local para evitar la filtración de credenciales. Expone 5 herramientas, como list, get, put.
Resumen generado a partir del README del proyecto
Acerca del MCP server de keysmith
keysmith permite asegurar las credenciales sensibles de los agentes de IA evitando que los secretos en texto plano entren en el contexto o en el historial de la sesión de un agente. Ofrece un modelo de seguridad por capas que utiliza el cifrado age para proteger los datos en reposo y vistas enmascaradas para garantizar que las herramientas y recursos solo devuelvan cadenas parciales no sensibles, como sk******ij. Este enfoque permite a los desarrolladores gestionar claves de API, URLs de bases de datos y tokens sin el riesgo de filtraciones permanentes en las solicitudes al modelo o en los logs.
Los usuarios pueden desplegar el MCP server vía stdio para clientes locales como Claude Code o Cursor, o utilizar HTTP/SSE para agentes remotos. Es compatible con HashiCorp Vault como backend para gestionar credenciales dinámicas con TTL corto. Una capa de redención única permite que un agente utilice un token que no es un secreto, el cual keysmith sustituye localmente en el entorno de un comando, asegurando que el valor real nunca aparezca en las listas de argumentos o transcripciones. El sistema también incluye un comando scan para detectar y rotar secretos filtrados automáticamente.
Qué puedes hacer con él
- 1Prevención de filtraciones de credenciales en transcripcionesUn agente puede almacenar un nuevo secreto leyéndolo desde un archivo de bandeja de entrada específico en lugar de recibir el texto plano en una llamada a una herramienta.
- 2Ejecución de comandos con variables de entorno segurasUn desarrollador puede instruir a una IA para ejecutar un comando curl utilizando un token de marcador de posición que se resuelve en el secreto real solo dentro del proceso hijo.
- 3Automatización de la rotación de secretos tras filtracionesPuedes configurar una tarea programada para escanear repositorios en busca de credenciales expuestas y reemplazarlas automáticamente.
- 4Restricción del uso de tokens a destinos específicosPuedes emitir tokens que estén estrictamente vinculados a un host o ruta específica para evitar que se utilicen contra endpoints no autorizados.
Escrito a partir del README del proyecto. Cada caso de uso se verifica con una cita del mismo.
Herramientas de keysmith MCP 5
Detectado desde el READMElistgetputrotatedelete
| list | — | |
| get | — | |
| put | — | |
| rotate | — | |
| delete | — |
Configuración
KEYSMITH_STOREVAULT_TOKEN
| Nombre | Descripción | Tipo |
|---|---|---|
| KEYSMITH_STORE | — | |
| VAULT_TOKEN | — |
Verificaciones automáticas
Ejecutado 14 nov 2026Informe completo →Aún no verificado. Un servidor necesita una puntuación de 80, ningún hallazgo grave y suficientes datos para que podamos revisarlo. Cómo funcionan las verificaciones · Qué corregir para obtener más puntos
- Repositorio de origen vinculado y accesiblesscodeai/keysmith is public and reachablegithub.com/sscodeai/keysmith ↗Aprobado
- El paquete indica este repositorio como su origenNo verificado
- Procedencia de la compilación (atestación de Sigstore)No verificado
- Licencia de código abierto (OSI)Apache-2.0spdx.org/licenses/Apache-2.0.html ↗Aprobado
- Commit o lanzamiento en el último añoLast commit or release 2026-11-14github.com/sscodeai/keysmith ↗Aprobado
- OpenSSF ScorecardNo verificado
- El nombre del paquete no es similar a un paquete popularNo verificado
- No hay avisos críticos en el paquete ni en sus dependenciasNo verificado
- Sin instrucciones ocultas para el modelo5 tool descriptions and the README read; no override phrases, credential paths or hidden charactersAprobado
- Las herramientas destructivas están etiquetadasNo verificado
- El endpoint remoto responde al handshake de MCPNo verificado
README
Ver en GitHubkeysmith 🔑
日本語 ·
The key-smith for AI agents — forge, guard, and rotate secrets so plaintext never enters the agent's context.
Keysmith is an MCP server + CLI for AI-agent-safe secret management. It treats masking as the last line of defense and works structurally to keep secrets from leaking: encrypted residency, masked views, handle-passing, self-healing rotation, and short-TTL dynamic credentials.
Masking alone leaves a gap: a masked value cannot be used. The redemption layer closes it — the agent handles a non-secret token, and keysmith substitutes the real value on this machine, into the environment of a command it starts. The value is never in a model request, a tool result, a transcript, or an argument list. See docs/REDEEM.md and docs/THREAT-MODEL.md.
Built with Go. Single static binary, zero runtime dependencies.
Why
AI agents increasingly need credentials (API keys, tokens, DB URLs) to do
their work. But every time an agent reads a .env file, the plaintext leaks
into its context, logs, and session history — permanently.
Keysmith fixes this with a layered security model:
| Layer | Mechanism | What it prevents |
|---|---|---|
| Encrypted residency | age (X25519) encrypted store at rest | Plaintext on disk; even a leaked context is harmless (blobs are ciphertext) |
| Masked views | resources/tools return sk******ij form |
Credentials entering agent context |
| Handle-passing | put reads the value from a file in the store inbox, not from the transcript |
Plaintext in tool-call transcripts |
| Self-healing rotation | scan --rotate detects leaks, kills the leaked value |
Stale leaked credentials keep working |
| Short-TTL (Vault) | dynamic DB creds expire in 1h | Leaked credentials become worthless |
| Redemption | keysmith run substitutes a token locally, into the child's environment |
An agent that must use a credential being tempted to print it; plaintext in argv, transcripts, or logs |
| Target binding | --allow-host / --allow-path / --allow-header at issue time, checked against run --target |
A token being redeemed into a command aimed at an attacker's endpoint |
Install
go install github.com/sscodeai/keysmith/cmd/keysmith@latest
# or build from source
go build -o bin/keysmith ./cmd/keysmith
Usage
Run the server on stdio transport (the standard MCP server mode):
keysmith -store ~/.keysmith
# or via env:
KEYSMITH_STORE=/path/to/store keysmith
Serve over HTTP/SSE for remote agents:
keysmith -store ~/.keysmith -http 127.0.0.1:8080
# endpoint: http://localhost:8080/sse
Serve MCP 2025 Streamable HTTP (single POST endpoint, stateless):
keysmith -store ~/.keysmith -http 127.0.0.1:8080 -streamable
# endpoint: http://localhost:8080/mcp
An HTTP listener has no authentication of its own, so keysmith refuses to bind
a non-loopback address unless -http-token is set. With a token, every request
must carry Authorization: Bearer <token>:
keysmith -store ~/.keysmith -http 192.168.1.10:8080 -http-token "$(openssl rand -hex 16)" -streamable
Use HashiCorp Vault as the backend (dynamic short-TTL secrets):
export VAULT_TOKEN=<token>
keysmith -store ~/.keysmith -vault http://127.0.0.1:8200
Configure it in your MCP client (Claude Code, Cursor, etc.):
{
"mcpServers": {
"keysmith": {
"command": "keysmith",
"args": ["-store", "~/.keysmith"]
}
}
}
The store directory is created on first run with 0600 permissions, holding:
key.txt— your age private key (NEVER share; keep0600)secrets.enc— armored age-encrypted secrets blob
CLI
In addition to the MCP server, keysmith works as a standalone CLI sharing the same store:
keysmith list # all keys, masked values
keysmith get API_KEY # masked value
keysmith get API_KEY --unsafe # plaintext (last resort)
keysmith set API_KEY < value.txt # value from stdin, no shell-history leak
keysmith rotate API_KEY 32 # generate + store new strong secret
keysmith delete API_KEY # remove a key
keysmith scan [--rotate] [repo-dir] # scan git history for leaked secrets
keysmith inbox # directory the MCP put tool accepts files from
keysmith token API_KEY # issue a session-bound placeholder token
keysmith token API_KEY --allow-host api.example.test --allow-path /v1/
# ...bound to a destination (see below)
keysmith run --target https://api.example.test/v1/me --env AUTH="Bearer <token>" -- sh -c 'curl -H "Authorization: $AUTH" https://api.example.test/v1/me'
Use a credential without reading it
The agent never needs the plaintext to use a credential:
TOKEN=$(keysmith token API_KEY) # token on stdout, session info on stderr
keysmith run --env AUTH="Bearer $TOKEN" -- sh -c 'curl -s -H "Authorization: $AUTH" https://api.example.test/me'
TOKENis a reference, not a secret:[[keysmith:v1:API_KEY:8f3a2b1c]]. It only resolves locally, only while the issuing session is alive, and only for the names issued in it.- The real value is substituted on this machine and placed in the child's
environment. It never enters a model request, a transcript, or
argv. - A token in the command arguments is refused, because
argvis readable by every user viaps. Put it in--envand let the child's shell expand it. - A token issued with
--allow-host/--allow-path/--allow-headeris bound to a destination:runthen refuses to redeem it unless--targetdeclares a matching URL (https, or loopback http). Unbound tokens still work, with a warning. - Redemption fails closed: unknown or expired session, a name not issued in that session, a missing value, a malformed token, or an unwritable audit log all abort before the command starts. No fallback ever forwards a literal token or a plaintext value.
<store>/audit.logrecords the key names, the command basename and the argument count — never a value and never a full argument list.
Full details, including the token grammar and the fail-closed table: docs/REDEEM.md.
Vault-backed commands (with -vault):
keysmith -vault http://127.0.0.1:8200 vault-kv-set API_KEY < value.txt
keysmith -vault http://127.0.0.1:8200 vault-kv-get API_KEY # masked
keysmith -vault http://127.0.0.1:8200 vault-kv-list
keysmith -vault http://127.0.0.1:8200 vault-db-creds app-role # dynamic short-TTL DB creds
Tools
| Tool | Description | Security property |
|---|---|---|
list |
All keys with masked values | Values never plaintext |
get |
Single key, masked value | Values never plaintext |
put |
Store a secret | Reads value_file from the store inbox only, then deletes it |
rotate |
Generate + store a new strong random secret | Returns masked value only |
delete |
Remove a key | — |
Resources
| URI | Description |
|---|---|
secret://secrets |
Masked view of all secrets (safe to read into context) |
Agent skills
The bundled SKILL.md (in skill/) teaches agents to route ALL secret
operations through this server — never cat a .env, never echo a token.
The AGENTS.md at the repo root encodes the same rules for agents working
on this codebase itself.
Capability map
How the pieces relate — core primitives vs the automation/transport layers built on top of them:
flowchart TB
subgraph Core["Core primitives"]
STORE[age encrypted store<br/>internal/store]
MASK[masking rules<br/>internal/mask]
SCAN[leak-scan + self-healing<br/>keysmith scan --rotate]
VAULT[Vault short-TTL creds<br/>internal/vault]
REDEEM[local redemption<br/>internal/redeem]
end
subgraph Auto["Automation"]
CRON[scheduled leak-scan<br/>scripts/scan-cron.sh]
end
subgraph Access["Access"]
STDIO[stdio]
SSE[SSE -http]
STREAM[Streamable -streamable]
end
SCAN -->|scheduled| CRON
STORE --> SCAN
MASK --> STORE
VAULT -.->|optional backend| STORE
STDIO -.-> SSE
SSE -.-> STREAM
| Layer | Capability | Relationship |
|---|---|---|
| Core | age store + mask + rotate + scan + redeem | foundational primitives |
| Automation | scripts/scan-cron.sh |
schedules scan --rotate |
| Access | stdio / SSE / Streamable | three transports, one server |
One line: core primitives provide the power, automation makes it run by itself, transports decide how agents connect.
Security model
- At rest: always age-encrypted (X25519), armor format. A plaintext file
never exists on disk. Atomic writes (temp + rename),
0600perms. - In transcripts:
putnever takes the plaintext as an argument — it reads a file path, and only inside the store inbox (keysmith inbox); the file is deleted after it is read. A path outside the inbox is refused, so the tool cannot be used as an arbitrary-file read or unlink. - In context: masked values only. Masking keeps first/last 2 chars
(
sk******ij) so credentials are distinguishable without being revealed. - At use time:
keysmith runredeems a session-bound token locally and places the value in the child's environment. Values never reachargv, the audit log, or a model request; every failure aborts before the command starts (no plaintext fallback, no literal-token fallback). A bound token also has to satisfy--target: the declared destination must match the binding, and the target is recorded in the audit line. - Masking rules: key-name markers (SECRET/TOKEN/PASSWORD/API_KEY/DSN...), known value prefixes (sk-, ghp_, glpat-, xoxb-, JWT...), and high-entropy alphanumeric runs (≥20 chars mixing letters+digits, Shannon entropy ≥3.5). A sensitive key name forces masking even when the value does not match a value heuristic — a passphrase without digits is still a secret. Plain configuration under a non-sensitive key (DEBUG, PORT) stays readable. URL-shaped values are masked per-segment: userinfo password always masked, high-entropy path/query runs masked, host/port stay clear. Pure-numeric values (timeouts, retries) are never masked.
Development
go test ./... # unit tests (mask + store + vault + leakscan + redeem)
go vet ./... # static checks
python3 e2e_test.py # full MCP protocol round-trip
python3 verify_redeem.py # redemption: child env vs /proc, fail-closed cases, audit log
Boundaries
keysmith narrows the paths a credential can take; it does not make an untrusted machine safe. Specifically:
- Any process running as your user can read
key.txtand decrypt the store.0600/0700permissions do not isolate same-UID processes. - The bundled agent skill is guidance, not access control: nothing stops an
agent from
cat-ing a file that was never in the store. The enforced paths are the store API, the masked views, and the redemption layer. - Masking discloses the first and last two characters of a value
(
sk******ij) so credentials stay distinguishable — a deliberate, small disclosure. - Masked views and the leak-scanner are best-effort detection, not proof: a value that is never matched is never masked.
The full adversary list, including what is explicitly out of scope, is in docs/THREAT-MODEL.md.
Scheduled leak-scan (cron self-healing)
The bundled scripts/scan-cron.sh runs keysmith scan --rotate on one or
more repos, printing one line only when leaks are found (and rotated) —
silent when clean. Wire it into any cron:
# every 6 hours, scan two repos; only alerts when leaks found+rotated
0 */6 * * * /path/to/keysmith/scripts/scan-cron.sh ~/.keysmith /repo1 /repo2
Roadmap
- Vault backend (dynamic short-TTL secrets — leaked credentials expire)
- HTTP/SSE transport (for remote agent scenarios)
- CLI subcommands (add/get/rotate/scan without MCP)
- Streamable HTTP transport (MCP 2025 standard, single POST endpoint)
- Scheduled leak-scan watchdog script (cron-driven self-healing)
- Local redemption layer (session-bound tokens resolved locally; fail-closed, value-free audit log)
- Multi-tenant / team mode (share store across agents with audit log)
- Cloud credentials (AWS STS / GCP short-lived)
License
Apache-2.0
Preguntas sobre keysmith MCP
¿Qué herramientas proporciona keysmith MCP?
Expone 5 herramientas, incluidas list, get, put, rotate, delete.