HCVA0-003 HashiCorp Certified: Vault Associate (003) Exam Free Practice Exam Questions (2026 Updated)

Comprehensive and Detailed in Depth Explanation:

Vault tokens have a Time-To-Live (TTL) that determines their expiration time, after which they are revoked. Parent-child relationships mean that revoking a parent token also revokes its children, regardless of their TTLs. Let’s analyze:

A: TTL 4 hours - Expires after 4 hours, no children listed.

B: TTL 6 hours - Expires after 6 hours, parent to C.

C: TTL 4 hours (child of B) - Expires after 4 hours or if B is revoked earlier.

D: TTL 3 hours - Expires after 3 hours, parent to E.

E: TTL 5 hours (child of D) - Expires after 5 hours or if D is revoked earlier.

Analysis:

Shortest TTL is D (3 hours), so it expires first unless a parent above it (none listed) is revoked sooner.

E (5 hours) is a child of D. If D is revoked at 3 hours, E is also revoked, despite its longer TTL.

A and C (4 hours) expire after D.

B (6 hours) expires last among parents.

The question asks which token(s) are revoked first based on TTL alone, not manual revocation. D has the shortest TTL (3 hours) and will be revoked first. E’s revocation depends on D, but the question focuses on initial expiration. Thus, only D is revoked first based on its TTL.

Overall Explanation from Vault Docs:

Tokens form a hierarchy where child tokens inherit revocation from their parents. “When a parent token is revoked, all of its child tokens—and all of their leases—are revoked as well.” TTL dictates automatic expiration unless overridden by manual revocation or parent revocation. Here, D’s 3-hour TTL is the shortest, making it the first to expire naturally.

Comprehensive and Detailed in Depth Explanation:

A: Incorrect. Transit doesn’t store ciphertext; it returns it to the client.

B: Correct. The Transit engine performs encryption/decryption without persisting data.

Overall Explanation from Vault Docs:

“The Vault Transit secrets engine does NOT store any data… Ciphertext is returned to the caller.”

Comprehensive and Detailed in Depth Explanation:

A: Irrelevant to permissions. Incorrect.

B: UI and CLI use the same permissions. Incorrect.

C: UI browsing requires list on parent paths; read alone isn’t enough. Correct.

D: Token works via CLI, so it’s valid. Incorrect.

Overall Explanation from Vault Docs:

“To browse the UI, users need list permissions on paths leading to the secret…”

Comprehensive and Detailed in Depth Explanation:

A: Incorrect. min_decryption_version sets the minimum key version, not length.

B: Correct. It controls versioning, not key size.

Overall Explanation from Vault Docs:

“min_decryption_version specifies the minimum key version for decryption… Key length is a separate configuration.”

Comprehensive and Detailed in Depth Explanation:

The initialization page means Vault is new or reset. Let’s evaluate:

A: Storage issues don’t trigger this screen; they’d cause errors post-init. Incorrect.

B: Vault requires initialization (vault operator init) to set up keys and enable login. Correct.

C: Policies apply post-login, not pre-init. Incorrect.

D: Config errors would prevent Vault from starting, not show this screen. Incorrect.

Overall Explanation from Vault Docs:

“Before Vault can be used, it must be initialized and unsealed… This screen indicates Vault has not been initialized yet.”

Comprehensive and Detailed in Depth Explanation:

A: Connection refused isn’t a service issue here. Incorrect.

B: Permissions don’t cause connection errors. Incorrect.

C: Invalid syntax change. Incorrect.

D: Default VAULT_ADDR is HTTPS; if TLS is off, set to http://127.0.0.1:8200. Correct.

Overall Explanation from Vault Docs:

“If TLS is disabled, set VAULT_ADDR to http://127.0.0.1:8200 to avoid connection errors…”

Comprehensive and Detailed in Depth Explanation:

A: v2 shows the key was rotated once. Correct.

