HCVA0-003 Exam Questions and Answers

QUESTION: 31 Exam Topic: 1, Exam Pool A

Jason has enabled the userpass auth method at the path users/.
What path would Jason and other Vault operators use to interact with this new auth method?

users/auth/
authentication/users
auth/users
users/

Answer(s): C

Explanation:

Comprehensive and Detailed in Depth
In HashiCorp Vault, authentication methods (auth methods) are mechanisms that allow users or machines to authenticate and obtain a token.
When an auth method like userpass is enabled, it is mounted at a specific path in Vault's namespace, and this path determines where operators interact with it--e.g., to log in, configure, or manage it.
The userpass auth method is enabled with the command vault auth enable -path=users userpass, meaning it's explicitly mounted at the users/ path. However, Vault's authentication system has a standard convention: all auth methods are accessed under the auth/ prefix, followed by the mount path. This prefix is a logical namespace separating authentication endpoints from secrets engines or system endpoints.
Option A: users/auth/
This reverses the expected order. The auth/ prefix comes first, followed by the mount path (users/), not the other way around. This path would not correspond to any valid Vault endpoint for interacting with the userpass auth method. Incorrect.

Option B: authentication/users
Vault does not use authentication/ as a prefix; it uses auth/. The term "authentication" is not part of Vault's path structure--it's a conceptual term, not a literal endpoint. This makes the path invalid and unusable in Vault's API or CLI. Incorrect.
Option C: auth/users
This follows Vault's standard convention: auth/ (the authentication namespace) followed by users (the custom mount path specified when enabling the auth method). For example, to log in using the userpass method mounted at users/, the command would be vault login -method=userpass - path=users username=<user>. The API endpoint would be /v1/auth/users/login. This is the correct path for operators to interact with the auth method, whether via CLI, UI, or API. Correct.
Option D: users/
While users/ is the mount path, omitting the auth/ prefix breaks Vault's structure. Directly accessing users/ would imply it's a secrets engine or other mount type, not an auth method. Auth methods always require the auth/ prefix for interaction. Incorrect.
Detailed Mechanics:
When an auth method is enabled, Vault creates a backend at the specified path under auth/. The userpass method, for instance, supports endpoints like /login (for authentication) and /users/<username> (for managing users). If mounted at users/, these become auth/users/login and auth/users/users/<username>. This structure ensures isolation and clarity in Vault's routing system. The ability to customize the path (e.g., users/ instead of the default userpass/) allows flexibility for organizations with multiple auth instances, but the auth/ prefix remains mandatory.
Overall Explanation from Vault Docs:
"When enabled, auth methods are mounted within the Vault mount table under the auth/ prefix... For example, enabling userpass at users/ allows interaction at auth/users." This convention ensures operators can consistently locate and manage auth methods, regardless of custom paths.

Reference:

https://developer.hashicorp.com/vault/docs/auth#enabling-disabling-auth-methods

Reveal Solution Next Question

QUESTION: 32 Exam Topic: 1, Exam Pool A

You want to integrate a third-party application to retrieve credentials from the HashiCorp Vault API. How can you accomplish this without having direct access to the source code?

You cannot integrate a third-party application with Vault without being able to modify the source code
Put in a request to the third-party application vendor
Instead of the API, have the application use the Vault CLI to retrieve credentials
Use the Vault Agent to obtain secrets and provide them to the application

Answer(s): D

Explanation:

Comprehensive and Detailed in Depth
Integrating a third-party application with Vault without modifying its source code requires a solution that handles authentication and secret retrieval externally, then delivers secrets in a way the application can consume (e.g., files or environment variables). Let's break this down:
Option A: You cannot integrate a third-party application with Vault without being able to modify the source code

This is overly restrictive and incorrect. Vault provides tools like the Vault Agent, which can authenticate and fetch secrets on behalf of an application without requiring code changes. The agent can render secrets into a format (e.g., a file) that the application reads naturally. This option ignores Vault's flexibility for such scenarios. Incorrect.
Option B: Put in a request to the third-party application vendor While this might eventually lead to native Vault support, it's impractical, slow, and depends on the vendor's willingness and timeline. It doesn't address the immediate need to integrate without source code access. This is a passive approach, not a technical solution within Vault's capabilities.
Incorrect.
Option C: Instead of the API, have the application use the Vault CLI to retrieve credentials The Vault CLI is designed for human operators or scripts, not seamless application integration. Third- party applications without source code modification can't invoke the CLI programmatically unless they're scripted to do so, which still requires external orchestration and isn't a clean solution. This approach is clunky, error-prone, and not suited for real-time secret retrieval in production. Incorrect. Option D: Use the Vault Agent to obtain secrets and provide them to the application The Vault Agent is a lightweight daemon that authenticates to Vault, retrieves secrets, and renders them into a consumable format (e.g., a file or environment variables) for the application. For example, if the application reads a config file, the agent can write secrets into that file using a template. This requires no changes to the application's code--just configuration of the agent and the application's environment. It's a standard, scalable solution for such use cases. Correct.
Detailed Mechanics:
The Vault Agent operates in two modes: authentication (to obtain a token) and secret rendering (via templates). For a third-party app, you'd configure the agent with an auth method (e.g., AppRole), a template (e.g., {{ with secret "secret/data/my-secret" }}{{ .Data.data.key }}{{ end }}), and a sink (e.g., /path/to/app/config). The agent runs alongside the app (e.g., as a sidecar in Kubernetes or a daemon on a VM), polls Vault for updates, and refreshes secrets as needed. The app remains oblivious to Vault, reading secrets as if they were static configs. This decoupling is key to integrating unmodified applications.
Real-World Example:
Imagine a legacy app that reads an API key from /etc/app/key.txt. The Vault Agent authenticates with Vault, fetches the key from secret/data/api, and writes it to /etc/app/key.txt. The app starts, reads the file, and operates normally--no code changes required.
Overall Explanation from Vault Docs:
"Vault Agent... provides a simpler way for applications to integrate with Vault without requiring changes to application code... It renders templates containing secrets required by your application." This is ideal for third-party or legacy apps where source code access is unavailable.

