OpenBao
An open-source secrets management system, written in Go. It stores and issues secrets, certificates and encryption keys, with policy-based access control and audit logging. Maintained by the OpenBao project, a Linux Foundation project.
Business rules, traced to source lines.
These 12 rules are a sample of the 23,849 CoreStory V3 extracted from OpenBao. Each one links to the exact lines on GitHub at commit 92de51f. The statement is CoreStory V3’s wording; the code excerpt is the source it cites.
custom_metadata must contain at most 64 keys; if the key count exceeds 64, validation is short-circuited and an error is returned indicating the payload must contain at most 64 keys.
- 64 — maximum permitted number of custom metadata keys
Also cited: L372–L377
AddVersion prunes versions when the sliding window size (CurrentVersion - OldestVersion) is at least maxVersions: it sets versionToDelete to CurrentVersion - maxVersions, deletes metadata versions from OldestVersion through versionToDelete, and advances OldestVersion to versionToDelete + 1. If pruning is not triggered, versionToDelete is 0.
- 0 — versionToDelete value and loop boundary when no pruning is triggered
- 1 — increment used to compute OldestVersion and loop bound
ACME-issued certificates are limited to a maximum TTL of 90 days; if the normal computed NotAfter exceeds now plus the maximum TTL, the requested TTL is clamped to the maximum.
- 90 days — maximum ACME certificate TTL duration
- 24 hours — hours per day multiplier
Also cited: L26
A remount is rejected if the source mount path or the destination mount path starts with any protectedMounts prefix ("audit/", "auth/", routing.MountPathSystem, routing.MountPathCubbyhole, routing.MountPathIdentity). The source violation returns fmt.Errorf("cannot remount %q", src.MountPath); the destination violation returns fmt.Errorf("cannot remount to destination %+v", dst).
- audit/ — protected mount path prefix
- auth/ — protected mount path prefix
Also cited: L59–L65
The literal namespace names in reservedNames are forbidden as namespace name path segments: the empty string, ".", "..", "root", "sys", "audit", "auth", "cubbyhole", and "identity". Validate rejects any segment contained in reservedNames, and ParseName rejects a clipped name contained in reservedNames.
- . — reserved namespace name
- .. — reserved namespace name
- root — reserved namespace name
- sys — reserved namespace name
- audit — reserved namespace name
- auth — reserved namespace name
- cubbyhole — reserved namespace name
- identity — reserved namespace name
A service account name is authorized if the role's ServiceAccountNames contains exactly the single wildcard "*" (i.e., list length is 1 and first element equals "*"); otherwise the service account name must match one of the glob patterns in ServiceAccountNames, or the login is denied with 403 Forbidden and "service account name not authorized".
- * — wildcard allowing any service account name
- 403 — HTTP status code when service account name is not authorized
When the request supplies critical_options and `role.AllowedCriticalOptions` is non-empty (not the wildcard), each critical option key must appear in the comma-separated allowed list; otherwise an error 'critical options not on allowed list: <keys>' is returned. When the request's critical_options is empty, the role's DefaultCriticalOptions are returned.
- critical_options — request field
- , — separator for allowed list
Also cited: L338–L341
If the database config's AllowedRoles does not contain the wildcard "*" and does not match the role name via strutil.StrListContainsGlob, setStaticAccount returns an error of the form "<roleName> is not an allowed role" (permission denied).
- * — wildcard allowed-roles entry permitting all roles
An OCSP request is rejected as too large when the base64-encoded value supplied in the `req` parameter has length greater than or equal to 2048 bytes (GET path), or when the number of bytes read from the POST body, limited to 2048 bytes, has length greater than or equal to 2048 bytes; such requests return a malformed-request response.
- 2048 bytes — maximum request size threshold; requests at or above this length are rejected
The maximum number of irrevocable leases returned to the irrevocable lease list API without the `force` flag set is 10000; when the limit is reached a warning is emitted: "Command halted because many irrevocable leases were found. To emit the entire list, re-run the command with force set true."
- 10000 — maximum irrevocable leases returned without force
- Command halted because many irrevocable leases were found. To emit the entire list, re-run the command with force set true. — warning emitted when limit is hit
Also cited: L82–L86
Generating an MFA method requires the config namespace ID to equal the entity namespace ID, or the entity namespace to have the config namespace as a parent; otherwise an error response "entity namespace %s outside of the config namespace %s" is returned.
- entity namespace %s outside of the config namespace %s — error message format
For operations within ACME using an existing account, an EAB is required when the EAB policy is "always-required" and the account has no EAB attached (account.Eab is nil), in which case ErrExternalAccountRequired is returned; otherwise no error is returned.
- always-required — policy name that requires EAB for existing accounts
Also cited: L13–L17
What the application does
23 capabilities identified, grouping 213 of the 3,403 distinct features extracted. Most extracted features are not grouped under a capability, so this list is a partial view of the application. These are descriptions, not the cited rules above.
Command-Line Interface
Command dispatch, flag parsing, help/synopsis, autocompletion, output formatting, and the operator-facing commands.
- CLI Autocomplete: Provides shell autocompletion suggestions for commands and their arguments and flags.
- CLI Command Help: Displays help information, synopsis, flags, and autocomplete support for command-line commands.
- CLI Command Help & Synopsis: Displays usage help and a synopsis for the command so users can learn its arguments and flags.
- CLI Command Help and Usage: Displays synopsis, flags, and help text for a command-line tool.
- CLI Shell Autocomplete: Provides command-line flag and argument autocompletion for the CLI, likely integrating with the shell completion protocol.
- Command Execution: A capability to run a unit of application logic, invoked through the program's main entry point.
- Command Flag Parsing: Parse command-line flags for a command.
- Command Help and Autocomplete: Provides CLI help text, flag documentation, and shell autocompletion for commands, including descriptions and flags like response headers, lease TTLs, plugin version, and token type.
- Command Help and Usage: Displays help text and usage synopsis for a command to the user.
- Command Line Autocomplete: Provides shell autocompletion for the tool's arguments and flags.
- Command Line Interface: Offers command-line flags, autocompletion, and help/synopsis output for operating the server.
- Command-Line Help: Users can view usage synopsis and flag/argument help for a command-line command.
- Generate Root: A CLI command that produces an operator generate-root token/output with OTP-based verification and status reporting.
- Operator Unseal: An operator command capability for unsealing a server instance, exposed as a dedicated command type.
- Result Output Formatting: Renders command results in multiple selectable formats such as table, JSON, and YAML.
- Shell Autocomplete: Generates shell completion candidates and flags for the CLI commands so users can tab-complete arguments and options.
- Shell Autocompletion: Generates autocompletion values and flags so users can complete commands and options interactively in their shell.
- Vault Server CLI: The command-line entry point and subcommand initialization that lets operators launch and configure the Vault server.
Seal and Unseal Operations
Initializing, sealing, unsealing, and rekeying the barrier with Shamir shares, recovery keys, or auto-unseal, plus key rotation.
- Auto Unseal: Automatically unseals a vault using configurable auto-seal barrier mechanisms and health-checked orchestration.
- Automatic Key Rotation: Automatically rotates encryption keys on a schedule or when required, tracking rotation timing and conditionally triggering rotation logic.
- Barrier Recovery: Supports recovering a barrier using a recovery key, including verifying recovery keys and checking recovery key support.
- Encryption Key Rotation: Rotate the root key and encrypting key terms, optionally automatically on a schedule.
- Key Rekeying: Allows operators to initiate and run a rekey of the root key, configured via RekeyConfig and tracked through RekeyInit, RekeyUpdate, RekeyProgress, and RekeyThreshold.
- Key Rotation: Rotate the server's encryption keyring and root key, including initiating, updating, checking status, and cancelling an in-progress rotation.
- Recovery Key Management: Generate, store, validate, and verify recovery keys for the seal.
- Rekey Operation: Triggers a key rotation/rekey operation through the HTTP interface, accessible without authentication.
- Root Key Rotation: Rotate the root encryption key including barrier root key rotation, standby keys, backed-up keys, and recovery key generation.
- Seal and Unseal: Allows operators to seal the barrier to block access and unseal it to restore operation.
- Seal and Unseal Operations: Supports sealing and unsealing the server, including recovery mode and waiting for leader election.
- Security Barrier Seal and Unseal: Seal and unseal the barrier to control whether stored data may be accessed.
- TLS Key Rotation: Management of a keyring of TLS keys with an active key and creation timestamps to support rotation.
- Transit Key Rotation: Rotate a transit key's version so new encryptions use a fresh key version.
- Vault Initialization: A client initializes a new Vault server, receiving root token, unseal keys, and PGP-encrypted key material.
- Vault Unseal: Unseal a sealed Vault server by supplying unseal keys through the operator unseal command.
- Vault Unsealing: Unseal the vault by supplying key shares or recovery keys, optionally with migration options.
Authentication
Credential-based login across auth methods (token, AppRole, JWT/OIDC, LDAP, Kubernetes, userpass, cert, OTP) including MFA and session renewal.
- AppRole Authentication: Authentication by an application using an AppRole role ID and secret ID.
- AppRole Login: Authenticates a client to Vault using the AppRole auth method, supplying a secret ID read from a string, file, or environment.
- Authentication: Provides a login capability that validates user credentials against an allowed role and secret obtained from environment, file, or string sources.
- Authentication Renewal: Renews expiring authentication tokens and credentials on behalf of the user.
- Certificate Login: Authentication via client TLS certificates, exercised through quota tests and the cert login flow.
- JWT Login: Authenticates users via JSON Web Tokens, verifying signatures, supported algorithms, expiry/nbf leeway, and nested group claims.
- Kubernetes Authentication: Configure and perform a login flow that authenticates against a Kubernetes cluster using a mounted service account token, role, and configurable token path.
- LDAP Authentication: Authenticates a user against an LDAP directory using configured credentials and mount path.
- Multi-Factor Authentication: Enables two-phase MFA login where a user validates a second factor before completing authentication.
- OIDC Login: Authenticates users through OpenID Connect, including string-valued group claims and nested group resolution.
- Token Authentication: Authentication of incoming requests by issuing, checking, and decoding client and SCC tokens.
- User Login: Authenticates a user by username and password and returns a valid token.
- Username and Password Login: Authentication using a username and password credential form.
Encryption and Cryptographic Operations
Transit-style encryption, decryption, signing, verification, HMAC, and key management including wrapping/rewrapping and import/export.
- Ciphertext Rewrapping: Rewrap existing ciphertext under the latest key version without decrypting to plaintext.
- Cryptographic Signing: Sign and verify data using managed keys.
- Cryptographic Signing and Verification: Sign and verify data using transit keys, including imported public keys and RSA/CSR-based keys.
- Encryption Key Import: Import and decrypt an encryption key from provided fields into the transit system.
- Envelope Encryption: Provides encryption and decryption of data using an envelope structure that bundles ciphertext with its key-wrapping metadata.
- HMAC Signing: Compute a keyed HMAC digest over data using a raw key.
- Key Export: Export cryptographic keys (RSA, EC, ED25519, MLDSA, HMAC, encryption, signing, public keys) in various formats such as PEM, DER, or raw.
- Key Import: Imports an existing cryptographic key supplied by the user, with help text describing its usage.
- Signature Verification: Verifies a signature against a message and key, reporting validity, including batch verification of multiple items.
- Transit Decryption: Decrypt ciphertext back to plaintext under a named transit key, with failure cases when unauthorized.
- Transit Encryption: Encrypt plaintext (optionally with context), producing ciphertext under a named transit key.
- Transit Key Management: Create, read, list, and delete transit keys and policies, including version listing and deletion enable/disable.
- Transit Secrets Engine: Provision and exercise a transit secrets engine for encryption, decryption, signing, verification, and key management.
Secrets Engine and Mount Management
Mounting, tuning, remounting, and unmounting secrets engines and auth methods, including the KV secrets engine with versioning, metadata, patching, and deletion.
- KV Secret Read: Read a secret from a key-value secrets engine, including KV v2 version resolution and preflight metadata handling.
- KV Secret Write: Users can write secret data to a KV path, including via stdin, with retry handling.
- Key-Value Store Operations: Provides CRUD and scan access to a versioned key-value store, allowing users to create, read, list, update, and search stored entries.
- Mount Lifecycle Management: Create, reconfigure, tune, and remove mounts (secrets/auth backends), including per-mount configuration such as TTLs, visibility, and plugin version.
- Mount Management: Manages local mounts and their system view context.
- Mount Tuning: Capability to adjust individual mount settings including option passing, listing visibility, non-HMAC keys, and passthrough request headers.
- Secret Deletion and Undeletion: Delete a secret's latest version, specific versions, or all versions, and restore soft-deleted secrets.
- Secret Metadata Management: Read, set, patch, and delete custom metadata and version metadata associated with a secret.
- Secret Retrieval: Retrieve a secret by key, including specific historical versions and detailed listings.
- Secret Write and Patch: Store a new secret value or apply a merge patch to an existing secret.
- Secrets Engine Mount Management: Enables users and operators to mount, unmount, and taint secrets engines and auth backends at paths.
- Secrets Engine Remount: Lets users move a secrets engine or auth backend from one path to another, including storage relocation.
- Versioned Key-Value Storage: A key-value backend that stores and retrieves versioned secrets with per-key encryption, version tracking, and cleanup of old versions.
Lease Management
Tracking, renewal, revocation, expiration, and tidy of leases and their associated secrets.
- Lease Count Reporting: Reports total lease counts, including counts with roles.
- Lease Expiration: Background expiration of leases using configurable TTLs, worker pools, and expiry strategies.
- Lease Expiration Handling: Detection and handling of expired leases and persistent lease eviction.
- Lease Garbage Collection: Collect stale or orphaned lease entries across namespaces and tidy up policies and locks.
- Lease Lookup: Allows callers to look up a lease by its ID, with context-aware variants.
- Lease Management: Users can read, update, and configure TTL-based leases with maximum TTL and TTL settings.
- Lease Persistence and Restore: Persist lease and token entries to storage and restore them into memory on startup.
- Lease Renewal: Allows callers to renew an existing lease, with context-aware variants.
- Lease Revocation: Allows callers to revoke leases by ID, with force and prefix-based variants plus configurable options and sync.
- Lease TTL Management: Lease time-to-live values are configured and enforced for backend-issued credentials.
- Secret Lease Management: Clients receive, renew, and manage leases for secrets, including default and maximum lease durations.
- Secret Lease Revocation: Revokes secret leases, both individually and via cache-clearing requests that compute index IDs and derive namespace/revocation paths.
PKI Certificate Authority
CA hierarchy generation, issuer and role management, certificate issuance and signing, CRLs, OCSP, ACME issuance, and tidy.
- ACME Certificate Issuance: Automated issuing of TLS certificates via the ACME protocol for domains and certificate signing requests using DNS-based challenge validation.
- Certificate Generation and Signing: Capability to generate and sign X.509 certificates (including CEL certificates) from CSR or creation bundles.
- Certificate Issuance: Issue X.509 certificates with configurable TTL, lease, and extra parameters for various subject types.
- Certificate Issuance with SANs and CSR: Issue leaf certificates from CSRs with configurable subject alternative names including DNS, IP, URI, OID, and user-ID attributes.
- Certificate Revocation: Revoke issued certificates, including intermediates, and manage tidy operations.
- Certificate Revocation List Management: Enables and disables Certificate Revocation Lists (CRLs) for CAs, including intermediate/root configuration and secondary CRL rebuilding.
- Certificate Signing: Sign certificate data using an issuer or external signer, including verbatim signing and CEL-evaluated signing.
- Certificate Store Tidy: Automated and manual cleanup of expired, revoked, and invalid certificates from the PKI store, including pagination and safety-buffer-aware retention.
- Issuer Management: Patch issuers and verify issuer defaults and key import behavior.
- OCSP Certificate Status Response: Generates OCSP responses reporting certificate revocation status, including unknown-certificate responses.
- PKI Certificate Authority Management: Capability to generate, cross-sign, and import certificate authority hierarchies including root and intermediate issuers and CA bundles.
- PKI Secrets Engine: Provision and exercise a PKI secrets engine, including root CA, intermediate CA, and key issuance.
API and HTTP Serving
HTTP request routing, response generation, headers, CORS, TLS listeners, and the OpenAPI-documented API surface.
- API Documentation Display: Serves and describes the API surface through an OpenAPI-style spec including paths, operations, parameters, schemas, and responses.
- CORS Handling: Provides cross-origin resource sharing support so browsers can make requests to the API from permitted origins and methods.
- HTTP Request Handling: Serves HTTP requests through a handler that builds a Response and listens on a configurable port within an environment-driven setup.
- HTTP Response Generation: Constructing outgoing HTTP responses with status codes, headers, and body content.
- HTTP Server: Starts and runs an HTTP server that handles requests via registered handlers.
- OpenAPI Document Generation: Builds and returns a complete OpenAPI document (info, paths, operations, components) describing an API from internal definitions.
- Redirect Response: Returning an HTTP redirect to the client.
- Request Routing: Routing of incoming API requests with approval and cancelation handling.
- Request Routing and Path Handling: Client requests are routed to the correct mount and path, handling root paths, slashes, and sudo access.
- Response Wrapping: Wrap and unwrap API responses using configurable wrapping keys and TTLs.
- TLS Network Listening: Starts a TLS-secured network listener with configurable certificates and reloadable TLS configuration.
Audit and Logging
Tamper-evident audit device management and structured leveled logging with rotation and reload.
- Agent Logging Configuration: Configuration of Vault Agent logging to a file or default logger, overridable via CLI and reloadable at runtime.
- Audit Device Management: Enable, disable, read, and update audit devices and their headers.
- Audit Log Management: Enables, disables, lists, and hashes audit records for a path with configurable options, giving users control over the auditing lifecycle.
- Audit Logging: Provides tamper-evident audit logging via HMAC-based accessors.
- Audit Trail: Authentication and request handling events are recorded to configured audit backends.
- Audited Headers Configuration: Users can add and remove audited headers through CRUD configuration of the audited-headers system.
- Leveled Logging: Emit log messages at distinct severity levels (trace, debug, info, warn, error, fatal) so consumers can record messages with an appropriate severity.
- Log File Rotation: Automatically rotates the active log file when size or time limits are reached, optionally archiving and pruning old files.
- Log Level Filtering: Query and configure the active log level so that only messages at or above a chosen severity are produced.
- Logging Configuration: Users can configure logging behavior such as level, format, file destination, and rotation through flags, environment variables, and explicit overrides.
- Structured Logging: Emits leveled log messages (trace/debug/info/warn/error) through a logger server with configurable level filtering.
Configuration Management
Loading, parsing, validating, and hot-reloading server and component configuration including TLS and listeners.
- Backend Configuration: Set and read the certificate authority backend configuration and certificate policy.
- Config Management: Create, read, modify, list, delete, and invalidate named configuration entries.
- Configuration Loading: Loads, merges, and normalizes configuration from files and directories into a resolved Config.
- Configuration Reload: Reloads runtime configuration without restarting the service.
- Configuration Validation: Validates configuration for correctness and required listers before use.
- Listener Configuration Parsing: Parsing listener address and socket configuration templates.
- Runtime Reload: Operators can reload certificates, configuration, and log level while the process is running.
- Storage Backend Configuration: Users configure and parse storage backends, including HA storage options, for Vault.
- Storage Configuration: Loading and validating the backend configuration, storage paths, and policy settings for the storage system.
- TLS Configuration: Enables users to configure TLS settings for secure connections, including certificate authority management.
- TLS Configuration Retrieval: Allows retrieval of TLS configuration settings for secure connections.
Raft Clustering and High Availability
Raft consensus, cluster membership, leadership, autopilot, snapshots, and request forwarding for HA operation.
- Cluster Request Forwarding: Forwards requests to the cluster leader, preserving the original request path and refusing to forward when local-only or cluster information is missing.
- Distributed Consensus (Raft): A Raft-based consensus layer that elects leaders, tracks terms and applied indices, and accepts client and inter-node communication.
- High Availability Active/Standby: Servers operate in active/standby mode with failover, step-down, and rotation between nodes.
- High Availability Leadership: Nodes contend for and hold leadership of the cluster, tracking active/standby state and stepping down when leadership is lost.
- Leader Election and Membership State: The cluster tracks active membership and election-related state such as term and lowest active index.
- Raft Autopilot: Automatic dead server cleanup, peer stabilization, and voter/non-voter promotion management for Raft clusters.
- Raft Backend Storage: Provides a Raft-backed storage backend supporting put, snapshot, transaction, key/value, list-prefix, and performance operations.
- Raft Cluster Management: Capability to form, join, configure, and remove nodes from a Raft storage cluster.
- Raft Cluster Membership Management: Bootstrap, join, teardown, and recover clusters.
- Raft Peer Management: Add, remove, promote, and demote cluster peers and manage suffrage.
- Raft Snapshot Management: Save and restore Raft cluster snapshots, with explicit handling of incomplete snapshots.
Token Lifecycle Management
Creation, lookup, renewal, revocation, and accessor-based management of authentication tokens.
- Accessor Management: Listing, lookup, and approval of token accessors for managing tokens without knowledge of the token ID.
- Orphan Auth Token Handling: Create and manage auth tokens that lack a parent token.
- Token Accessor Management: Create and manage token accessors enabling lookup, renewal, and revocation without exposing the token itself.
- Token Creation: Create new authentication tokens, optionally as child/orphan tokens or with specific roles and policies.
- Token Creation and Issuance: Create authentication tokens with configurable type, TTL, policies, and identity bindings.
- Token Issuance: Create new auth tokens, including orphaned tokens and tokens bound to roles with associated policies.
- Token Lookup: Retrieve information about an existing token, either one's own token or another's via accessor.
- Token Renewal: Extend the lifetime/lease of an existing token, for one's own token or via accessor, subject to renewable/period/TTL properties.
- Token Revocation: Invalidate tokens, including revoking one's own token, an accessor, orphan tokens, or an entire token tree.
- Token Role Management: Creating and managing token roles that define allowed/disallowed policies, period, orphan status, and TTL constraints for issued tokens.
- Token Store Tidy: Tidying of the token store to clean up orphaned tokens, leases, and related bookkeeping.
Authorization and Policy
ACL policy definition, parsing, evaluation, and enforcement that grants or denies operations against paths and capabilities.
- ACL Authorization: Evaluates access-control rules to decide whether a requested operation is allowed or denied for a given path.
- ACL Enforcement: Blocks or permits API requests based on privilege rules.
- Access Control Policy Management: Define, parse, merge, and evaluate ACL policies that grant or deny operations against paths, segments, and values.
- Authorization Check: Evaluates request authorization and distinguishes authorized from unauthorized access.
- Capabilities Introspection: Query the capabilities available on a given path.
- Control Group Enforcement: Defines control-group factor and identity requirements that gate access to policy paths.
- Policy Enforcement: Evaluates ACL policies for requests and manages the policy store lifecycle.
- Policy Evaluation: Evaluate a request against engine policies to produce an output or decision the caller observes.
- Policy Management: CRUD operations for retrieval, listing, creation/update, and deletion of policies.
- Policy Path Rule Evaluation: Interprets path rules that determine which capabilities apply to a given request path, handling prefix and segment-wildcard matching.
Identity and Group Management
Entities, aliases, groups, and membership resolution forming the identity store used for access decisions.
- Alias Management: Upsert aliases to create or update identity aliases for entities.
- Entity Alias Management: Capability to attach, resolve, and manage aliases that map external identity sources to entities, including local and mount-specific aliases.
- Entity Management: Create, load, update, and delete entities (including alias identifiers and metadata) in the identity store.
- Entity Merge: Capability to merge multiple identity entities into one while detecting and rejecting conflicting aliases or clashing entities.
- Group Alias Management: Allows users to create, update, delete, and look up group aliases that map alternative names to groups, with case-insensitive resolution and database indexing.
- Group Management: Create, read, update, and delete groups addressable by ID or name.
- Group Membership Management: Capability to define groups, their membership, and associated policies and metadata.
- Group and Entity Management: Provides packing and diffing of groups and other entities for storage and synchronization.
- Identity Entity Management: Represents and manages identity entities with their aliases, policies, metadata, MFA secrets, and merge history.
- Identity Group Membership: Manages identity groups with member entities, nested parent groups, policies, and alias references.
Secret Storage and Retrieval
Reading, writing, listing, scanning, patching, and deleting secrets and stored entries across backends.
- Cubbyhole Secret Storage: A per-token private key-value store where users can write, read, list, and delete secrets scoped to their own token.
- Key Value Listing: Enumerate keys under a given prefix, with paginated listing support.
- Key Value Read: Retrieve a single stored value by key, including support for alternate key expansions and path truncation.
- Key Value Write: Create or update a value under a key in the store.
- Key-Value Patching: Apply a patch update to a key-value entry, with retry handling and validation of headers and tokens.
- Secret Delete: Remove secret data at a path, with data-passing and context-aware variants.
- Secret Listing: Lists secrets held in the key-value store.
- Secret Patch Operation: Applies partial patch updates to a secret through a preprocessing and operation pipeline.
- Secret Read: Retrieve secret data by path, with plain, raw, and context-aware variants.
- Secret Write: Persist secret data at a path, including raw byte writes and context-aware variants.
Agent and Proxy
Vault Agent/Proxy auto-auth, API proxying with caching, templating, and process lifecycle management.
- API Proxy with Caching: An HTTP API proxy that forwards requests and caches responses, including dynamic-secret-aware caching.
- Agent API Proxy: A Vault Agent capability that proxies API requests to the Vault server, optionally caching responses and using configured user-agent headers.
- Agent Auto-Auth: Automatic authentication of the Vault Agent using AppRole credentials, including token caching and exit-after-auth behavior.
- Agent Command Execution: Run the agent process with configurable exec command, restart behavior, and secret-change restart handling.
- In-Memory Key-Value Caching: Provides a key-value store backed by an in-memory database that clients can create and read/write entries against.
- Proxy Command Execution: Users can run the proxy command, which boots configuration, logging, and process lifecycle behavior.
- Secret Template Rendering: Rendering of Vault secrets into files via Consul Template configuration, including retries, exit counters, and Vault client environment setup.
- Template Rendering: Render templated content using the provided transformations.
- Vault Agent Configuration Loading: Loads and validates Vault Agent configuration files, including agent cache, listener, and vault retry settings.
Container and Build Tooling
Building, signing, publishing, and managing container images and distributable build artifacts for the project.
- Build and Release: Builds and releases the project binary with configurable build tags, optionally bootstrapping dependencies and external tooling.
- Container Image Build: Builds a Docker/container image from a build context and options, optionally pulling parent images and tagging the result.
- Container Image Release: Automates building, tagging, pushing, and signing multi-platform container images for multiple distro variants.
- Docker Cluster Provisioning: Provisions a multi-node Vault cluster running in Docker containers with networking and node setup.
- Image Signing: Installs Cosign and signs released container images to provide supply-chain verification.
- Package Signing: Import a GPG key and install Cosign to sign release artifacts and repository metadata.
- Release Publishing: Produces and publishes versioned releases, including release images.
- Repository Release Publication: Consolidate distro packages into a release and publish the updated repository.
- Vault Container Image Build: Building versioned Vault container images for community and enterprise editions.
Dynamic Secret and Credential Generation
On-demand generation, lease, renewal, and revocation of database, SSH, and other dynamic credentials.
- Credential Generation: Generate and set credentials for users.
- Credential Lease Management: Users can manage the lease lifecycle of their credentials, including canceling a lease and updating its time-to-live.
- Database Credential Management: Configure and rotate database credentials and roles, including static role assignment and credential rotation queue.
- Database Credential Rotation: Enables rotation of database connection credentials, updating the stored password for a named connection and user.
- Dynamic Credential Issuance: Issues dynamic SSH credentials for configured users, ports, and IP targets.
- Root Credential Rotation: Rotate the root credentials of the system.
- Secret Credential Management: Issuing, renewing, and revoking secret credentials for a defined credential type.
- Secret Credential Revocation: Allows a user or system to revoke previously issued secret credentials.
- Static Role Password Rotation: Rotates static database role passwords on a schedule, including WAL queueing when rotation fails so rotations can be replayed later.
Observability and Metrics
Exposure of operational metrics, profiler endpoints, host/system info, and health checks to monitoring systems.
- Cluster Metrics Collection: Emit telemetry and operational metrics into a cluster-wide metric sink for monitoring.
- Health Status Reporting: Exposes a health endpoint that reports server replication, sealing, and liveness status to clients.
- Host Info Collection: Collects host hardware and resource information such as CPU, memory, disk, and host identity into a HostInfo structure.
- Host Information Collection: Collects host system information including CPU, memory, disk, and timestamps for monitoring or reporting purposes.
- Metrics Collection and Export: Expose and surface operational metrics (counters, gauges, summaries) to consumers.
- Profiling Endpoint: Exposes a pprof binary accessible to users for capturing runtime profiling data.
- Prometheus Metrics Export: Exposes application metrics in Prometheus exposition formats for scraping and monitoring.
- System Metrics Exposition: Exposes system-level metrics over an HTTP endpoint, including support for a custom metrics path and unauthenticated access.
- Telemetry Reporting: Configuration of metrics and telemetry emission to monitoring backends such as StatsD, Statsite, and Circonus.
Plugin Management
Registration, cataloging, mounting, connection, versioning, and lifecycle of external and builtin plugins.
- External Plugin Connection: A capability to establish and manage connections to external plugins, including multiplexing and client lifecycle.
- Plugin Catalog Management: Plugins can be registered and removed from the catalog.
- Plugin Lifecycle Management: Lifecycle management of plugin processes including setup, operation, and teardown.
- Plugin Mounting and Unmounting: Mounting and unmounting plugins, including multiplexed logical backends and versioned mounts.
- Plugin Multiplexing: Multiplexing plugin processes by grouping plugins that share type, version, and arguments while keeping differing ones separate.
- Plugin Registration: Registering a plugin with a vault server and observing the registration response.
- Plugin Reload: Trigger a reload of a plugin and observe its reload status/completion.
- Plugin Version Reporting: Exposes the backend plugin's version and versioning capability, including the empty/unset plugin version case.
- Plugin Versioning: Reports plugin and running version information to users and the system.
Storage and Transactions
Key-value storage backends with transactional begin/commit/rollback semantics, pagination, and storage views.
- Key-Value Storage: Users can store, retrieve, list, page through, and delete keys and their values in the backend store.
- Key-Value Storage Operations: Provides read, write, and delete access to key-value data through a view abstraction.
- Key-Value Store: A storage backend that supports storing, retrieving, listing, and deleting keyed entries.
- Read-Only Transactions: Allows starting read-only transactions with configurable read-only error handling.
- Read-Write Transactions: Open a writable transaction allowing reads and writes within an isolated scope that can be committed or rolled back.
- Storage Operations: Capability to perform put, get, delete, and list operations on stored data with size validation.
- Storage View Listing: Lists stored entries within a view, with optional pagination for large result sets.
- Transactional Key-Value Store: A persistent key-value store offering CRUD operations alongside explicit transaction control with commit and rollback.
- Transactional Storage: Supports atomic transactions with begin, commit, and rollback over the key-value store.
Namespace Management
Creation, hierarchy, sealing, locking, and deletion of namespaces with per-namespace mounts and isolation.
- Namespace Creation and Configuration: Users can create new namespaces and modify their configuration through a set operation.
- Namespace Deletion: A command-line capability to delete a namespace, invoked via a delete command with its arguments, flags, and help/synopsis metadata.
- Namespace Hierarchy: Maintains hierarchical relationships between namespaces.
- Namespace Isolation: Enforce separation of identity data across namespaces including group buckets and edge cases.
- Namespace Listing: Users can enumerate the namespaces available in the system, with the results shaped and validated by a dedicated list schema.
- Namespace Lookup and Resolution: Resolve and retrieve namespaces by path, accessor, or longest prefix, including from incoming requests.
- Namespace Management: Create, read, update, and delete (CRUD) operations for managing namespaces via validation-backed API endpoints.
- Namespace Seal and Unseal: Seal and unseal a namespace to toggle its availability.
Testing Infrastructure
Harnesses and test execution for acceptance, backend conformance, integration, and unit testing across the system.
- Acceptance Test Runner: Executes acceptance test cases composed of steps, including preflight hooks, precheck assertions, and teardown, against backend environments.
- Backend Conformance Testing: Exercises multiple storage backends with a uniform set of CRUD, list, paging, transaction and random-operation tests to verify behavioral equivalence across all implementations.
- Go Test Execution: Runs Go test suites in CI with configurable flags, tags, architecture, and parallelism.
- Integration Test Execution: Running the integration test suite including license checking and test runner invocation.
- Test Case Execution: Defining and running structured multi-step test cases with assertions against Vault plugin behavior.
- Test Cluster Provisioning: Provision and start an in-memory test cluster with its cores, listeners, and barrier keys for exercising the system.
- Test Execution: Run the test suites including unit, acceptance, race, compile, and Ember UI tests.
- Test Setup: Provides standardized harnesses for initializing application, rendering, and unit test environments.
What was analyzed
- Go · 1,534 files · 430,303 lines
- Markdown · 847 files · 74,938 lines
- JavaScript · 1,290 files · 64,495 lines
- YAML · 77 files · 30,380 lines
- Handlebars · 479 files · 21,792 lines
- SVG · 112 files · 6,831 lines
- SCSS · 105 files · 6,227 lines
- TypeScript · 78 files · 4,453 lines
- HCL · 103 files · 2,325 lines
- Text · 499 files · 1,908 lines
- JSON · 34 files · 1,698 lines
- Other (9 languages) · 68 files · 3,138 lines
Whole repository: 5,446 files. cloc 2.06 counts 648,488 lines of code in 5,226 of them (833,286 lines with comments and blanks).
Where this came from
Extracted by CoreStory V3 (build 4470 with two small engine fixes) using DeepSeek-V4.1-Flash from the public repository at commit 92de51f on 2026-11-13. Capability descriptions are from the same run.
- Repository openbao/openbao
- Commit 92de51f7a0586759215d299bc79118874ea54fb1
- Line counts cloc 2.06
- Rule citations Each rule shown was checked: its quote was compared with the repository source at the cited lines at this commit.
Code excerpts are from the upstream repository and remain under its MPL-2.0 license. CoreStory is not affiliated with or endorsed by the OpenBao project.
Want this for your own codebase?
Talk to us about mapping the business rules in your repositories.