B: Transit doesn’t store data. Incorrect.

C: v2 is the key version, not data version. Incorrect.

D: No transit v2 option exists. Incorrect.

Overall Explanation from Vault Docs:

“Ciphertext is prepended with the key version (e.g., v2)… Indicates rotation.”

Comprehensive and Detailed in Depth Explanation:

Token is enabled by default and cannot be disabled.

Userpass is explicitly enabled.

Total: 2 auth methods.

Overall Explanation from Vault Docs:

“Tokens are the default auth method… Additional methods like userpass increase the count.”

Comprehensive and Detailed in Depth Explanation:

The screenshot provides a lease path: auth/userpass/login/student01, which reveals the authentication method used to generate the token tied to this lease. Vault’s auth methods create tokens at specific paths, and the path structure indicates the method.

Option A: Userpass The path auth/userpass/login/student01 explicitly includes userpass, matching the userpass auth method. This method authenticates users with a username (e.g., student01) and password, typically via vault login -method=userpass username=student01. The /login endpoint confirms a login operation, and the lease ties to the resulting token. This is the clear, correct answer based on the path. Correct. Vault Docs Insight: “The userpass auth method allows users to authenticate with a username and password… mounted at auth/userpass by default.” (Matches the path.)

Option B: Auth “Auth” isn’t an auth method—it’s the namespace prefix (auth/) for all auth methods in Vault (e.g., auth/token, auth/userpass). The screenshot specifies userpass within auth/, not a generic “auth” method. This option is a misnomer and incorrect. Vault Docs Insight: “All auth methods are mounted under auth/… ‘auth’ itself is not a method.” (Clarifies structure.)

Option C: Root token A root token is a privileged token type, not an auth method. It’s created during Vault initialization or via auth/token/create with root privileges, not through a login path like auth/userpass/login. The screenshot’s path indicates a userpass login, not a root token usage. Incorrect. Vault Docs Insight: “Root tokens are created at initialization… not tied to a specific auth method login path.” (Distinct from userpass.)

Option D: Child token A child token is a token created by a parent token (e.g., via vault token create), not an auth method. The path auth/userpass/login/student01 shows a login event, not a token creation event (which would be auth/token/create). This option confuses token hierarchy with authentication. Incorrect. Vault Docs Insight: “Child tokens are created by parent tokens… not directly via login endpoints.” (Different mechanism.)

Detailed Mechanics:

When a user logs in with vault login -method=userpass -path=userpass username=student01, Vault hits the endpoint POST /v1/auth/userpass/login/student01 with a password payload. Success generates a token, and a lease is created at auth/userpass/login/student01 with a TTL. The screenshot’s lease path directly reflects this process, pinpointing userpass as the method.

Real-World Example:

Enable userpass: vault auth enable userpass. Add user: vault write auth/userpass/users/student01 password=secret. Login: vault login -method=userpass username=student01. The token’s lease appears as auth/userpass/login/student01.

Overall Explanation from Vault Docs:

“The lease shown lives at auth/userpass/login/ < username > and indicates the userpass auth method was used to obtain a token… The userpass method authenticates via username/password at its mount path.” The path structure is a definitive indicator.

Comprehensive and Detailed in Depth Explanation:

Leases tie to dynamic secrets with TTLs. Let’s check:

A: KV - Static secrets, no lease on read. Correct.

B: Consul - Dynamic creds with leases. Incorrect.

C: Database - Dynamic creds with leases. Incorrect.

D: AWS - Dynamic creds with leases. Incorrect.

Overall Explanation from Vault Docs:

“The Key/Value Backend… does not issue leases although it may return a lease duration.”

Comprehensive and Detailed in Depth Explanation:

The Vault Secrets Operator (VSO) integrates Kubernetes workloads with Vault by syncing secrets. Let’s evaluate:

A: VSO doesn’t create a local API endpoint for direct requests; it syncs secrets to Kubernetes Secrets. Incorrect.