Reference:

https://developer.hashicorp.com/vault/docs/agent-and-proxy/agent

Reveal Solution Next Question

QUESTION: 33 Exam Topic: 1, Exam Pool A

What API endpoint is used to manage secrets engines in Vault?

/secret-engines/
/sys/mounts
/sys/capabilities
/sys/kv

Answer(s): B

Explanation:

Comprehensive and Detailed in Depth
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."

Reference:

https://developer.hashicorp.com/vault/api-docs/system/mounts

Reveal Solution Next Question

QUESTION: 34 Exam Topic: 1, Exam Pool A

You are deploying Vault in a local data center, but want to be sure you have a secondary Vault cluster in the event the primary cluster goes offline. In the secondary data center, you have applications that are running, as they are architected to run active/active.
Which type of replication would be best in this scenario?

Disaster Recovery replication
Performance replication

Answer(s): B

Explanation:

Comprehensive and Detailed in Depth
Vault supports two replication types: Performance Replication and Disaster Recovery (DR) Replication, each serving distinct purposes. The scenario involves an on-premises primary cluster and a secondary cluster in another data center, with active/active applications needing Vault access. Let's analyze:
Option A: Disaster Recovery replication

DR replication mirrors the primary cluster's state (secrets, tokens, leases) to a secondary cluster, which remains in standby mode until activated (promoted) during a failover. It's designed for disaster scenarios where the primary is lost, not for active/active use. The secondary doesn't serve reads or writes until promoted, which doesn't suit applications actively running in the secondary data center.
Incorrect.
Option B: Performance replication
Performance replication creates an active secondary cluster that replicates data from the primary in near real-time. It supports read operations locally, reducing latency for applications in the secondary data center, and can handle writes (forwarded to the primary). This fits an active/active architecture, providing redundancy and performance. If the primary fails, the secondary can continue serving reads (though writes need reconfiguring). Correct.
Detailed Mechanics:
Performance replication uses a primary-secondary model with log shipping via Write-Ahead Logs (WALs). The secondary maintains its own storage, synced from the primary, and can serve reads independently. Writes are forwarded to the primary, ensuring consistency. In an active/active setup, applications in both data centers can query their local Vault cluster, leveraging the secondary's read capability. DR replication, conversely, keeps the secondary dormant, requiring manual promotion, which introduces downtime unsuitable for active apps.
Real-World Example:
Primary cluster at dc1.vault.local:8200, secondary at dc2.vault.local:8200. Apps in DC2 query the secondary for secrets (e.g., GET /v1/secret/data/my-secret), avoiding cross-DC latency. If DC1 fails, DC2 continues serving cached reads until a new primary is established.
Overall Explanation from Vault Docs:
"Performance replication... allows secondary clusters to serve reads locally, ideal for active/active setups... DR replication is for failover, keeping secondaries in standby."

Reference:

https://developer.hashicorp.com/vault/docs/enterprise/replication

Reveal Solution Next Question

QUESTION: 35 Exam Topic: 1, Exam Pool A

How long does the Transit secrets engine store the resulting ciphertext by default?

24 hours
30 days
32 days
Transit does not store data

Answer(s): D

Explanation:

Comprehensive and Detailed in Depth
The Transit secrets engine in Vault is designed for encryption-as-a-service, not data storage. Let's evaluate:
Option A: 24 hours
Transit doesn't store ciphertext, so no TTL applies. Incorrect.
Option B: 30 days
No storage means no 30-day retention. Incorrect.
Option C: 32 days

This aligns with token TTLs, not Transit behavior. Incorrect.
Option D: Transit does not store data
Transit encrypts data and returns the ciphertext to the caller without persisting it in Vault. Correct.
Detailed Mechanics:
When you run vault write transit/encrypt/mykey plaintext=<base64-data>, Vault uses the named key (e.g., mykey) to encrypt the input and returns a response like vault:v1:<ciphertext>. This ciphertext is not stored in Vault's storage backend (e.g., Consul, Raft); it's the client's responsibility to save it (e.g., in a database). This stateless design keeps Vault lightweight and secure, avoiding data retention risks.
Real-World Example:
Encrypt a credit card: vault write transit/encrypt/creditcard plaintext=$(base64 <<< "1234-5678- 9012-3456"). Response: ciphertext=vault:v1:<data>. You store this in your app's database; Vault retains nothing.
Overall Explanation from Vault Docs:
"Vault does NOT store any data encrypted via the transit/encrypt endpoint... The ciphertext is returned to the caller for storage elsewhere."

Reference:

https://developer.hashicorp.com/vault/docs/secrets/transit

Reveal Solution Next Question

HashiCorp HCVA0-003 Exam (page: 7) HashiCorp Certified: Vault Associate (003) Updated on: 15-Feb-2026

QUESTION: 31 Exam Topic: 1, Exam Pool A

Explanation:

Reference:

QUESTION: 32 Exam Topic: 1, Exam Pool A

Explanation:

Reference:

QUESTION: 33 Exam Topic: 1, Exam Pool A

Explanation:

Reference:

QUESTION: 34 Exam Topic: 1, Exam Pool A

Explanation:

Reference:

QUESTION: 35 Exam Topic: 1, Exam Pool A

Explanation:

Reference:

HashiCorp HCVA0-003 Exam (page: 7)
HashiCorp Certified: Vault Associate (003)
Updated on: 15-Feb-2026