B: Client-side caching is a Vault Agent feature, not VSO’s primary function. VSO can use caching, but it’s not the main integration method. Incorrect.

C: VSO doesn’t inject Vault Agents; that’s a separate Vault Agent Sidecar approach. Incorrect.

D: VSO watches Custom Resource Definitions (CRDs) to sync Vault secrets to Kubernetes Secrets dynamically. This is its core mechanism. Correct.

Overall Explanation from Vault Docs:

“VSO operates by watching for changes to its supported set of CRDs… It synchronizes secrets from Vault to Kubernetes Secrets, ensuring applications access them natively.”

Comprehensive and Detailed in Depth Explanation:

A: Vault’s default max TTL is 768 hours (32 days). Correct.

B, C, D: Incorrect values per Vault’s defaults.

Overall Explanation from Vault Docs:

“The system max TTL is 768 hours (32 days) unless overridden…”

Comprehensive and Detailed in Depth Explanation:

Vault’s API provides endpoints for managing its components, including secrets engines, which generate and manage secrets (e.g., AWS, KV, Transit). Managing secrets engines involves enabling, disabling, tuning, or listing them. Let’s evaluate:

Option A: /secret-engines/ This is not a valid Vault API endpoint. Vault uses /sys/ for system-level operations, and no endpoint named /secret-engines/ exists in the official API documentation. It’s a fabricated path, possibly a misunderstanding of secrets engine management. Incorrect.

Option B: /sys/mounts This is the correct endpoint. The /sys/mounts endpoint allows operators to list all mounted secrets engines (GET), enable a new one (POST to /sys/mounts/ < path > ), or tune existing ones (POST to /sys/mounts/ < path > /tune). For example, enabling the AWS secrets engine at aws/ uses POST /v1/sys/mounts/aws with a payload specifying the type (aws). This endpoint is the central hub for secrets engine management. Correct.

Option C: /sys/capabilities The /sys/capabilities endpoint checks permissions for a token on specific paths (e.g., what capabilities like read or write are allowed). It’s unrelated to managing secrets engines—it’s for policy auditing, not mount operations. Incorrect.

Option D: /sys/kv There’s no /sys/kv endpoint. The KV secrets engine, when enabled, lives at a user-defined path (e.g., kv/), not under /sys/. System endpoints under /sys/ handle configuration, not specific secrets engine instances. Incorrect.

Detailed Mechanics:

The /sys/mounts endpoint interacts with Vault’s mount table, a registry of all enabled backends (auth methods and secrets engines). A GET request to /v1/sys/mounts returns a JSON list of mounts, e.g., { " kv/ " : { " type " : " kv " , " options " : { " version " : " 2 " }}}. A POST request to /v1/sys/mounts/my-mount with { " type " : " kv " } mounts a new KV engine. Tuning (e.g., setting TTLs) uses /sys/mounts/ < path > /tune. This endpoint’s versatility makes it the go-to for secrets engine management.

Real-World Example:

To enable the Transit engine: curl -X POST -H " X-Vault-Token: < token > " -d ' { " type " : " transit " } ' http://127.0.0.1:8200/v1/sys/mounts/transit. To list mounts: curl -X GET -H " X-Vault-Token: < token > " http://127.0.0.1:8200/v1/sys/mounts.

Overall Explanation from Vault Docs:

“The /sys/mounts endpoint is used to manage secrets engines in Vault… List, enable, or tune mounts via this system endpoint.”

Comprehensive and Detailed in Depth Explanation:

The PKI secrets engine in Vault generates dynamic X.509 certificates, acting as a certificate authority (CA) to streamline certificate management. Let’s assess each option based on its documented benefits:

Option A: TTLs on Vault certs are longer to ensure certificates are valid for a longer period of time This is misleading. Vault’s PKI engine allows configurable TTLs, but the recommendation is for short TTLs (e.g., hours or days) to reduce the need for revocation and enhance security. Long TTLs increase exposure if a certificate is compromised, requiring revocation and larger Certificate Revocation Lists (CRLs). The engine’s benefit isn’t longer validity—it’s flexibility and automation, not extended lifetimes. Incorrect. Vault Docs Insight: “By keeping TTLs relatively short, revocations are less likely… helping scale to large workloads.” (Short TTLs are preferred.)

Option B: Reducing, or eliminating certificate revocations A key advantage of the PKI engine is issuing short-lived certificates. With short TTLs (e.g., 24h), certificates expire naturally before revocation is needed, minimizing CRL maintenance. For example, an app can fetch a new cert daily, reducing revocation events compared to traditional multi-year certs. This aligns with Vault’s ephemeral certificate model. Correct. Vault Docs Insight: “By keeping TTLs relatively short, revocations are less likely to be needed, keeping CRLs short…” (Direct benefit.)

Option C: Reduces time to get a certificate by eliminating the need to generate a private key and CSR Traditionally, obtaining a certificate involves generating a private key, creating a Certificate Signing Request (CSR), and submitting it to a CA—a manual, time-consuming process. The PKI engine automates this: vault write pki/issue/my-role common_name=app.example.com instantly generates a private key and signed certificate. This eliminates manual steps, speeding up issuance significantly. Correct. Vault Docs Insight: “Services can get certificates without… generating a private key and CSR, submitting to a CA, and waiting…” (Automation reduces time.)

Option D: Vault can act as an intermediate CA The PKI engine can be configured as an intermediate CA, signed by a root CA (internal or external). For example, vault write pki/intermediate/generate/internal common_name= " Intermediate CA " creates an intermediate, which can issue certificates under a trust chain. This supports hierarchical PKI setups, a major feature. Correct. Vault Docs Insight: “The PKI secrets engine can act as an intermediate CA… issuing certificates on behalf of a root CA.” (Explicit capability.)

Detailed Mechanics:

The PKI engine operates at paths like pki/ (root) or pki_int/ (intermediate). Roles (e.g., my-role) define parameters like TTL and allowed domains. Issuing a cert (vault write pki/issue/my-role…) returns a JSON payload with certificate, private_key, and issuing_ca. Short TTLs leverage Vault’s lease system, auto-revoking certs on expiry. As an intermediate CA, it signs certificates with its key, validated against a root, enhancing trust management.

Real-World Example:

An app needs a cert: vault write pki/issue/web common_name=web.example.com ttl=24h. Vault returns a cert and key instantly, valid for 24 hours. No CSR, no revocation needed—expires tomorrow. Another PKI mount at pki_int/ issues certs under a corporate root CA.

Overall Explanation from Vault Docs:

“The PKI secrets engine generates dynamic X.509 certificates… Services can get certificates without the usual manual process… By keeping TTLs short, revocations are less likely… Vault can act as an intermediate CA, issuing certificates efficiently.” These benefits—automation, reduced revocation, and CA flexibility—define its value.

Comprehensive and Detailed in Depth Explanation:

cubbyhole is default; kv and transit are user-enabled. Total: 3.

Overall Explanation from Vault Docs:

“cubbyhole is enabled by default… User-enabled engines add to this.”

Comprehensive and Detailed in Depth Explanation:

A: Sealing would prevent decryption, not return encoded data. Incorrect.

B: Permission issues don’t return encoded data. Incorrect.

C: Transit returns base64-encoded plaintext; decoding Y3JlZGl0LWNhcmQtbnVtYmVyCg== yields “credit-card-number”. Correct.

D: No evidence of corruption; it’s a format issue. Incorrect.

Overall Explanation from Vault Docs:

“All plaintext data must be base64-encoded… Decode it to reveal the original value.”

Comprehensive and Detailed in Depth Explanation:

A: Matches dev policy and num_uses=5. TTL is system default (768h). Correct.

B: Missing num_uses. Incorrect.

C: Adds default policy explicitly, not needed as it’s implicit. Incorrect.

D: Missing num_uses. Incorrect.

Overall Explanation from Vault Docs:

“vault token create with -policy and -use-limit sets specific attributes… default policy is included implicitly.”

Comprehensive and Detailed in Depth Explanation:

Vault tokens have two key time attributes: TTL (Time-To-Live) and Max TTL (Maximum Time-To-Live), governing their lifecycle. Let’s dissect each option:

Option A: The TTL defines when the token will expire and be revoked The TTL is the current lifespan of a token before it expires. For example, a token with a TTL of 24h (vault token create -ttl=24h) expires 24 hours from creation unless renewed. Upon expiry, Vault revokes it automatically. This is a fundamental property of TTL, making this statement accurate. Correct. Vault Docs Insight: “The TTL defines when the token will expire… if it reaches its TTL, it will be revoked by Vault.” (Core definition.)

Option B: The TTL defines when another token will be generated TTL governs expiration, not token generation. New tokens are created explicitly (e.g., vault token create) or via auth methods, not automatically by TTL. This misunderstands TTL’s role—it’s about expiry, not regeneration. Incorrect. Vault Docs Insight: “TTL is the duration until expiration… New tokens are not generated by TTL.” (No generation link.)

Option C: The Max TTL defines the timeframe for which a token cannot be used This is backwards. Max TTL sets the upper limit a token can exist through renewals, not a period of inactivity or unusability. A token with a Max TTL of 72h can be renewed up to 72 hours from creation, after which it’s revoked. This option inverts the concept. Incorrect. Vault Docs Insight: “Max TTL defines the maximum timeframe for which the token can be renewed… not a usage restriction.” (Opposite meaning.)

Option D: The Max TTL defines the maximum timeframe for which a token can be renewed Max TTL caps the total lifespan of a token, including renewals. For example, a token with TTL=24h and Max TTL=72h (vault token create -ttl=24h -explicit-max-ttl=72h) can be renewed twice (24h + 24h + 24h = 72h) before hitting the limit. Beyond 72h, renewal fails, and it expires. This is the precise definition of Max TTL. Correct. Vault Docs Insight: “The Max TTL defines the maximum timeframe for which the token can be renewed… Once reached, it cannot be renewed further.” (Exact match.)

Detailed Mechanics:

TTL is dynamic, decreasing as time passes (e.g., vault token lookup shows ttl: 23h59m50s after 10 seconds). Renewal (vault token renew) resets TTL to its original value (e.g., 24h), but only up to Max TTL from creation. System defaults (768h/32 days) apply unless overridden. Periodic tokens (-period=24h) renew indefinitely within their period, ignoring Max TTL unless explicitly set.

Real-World Example:

Create: vault token create -ttl=1h -explicit-max-ttl=3h. After 1h, TTL=0, renewable. Renew at 2h total, TTL=1h again. At 3h total, Max TTL hits—revoked. Contrast with TTL-only: vault token create -ttl=1h, renewable up to system Max TTL (768h).

Overall Explanation from Vault Docs:

“The TTL defines when the token will expire… If it reaches its TTL, it will be immediately revoked by Vault. The Max TTL defines the maximum timeframe for which the token can be renewed… Once the Max TTL is reached, the token cannot be renewed any longer and will be revoked.” These attributes ensure controlled token lifecycles.

Comprehensive and Detailed in Depth Explanation:

A: Insecure and manual; not a Vault feature. Incorrect.

B: Auto-auth doesn’t replicate tokens/leases. Incorrect.

C: DR replication mirrors tokens and leases; promotion enables failover. Correct.

D: Performance replication doesn’t replicate tokens fully. Incorrect.

Overall Explanation from Vault Docs:

“Disaster Recovery replication mirrors tokens and leases… Promote the secondary during an outage.”