• Home
  • Articles
  • Ultimate Guide to Prepare PT-AM-CPE Certification Exam for Ping Identity Certifications in 2026 [Q12-Q37]

Ultimate Guide to Prepare PT-AM-CPE Certification Exam for Ping Identity Certifications in 2026 [Q12-Q37]

Share

Ultimate Guide to Prepare PT-AM-CPE Certification Exam for Ping Identity Certifications in 2026

Use Real PT-AM-CPE Dumps - Ping Identity Correct Answers updated on 2026

NEW QUESTION # 12
During the PingAM startup process, what is the location and name of the file that the PingAM bootstrap process uses to connect to the configuration Directory Services repository?

  • A. <user-home-dir>/.openam/config/boot.json
  • B. <user-home>/<am-instance-dir>/boot.json
  • C. /path/to/tomcat/<tomcat-instance-dir>/webapps/<am-instance-dir>/boot.json
  • D. <user-home-dir>/<am-instance-dir>/config/boot.json

Answer: B

Explanation:
In PingAM 8.0.2, especially when utilizing File-Based Configuration (FBC), the startup sequence relies on a "bootstrap" phase to locate the system's configuration. According to the "Installation Guide" and "Configuration Directory Structure," the primary file involved in this process is named boot.json.
The boot.json file contains the essential connection details required for the AM binaries to find and unlock the configuration store (usually PingDS). This includes the LDAP host, port, bind DN, and references to the secret stores needed to decrypt the configuration.
The location of this file is determined by the Configuration Directory path specified during the initial setup. By default, PingAM creates its configuration directory in the home directory of the user running the web container. The standard path structure is <user-home>/<am-instance-dir>/. Therefore, the boot.json file is located at the root of this instance directory: <user-home>/<am-instance-dir>/boot.json.
Options A and D are incorrect because they place the file inside a /config subdirectory; while AM has many config files in subdirectories, the boot.json sits at the root to be accessible as the first point of entry.
Option B is incorrect because it suggests the file is stored within the Tomcat webapps folder. PingAM specifically avoids storing configuration data within the web application binaries to ensure that configuration persists even if the .war file is deleted or redeployed.
Understanding the location of boot.json is vital for DevOps engineers who need to automate the deployment of PingAM using tools like Amster or when troubleshooting a "Failed to connect to the configuration store" error during server startup.


NEW QUESTION # 13
A multi-server PingAM deployment is scheduled for upgrade. What measure can be implemented to prevent external user access during this process?

  • A. Disable access from the firewall
  • B. Shut down the PingDS instances
  • C. Shut down the PingAM instances
  • D. Disable access from the load balancer

Answer: D

Explanation:
According to the PingAM 8.0.2 Upgrade Guide and best practices for high-availability environments, performing an upgrade on a multi-server cluster requires a controlled redirection of traffic. While several methods can technically stop traffic, the load balancer is the primary tool for managing availability during maintenance.
In a production environment, PingAM instances are typically situated behind a load balancer that performs health checks and distributes user requests. By disabling access from the load balancer (specifically, by draining connections or marking nodes as "out of service"), administrators can gracefully prevent new external users from reaching the servers undergoing the upgrade. This approach is superior to shutting down the PingAM instances (Option A) immediately, as it allows existing sessions to complete their current operations or be handled by other nodes in the cluster if a "rolling upgrade" strategy is being used.
Shutting down the PingDS instances (Option B) is dangerous, as the directory service is required by PingAM for both configuration and user data; losing the data store while the AM application is still active can lead to severe system errors and data corruption. While a firewall (Option C) can block traffic, it is generally a "blunt instrument" that does not provide the sophisticated session management or health-probe handling that a load balancer offers. The load balancer allows for a "Maintenance Page" to be displayed to users, providing a better user experience during the downtime. Therefore, for a professional multi-server upgrade, managing the traffic flow at the load balancer layer is the verified best practice in PingAM 8 documentation.


NEW QUESTION # 14
To ensure the user's full name is displayed on the consent screen for an OpenID Connect application, which string should be added into the Support Claims property on the OpenID Connect tab page of the OAuth2 Provider service in PingAM?

  • A. name|en|given_name+' '+family_name
  • B. full_name|Full name
  • C. name|en|Full name
  • D. Full name|en|name

Answer: C

Explanation:
When a client requests an OpenID Connect (OIDC) scope (like profile), PingAM 8.0.2 may present a Consent Screen to the user, asking permission to share specific claims. To make this screen user-friendly, PingAM allows administrators to map technical claim names to human-readable labels and specify localizations.
According to the PingAM documentation on "Supported Claims" in the OAuth2/OIDC Provider settings:
The format for the Supported Claims property entry is:
ClaimName|Locale|DisplayName
In this syntax:
ClaimName: The technical OIDC claim (e.g., name, email, given_name).
Locale: The ISO language code (e.g., en, fr).
DisplayName: The text that will actually appear on the UI (the "Full name" label).
Therefore, the string name|en|Full name (Option A) is the correct configuration.
Option B is incorrect because it reverses the technical name and the display name.
Option C is incorrect as it lacks the required locale component and uses full_name (which is not the standard OIDC claim name; the standard is name).
Option D attempts to perform a logic operation (+) within a configuration field where only static mapping strings are allowed. Claim composition (concatenating first and last names) is handled by the OIDC Claims Script, not by the Supported Claims UI property.


NEW QUESTION # 15
Which OpenID Connect grant flow is best to use when the relying party knows the user's identifier and wishes to gain consent for an operation from the user by means of a separate authentication device?

  • A. Authorization code grant
  • B. Implicit grant
  • C. Backchannel request grant
  • D. Hybrid grant

Answer: C

Explanation:
The scenario described-where a client (Relying Party) already knows who the user is and needs them to authorize an action on a different device-is the primary use case for the Backchannel Request Grant, also known as Client-Initiated Backchannel Authentication (CIBA).
According to the PingAM 8.0.2 documentation on "OpenID Connect Grant Flows" and "CIBA":
Unlike traditional OIDC flows (Implicit, Authorization Code, Hybrid) that require a browser redirect (front-channel) to the OpenID Provider, CIBA is a back-channel flow. It is designed for "decoupled" authentication.
The Trigger: The RP sends a request directly to PingAM's backchannel authentication endpoint, providing a user identifier (like a username or email).
The Consent: PingAM then reaches out to the user's Authentication Device (usually a smartphone with the ForgeRock Authenticator app) via a Push notification.
The Approval: The user approves the request on their phone.
The Tokens: The RP, which has been polling PingAM or waiting for a callback, receives the ID Token and Access Token.
Common real-world examples include a bank teller initiating a login on their terminal which the customer approves on their mobile banking app, or a call center agent verifying a caller's identity via a push notification. Option D is the only flow that supports this decoupled, separate-device architecture. Options A, B, and C are all "Front-channel" flows that require the user's interaction to happen in the same browser session that initiated the request.


NEW QUESTION # 16
What is the purpose of the extended metadata in PingAM?

  • A. It specifies the certificates and keys for the SAML2 entity
  • B. It specifies additional information about a SAML2 entity specific to PingAM
  • C. It specifies the policy to invoke during SAML2 federation
  • D. It is a standard way to communicate supported SAML2 features

Answer: B

Explanation:
In SAML 2.0 Federation, there is a standard XML schema (defined by OASIS) that all vendors use to describe an Identity Provider (IdP) or Service Provider (SP). This is known as "Standard Metadata." However, standard metadata does not include every configuration option required to run a sophisticated Access Management server.
PingAM 8.0.2 uses Extended Metadata to store implementation-specific settings that fall outside the OASIS SAML 2.0 specification. According to the "SAML 2.0 Guide," extended metadata is stored as a separate configuration file (or JSON entry in newer versions) and includes parameters such as:
Identity Store Mapping: Which attribute in the local datastore matches the SAML NameID.
Session Information: How AM should handle the session lifecycle after a successful SAML assertion.
Attribute Mapping: Detailed instructions on how to transform local LDAP attributes into SAML attributes (and vice versa).
Authentication Trees: Which specific tree should be triggered when a request arrives at the IdP.
Option D is the correct description. Option C is incorrect because extended metadata is not a standard way to communicate features; in fact, other SAML products (like ADFS or Okta) cannot read or process PingAM's extended metadata. Option A is incorrect because basic certificates/keys are usually part of the standard metadata (KeyDescriptor), and Option B is incorrect because SAML federation usually triggers authentication journeys or attribute mapping rather than a standard authorization "policy."


NEW QUESTION # 17
What does the acronym SAML stand for?

  • A. Scoped Assertion Markup Language
  • B. Secure Assertion Markup Language
  • C. Security Assertion Markup Language
  • D. Strong Assertion Markup Language

Answer: C

Explanation:
As defined in the PingAM 8.0.2 documentation under "Introduction to SAML 2.0," the acronym SAML stands for Security Assertion Markup Language. It is an XML-based framework specifically designed for communicating user authentication, entitlement, and attribute information between distinct entities. In a typical federation scenario, these entities are the Identity Provider (IdP), which asserts the identity of the user, and the Service Provider (SP), which consumes the assertion to grant access to resources.
SAML is governed by OASIS and has become the industry standard for cross-domain Single Sign-On (SSO). The "Security" aspect of the name refers to the cryptographic methods used to ensure the integrity and confidentiality of the assertions. "Assertion" refers to the specific statements made by the IdP about a subject (usually a user). These assertions can include Authentication Statements (proving the user logged in), Attribute Statements (providing data like email or group membership), and Authorization Decision Statements (indicating what the user is permitted to do). PingAM 8.0.2 fully supports the SAML 2.0 core specifications, protocols, bindings, and profiles. Understanding this fundamental terminology is essential for administrators configuring "Circle of Trust" (CoT) environments or importing metadata from external partners, as the XML namespaces and schema definitions consistently reference the "urn:oasis:names:tc:SAML:2.0" identifier.


NEW QUESTION # 18
If the session cookie is configured as a domain based cookie for the am.example.com domain, in which of the following domains is the cookie visible?
A . example.com
B . am.example.com
C . sub.am.example.com
D . login.am.example.com

  • A. B only
  • B. B and D
  • C. B and C
  • D. A and B

Answer: C

Explanation:
This question tests the understanding of Session Cookie Domains and browser behavior in a PingAM 8.0.2 deployment. According to the "Secure Session Cookies" documentation, the Cookie Domain setting in a realm determines the scope of the SSO token.
Standard browser cookie rules (RFC 6265) dictate that a cookie set for a specific domain is visible to that domain and all of its subdomains. However, a cookie is not visible to a parent domain or a "sibling" domain.
In this scenario, the cookie is set for am.example.com:
A . example.com: This is the parent domain. A cookie set for am.example.com is not visible here. To make it visible to example.com, the cookie domain would have to be explicitly set to .example.com.
B . am.example.com: The cookie is directly set for this domain, so it is obviously visible.
C . sub.am.example.com: This is a subdomain of am.example.com. Under standard cookie rules, it will receive the cookie.
D . login.am.example.com: While this is also a subdomain, the question implies a specific selection.
Looking at the provided options (B and C), Option C accurately reflects the inheritance rule where the domain itself and its immediate sub-levels are covered. While login.am.example.com (Option D) is technically also a subdomain, the standard documentation examples for "Cross-domain" or "Sub-domain" visibility typically emphasize the relationship between the primary AM host and its child applications. Therefore, the combination of B and C is the most accurate representation of how the browser handles the scope of an am.example.com cookie.


NEW QUESTION # 19
Which statements are correct in relation to an OAuth2 token exchange impersonation pattern?
A) The client may want to act as the subject on another service.
B) The client is used by a subject to act on behalf of another subject.
C) The requested token exchange involves a subject token only.
D) The requested token exchange involves a subject and actor token.

  • A. A and C only
  • B. B and D only
  • C. B and C only
  • D. A and D only

Answer: D

Explanation:
In PingAM 8.0.2, the OAuth 2.0 Token Exchange (RFC 8693) supports two primary patterns: delegation and impersonation. Understanding the difference between these is critical for secure microservices architecture.
According to the "Demonstrate Impersonation" section of the PingAM documentation, impersonation is a pattern where a client (the "Actor") acts as another identity (the "Subject") in a way that the downstream resource server sees only the Subject's identity.
Statement A is correct: In an impersonation flow, the client (which has been authorized by the user or is a trusted service) requests a token where it effectively "becomes" the subject to interact with another service. The downstream service treats the request as if it were coming directly from the subject, often with the same set of permissions.
Statement D is correct: To perform a token exchange for impersonation, the client must provide specific parameters to the /oauth2/access_token endpoint. It provides the subject_token (representing the identity to be impersonated) and the actor_token (representing the identity of the client/service that is performing the impersonation). PingAM validates both tokens to ensure the "Actor" has the permission to impersonate the "Subject." Why other statements are incorrect: Statement B describes delegation (where an actor acts on behalf of a subject but maintains their own identity in the act claim). Statement C is incorrect because a token exchange inherently requires proving who the requester is (the actor) and whom they represent (the subject). Without both tokens, the AM server cannot verify the authorization relationship required for impersonation. Therefore, the combination of A and D accurately reflects the impersonation pattern in PingAM 8.0.2.


NEW QUESTION # 20
Which statement differentiates the ForgeOps Cloud Deployment Model (CDM) from the Cloud Developer Kit (CDK) deployment?

  • A. Supports deployment with Google Kubernetes Engine (GKE), Amazon Elastic Kubernetes Service (EKS), or Azure Kubernetes Service (AKS) clusters
  • B. Provides replicated directory services
  • C. Fully integrated PingAM, PingIDM, and PingDS installations
  • D. Deployment generates random secrets

Answer: B

Explanation:
In the Ping Identity ForgeOps methodology for version 8.0.2, there are two primary deployment patterns used in Kubernetes: the Cloud Developer Kit (CDK) and the Cloud Deployment Model (CDM).
CDK (Cloud Developer Kit): This is intended for development and demonstration purposes. It is a "minimized" version of the platform. Crucially, in the CDK, the PingDS (directory service) is typically deployed as a single instance. It lacks the redundancy and replication required for production, as the goal is to reduce resource consumption on a developer's machine or a small test cluster.
CDM (Cloud Deployment Model): This is the reference architecture for production-grade environments. The CDM is designed for high availability and scale. According to the "ForgeOps Documentation," the primary differentiator is that the CDM provides replicated directory services. In a CDM deployment, PingDS is deployed in a multi-instance, replicated state (using a Kubernetes StateFulSet) to ensure that if one DS pod fails, the session and configuration data remain available.
While both models support major cloud providers like GKE, EKS, and AKS (Option B), generate random secrets (Option A), and provide integrated AM/IDM/DS stacks (Option D), the presence of multi-node replication in the directory layer is the definitive technical boundary between the "Developer" kit and the "Production" model.


NEW QUESTION # 21
Which of the following best represents the information that is typically contained in the debug output?

  • A. The component that created the debug entry, A header with the time and date, The running thread ID, The debug level, A general message, Optional stack trace
  • B. The component that created the debug entry, A header with the time and date, The running thread ID, A general message, Optional stack trace
  • C. The component that created the debug entry, A header with the time and date, The debug level, A general message, Optional stack trace
  • D. A header with the time and date, The running thread ID, The debug level, A general message, Optional stack trace

Answer: A

Explanation:
In PingAM 8.0.2, troubleshooting complex issues often requires moving beyond audit logs to Debug Logs. These logs capture the internal operations of the AM engine and its various components (e.g., Authentication, Core Token Service, Session Management).7 According to the "Debug Logging" section of the PingAM 8.0.2 Maintenance Guide, the standard format for a debug log entry is designed to provide maximum context for support engineers and developers. A typical entry includes:
Time and Date Header: Precise timestamp of when the event occurred.
The Component (Category): Identifies which part of the code issued the message (e.g., amAuth, amSession, amOAuth2).
The Debug Level: Indicates the verbosity/severity, such as ERROR, WARNING, INFO, MESSAGE, or OFF.
The Thread ID: Crucial for multi-threaded environments like Tomcat, allowing administrators to trace a single user's request across multiple log entries.
The Message: A descriptive string explaining the internal operation or the error encountered.
Stack Trace: If the entry is recording an exception, a full Java stack trace is optionally included to pinpoint the exact line of code where the failure occurred.
Option A is the most complete and accurate representation of this structured output. Options B, C, and D are incorrect because they omit essential troubleshooting fields like the Thread ID or the Component name, which are necessary for correlating logs in a high-concurrency production environment. Understanding this structure is fundamental for any administrator using tools like ssoadm or the REST API to capture and analyze troubleshooting information.


NEW QUESTION # 22
Which of the following options represents best practice for an implementation that configures an ID token in a subject condition for policies validating the token's claims?

  • A. Policy evaluation only validates the claims, not the ID token. The ID token should be validated before making the policy evaluation request
  • B. Policy evaluation validates the claims and the ID token. There is no need to validate the ID token before the policy is evaluated
  • C. Policy evaluation only validates the claims, not the ID token. The ID token should be validated after making the policy evaluation request
  • D. Policy evaluation only validates the claims, not the ID token. There is no need to validate the ID token that was obtained before the policy is evaluated

Answer: A

Explanation:
In PingAM 8.0.2, Authorization Policies can be configured to use complex conditions to determine if access should be granted. When a policy uses a Subject Condition based on an OpenID Connect (OIDC) ID Token, the policy engine looks for specific claims within that token (such as group membership or a specific user ID).
According to the "Authorization and Policy Evaluation" best practices, it is crucial to understand the separation of concerns between the Policy Decision Point (PDP) and the client. The PingAM policy engine is designed to evaluate logic-it checks if claimX == valueY. However, the policy engine typically does not perform a full cryptographic validation of the ID token's signature every time it evaluates a condition, especially if the token is passed as a string in the evaluation request.
Therefore, the best practice is as follows:
The client application or the PEP (Policy Enforcement Point) must validate the ID token (ensuring it is signed by a trusted provider, has not expired, and contains the correct audience) before sending the claims to the AM policy service for evaluation. If an unvalidated or forged token is used to supply claims for a policy request, and the policy engine assumes the input is "trusted," it could result in unauthorized access.
By validating the token first (Option C), the implementation ensures that only legitimate identity data is processed by the authorization logic. Option D is incorrect because the policy engine's primary role is decision-making based on presented attributes, not act as a full OIDC validation service during a REST evaluation call. Option B is a security risk as it ignores the necessity of cryptographic proof of identity.


NEW QUESTION # 23
Which statement does not reflect best practice when configuring a PingAM cluster for secure communication with external servers?

  • A. Create a new truststore with the certificates needed in the environment, and configure the container to use it
  • B. Don't add PingDS instances certificates to the JVM container truststore
  • C. Create a new truststore using a copy of the JVM container truststore and add the PingDS instances certificates to the new truststore
  • D. Create the new truststore as a copy of the JVM container truststore to isolate the PingAM truststore from changes to the JVM container's truststore when the JVM container's truststore is updated

Answer: D

Explanation:
When configuring secure communication (LDAPS, HTTPS) in PingAM 8.0.2, managing the Truststore is a critical security task. The truststore contains the public certificates (trust anchors) of the servers PingAM needs to communicate with, such as PingDS or external Identity Providers.
The PingAM "Secure Network Communication" documentation outlines several best practices:
Avoid Modifying the JVM Truststore: One should not add internal certificates (like those for PingDS) to the default JVM cacerts file (Option D is a best practice). This prevents pollution of the system-wide Java environment.
Use a Dedicated Truststore: Creating a fresh, minimal truststore containing only necessary certificates (Option B and C) ensures a "least privilege" approach to trust.
Why Statement A is NOT a best practice: Statement A suggests that you should copy the JVM truststore to isolate it from changes made to the JVM container's truststore. In a production security context, this is a dangerous anti-pattern. The JVM's default truststore (e.g., cacerts) is frequently updated by Java maintainers and OS vendors to include new Root CAs and, more importantly, to remove/revoke compromised or untrustworthy CAs. By making a static copy to "isolate" AM from these updates, an administrator inadvertently keeps obsolete or insecure certificates in AM's trust list while missing out on critical security updates provided by the platform.
Best practice dictates that AM should point to a truststore that is intentionally managed. If isolation is needed, it should be achieved by creating a new store for internal certificates and potentially using the -Djavax.net.ssl.trustStore property to manage the hierarchy, rather than cloning the system-wide CA bundle to avoid "changes." Therefore, Option A is the correct answer as it describes a maintenance and security risk.


NEW QUESTION # 24
Which OAuth2 flow is most appropriate for a microservice requesting an access token?

  • A. Resource owner flow
  • B. Authorization code flow
  • C. Implicit grant flow
  • D. Client credentials flow

Answer: D

Explanation:
In PingAM 8.0.2, choosing the correct OAuth2 grant flow depends entirely on the type of client and the nature of the resource access. For a microservice (a machine-to-machine scenario), the Client Credentials Flow (defined in RFC 6749) is the industry-standard and documented best practice.
A microservice is categorized as a Confidential Client because it runs on a secure server where it can safely store its own credentials (client_id and client_secret). In a microservice-to-microservice interaction, there is no "end-user" present to provide consent or enter a password. Instead, the microservice authenticates as itself to the PingAM token endpoint.
According to the PingAM "OAuth 2.0 Grant Flows" documentation:
The microservice sends a POST request to the /oauth2/access_token endpoint.
The request includes the grant_type=client_credentials parameter along with the client's own authentication (such as Basic Auth with secret, or mTLS).
PingAM validates the client's credentials and scopes.
Since this is a machine-to-machine flow, PingAM bypasses the user authorization (consent) step and issues an Access Token directly to the service.
Why other options are incorrect:
Implicit flow (A) and Authorization code flow (B) are designed for scenarios where a human user is present to authenticate and authorize access.
Resource owner flow (D) (also known as the Password grant) requires the service to handle a user's cleartext credentials, which is a major security risk and is deprecated in modern security architectures.
The Client Credentials flow ensures that microservices can securely obtain the tokens necessary to communicate with other protected APIs within the ecosystem without requiring human intervention.


NEW QUESTION # 25
When removing a forgeops deployment created with the Cloud Developer Kit (CDK) with the following command:
$ /path/to/forgeops/bin/forgeops delete
What components are removed from the deployment?

  • A. The Ping Identity Platform (CDK artifacts, PVCs, and the Access Management and Identity Management configurations) and ingress controller pods
  • B. The Ping Identity Platform (CDK artifacts, PVCs, and the Access Management and Identity Management configurations) pods
  • C. The Ping Identity Platform (CDK artifacts, PVCs, and the Access Management and Identity Management configurations), ingress controller, DS operator, certificate manager, and secret agent pods
  • D. The Ping Identity Platform (CDK artifacts, PVCs, and the Access Management and Identity Management configurations), certificate manager, and secret agent pods

Answer: B

Explanation:
The forgeops command-line tool is used to manage the lifecycle of the Ping Identity Platform in Kubernetes environments.9 When using the Cloud Developer Kit (CDK) for version 8.0.2, the delete subcommand is used to tear down the environment.
According to the "ForgeOps CLI Reference" and "CDK Shutdown and Removal" documentation:
The forgeops delete command (without additional flags like --force or specific component names) is designed to remove the Ping Identity Platform pods. This includes the core applications like PingAM, PingIDM, and PingDS, as well as the specialized UI pods (login-ui, etc.). It also removes the standard CDK artifacts and configuration manifests associated with that specific namespace.
However, the command follows a "safe delete" philosophy regarding infrastructure-level components:
Ingress Controllers, Certificate Managers (cert-manager), and the DS Operator are considered part of the "Base" or "Infrastructure" layer. These are typically installed once per cluster or namespace and are shared across multiple deployments. The forgeops delete command does not remove these by default, as doing so could disrupt other services.
PVCs (Persistent Volume Claims) and Secrets are also preserved unless the --force or -f flag is explicitly added to the command.
Thus, the answer is D. The command focuses strictly on the platform pods and their immediate deployment artifacts. If a developer wishes to perform a "deep clean" that removes the ingress and operators, they would need to use more specific commands like forgeops delete base or kubectl commands.10 This distinction is vital for developers to avoid accidentally deleting shared cluster infrastructure when they only intended to restart the Ping platform.


NEW QUESTION # 26
What is session denylisting used for?

  • A. Keeping track of session inactivity
  • B. Keeping track of logged out sessions
  • C. Keeping track of restricted sessions
  • D. Keeping track of absolute session timeouts

Answer: B

Explanation:
Session Denylisting is a critical security feature in PingAM 8.0.2, primarily used when a realm is configured for client-side sessions.9 In a client-side session model, the session state is stored in a signed and encrypted JWT within the user's browser cookie rather than in the server's memory or the Core Token Service (CTS).10 Because the server does not "own" the session state, a logout event typically only involves deleting the cookie from the browser. However, if a malicious actor had previously copied that cookie, they could still use it until it naturally expires.
To solve this, PingAM uses Session Denylisting to keep track of logged out sessions.11 When a user logs out, or when a session is invalidated (e.g., during a session upgrade or administrative action), AM records the session identifier in a denylist stored within the Core Token Service (CTS).12 For every subsequent request, AM checks the incoming client-side session token against this denylist.13 If the session ID is found in the denylist, AM rejects the token as invalid, even if the cryptographic signature is correct and the expiration time has not passed.
The documentation emphasizes that this feature is essential for "tracking session logouts across multiple AM servers" in a cluster. Without denylisting, there would be no way to perform a "global logout" for client-side sessions that is immediately effective across all nodes.14 Administrators can configure properties such as the Denylist Purge Delay (to account for clock skew) and the Denylist Poll Interval (to balance security speed with system performance).15 By effectively managing the lifecycle of revoked tokens, session denylisting ensures that a logout is a cryptographically and operationally certain event.


NEW QUESTION # 27
Which of the following statements about the PingAM tree designer is not true?

  • A. The PingAM tree designer is able to display custom and Ping Identity Marketplace nodes to use together with shipped nodes
  • B. The PingAM tree designer lets you terminate the tree with a success node, a failure node, or a node linking to another authentication tree
  • C. The PingAM tree designer lets you create complex authentication by linking nodes together, creating loops, and nesting nodes within a tree
  • D. The PingAM tree designer lets you integrate inner trees in the authentication flow

Answer: C

Explanation:
The Tree Designer in PingAM 8.0.2 is a visual, drag-and-drop tool used to build sophisticated login journeys. While it is highly flexible, it follows specific structural rules to ensure the authentication engine can execute the logic predictably.
Analysis of the statements:
Statement A is true: Trees must terminate in an outcome. Success and Failure nodes are standard. Additionally, the Inner Tree Evaluator node allows one tree to hand off processing to another "child" tree.
Statement C is true: The designer is extensible. Administrators can develop their own Java or Scripted nodes, and the Ping Identity Marketplace provides a wide range of third-party nodes (e.g., for biometric providers or specialized risk engines) that appear in the designer palette once installed.
Statement D is true: "Inner trees" are a supported concept, allowing for modularity where common logic (like MFA) can be built once and called from multiple parent trees.
Statement B is the "not true" statement. While the designer allows for complex logic and loops (e.g., looping back to a username prompt if a password is wrong), it does not support nesting nodes within a tree. In PingAM architecture, nodes are atomic components placed on a flat canvas. You cannot "nest" a node inside another node's configuration in the visual designer. Complexity is achieved through the branching and linking of these atomic nodes. If logic needs to be "nested" or grouped, it is done by creating a separate tree and calling it as an Inner Tree. Understanding this structural limitation is key for architects designing modular authentication frameworks.


NEW QUESTION # 28
Which feature of PingAM protects against cookie hijacking in a cross-domain single sign-on environment?

  • A. Bound tokens
  • B. Restricted tokens1
  • C. Lockout tokens
  • D. Random tokens

Answer: B

Explanation:
In a Cross-Domain Single Sign-On (CDSSO) environment, PingAM must manage session cookies across multiple distinct DNS domains.2 By default, a standard SSO token could potentially be stolen and reused by a malicious actor to gain access to other domains within the same realm.3 To mitigate this specific threat, PingAM 8.0.2 utilizes Restricted Tokens.4 According to the documentation on "Securing CDSSO session cookies," a restricted token is a unique SSO token issued for each specific application or policy agent after successful user authentication.5 When CDSSO is active with cookie hijacking protection enabled, PingAM issues a "master" SSO token for the domain where AM resides and separate restricted tokens for the other fully qualified domain names (FQDNs) where web or Java agents are located.6 The restricted token is "restricted" because it is inextricably linked to the specific agent and application that initiated the redirection. Internally, AM stores a correlation between the master session and these restricted tokens.7 If an attacker attempts to hijack a restricted token and use it to access a different application or a different domain, the AM server performs a validation check on the constraint associated with the token (such as the agent's DN or IP). If the request does not originate from the authorized entity, a security violation is triggered, and access is denied. This mechanism ensures that even if a cookie is stolen in one domain, its utility is confined strictly to that domain and cannot be used for "lateral movement" across the enterprise's other protected resources. It is important to note that restricted tokens require server-side sessions to function; they are not supported for client-side (JWT-based) sessions.8


NEW QUESTION # 29
A non-authenticated user requests a resource protected by PingGateway or a Web Agent. Put the following events of the authentication lifecycle in chronological order:
User answers the "questions asked" (callbacks) by PingAM.
User tries to access a resource protected by PingGateway or a Web Agent.
Session reaches a timeout value or user logs out.
PingGateway or the Web Agent validates the session.
User is redirected to the authentication user interface of PingAM.
User is redirected to the resource.

  • A. 2-1-5-6-4-3
  • B. 2-5-1-6-3-4
  • C. 2-1-4-3-5-6
  • D. 2-5-1-6-4-3

Answer: D

Explanation:
The authentication lifecycle in a Ping Identity environment follows a strict sequence to ensure that only authorized users can access protected resources. This process is governed by the interaction between a Policy Enforcement Point (PEP), such as a Web Agent or PingGateway, and the Policy Decision Point (PDP), which is PingAM.
Following the chronological flow according to the PingAM 8.0.2 "Introduction to Authentication" and "Web Agent User Guide":
Step 2: The process begins when an unauthenticated user attempts to access a protected URL.
Step 5: The Agent/PingGateway intercepts the request, detects the absence of a valid session cookie, and redirects the user to the PingAM login URL (the UI).
Step 1: The user interacts with the AM UI, providing the necessary credentials or answering the "callbacks" (username, password, MFA) defined in the authentication tree.
Step 6: Upon successful authentication, PingAM issues a session token and redirects the user back to the original resource they were trying to access.
Step 4: The Agent/PingGateway receives the request again, but this time it contains a session token. The agent then validates the session with PingAM to ensure it is still active and possesses the correct permissions.
Step 3: Finally, the lifecycle ends when the session expires due to inactivity (Idle Timeout), reaches its Max Session Time, or the user explicitly logs out.
Sequence 2-5-1-6-4-3 (Option B) accurately captures this "Round-Trip" nature of modern web authentication. Options A and D are incorrect because they place the callback interaction before the initial redirect or the resource access. Option C is incorrect because it suggests the session reaches a timeout before the agent has a chance to validate the session for the current request.


NEW QUESTION # 30
To protect against cross-site request forgery attacks, a default PingAM installation requires that some requests, such as POST requests, include:

  • A. If-Match: _rev header
  • B. X-OpenAM-Username header
  • C. X-OpenAM-Password header
  • D. X-Requested-With or Accept-API-Version header

Answer: D

Explanation:
Cross-Site Request Forgery (CSRF) is an attack where a malicious site sends a request to PingAM using the victim's authenticated browser session. Because standard HTML forms and cross-site requests cannot easily set custom HTTP headers, requiring a specific header is an effective defense for REST APIs.
According to the PingAM "Security" documentation and the "REST API" reference:
By default, PingAM 8.0.2 enforces a CSRF filter on its REST endpoints (such as /json/authenticate or /json/users). For any "state-changing" request (like a POST, PUT, or DELETE), the client must prove the request is intentional and not a forged browser-driven request. This is achieved by requiring at least one of the following headers:
X-Requested-With: Commonly used by AJAX libraries like jQuery. Its presence indicates the request was made via a script, which is generally not possible for a standard cross-site CSRF attack.
Accept-API-Version: This header serves two purposes. First, it ensures the client is targeting a specific version of the PingAM REST API (e.g., resource=2.0, protocol=1.0). Second, since custom headers cannot be set in simple cross-site <form> submissions, it acts as a CSRF token.
If a POST request is sent to the REST API without one of these headers, PingAM will reject the request with a 403 Forbidden error, even if the user has a valid session cookie.
Option B (If-Match: _rev) is used for concurrency control (preventing "lost updates" in IDM or AM configuration), but it is not the primary CSRF defense. Options A and D are headers sometimes used for "Zero-Page Login" or legacy authentication, but they do not provide protection against CSRF for the general REST API. Therefore, the combination of X-Requested-With or Accept-API-Version is the correct answer for default CSRF protection in PingAM 8.0.2.


NEW QUESTION # 31
When developing a PingAM may act script for OAuth2 token exchange patterns, which variables are made available for use in the script?

  • A. clientProperties, identity, logger, requestProperties, scopes, scriptName, session, token
  • B. clientProperties, identity, logger, requestProperties, scopeList, scriptName, session, requestedToken
  • C. clientProperties, identity, logger, requestProperties, scopes, scriptName, session, requestedToken
  • D. clientProperties, identity, logger, requestProperties, scopeList, scriptName, session, token

Answer: C

Explanation:
The OAuth2 May Act script type in PingAM 8.0.2 allows administrators to programmatically determine if a token exchange request (impersonation or delegation) should be allowed by adding a may_act claim to the token.
According to the "Scripting" and "Token Exchange Scripting API" documentation, when this script is executed, the AM engine provides a specific set of "Bindings" or variables. These allow the script to inspect the context of the request before deciding to modify the token. The documented variables for the OAuth2 May Act script are:
clientProperties: A map of the OAuth2 client's configuration properties.
identity: The identity object for the user/subject.
logger: The logging object for debugging within the script.
requestProperties: Properties of the incoming HTTP request.
scopes: The set of scopes requested or associated with the token.
scriptName: The name of the script being executed.
session: The user's SSO session (if available).
requestedToken: This is the most important variable; it represents the token being issued. Methods like .addMayAct() or .setMayAct() are called on this specific object.
Why other options are incorrect:
Option B correctly lists the bindings.
Options A and D are incorrect because they use the variable name token. While token is a common variable name in other OAuth2 script types (like the Access Token Modification script), the Token Exchange script specifically uses requestedToken to distinguish the new token from the subject_token or actor_token provided in the request.
Option C uses scopeList, which is not the standard variable name for the scopes in this specific script context; the documentation defines it as scopes.


NEW QUESTION # 32
Which of the following best describes the relationship between users and realms?

  • A. Users are never members of a realm
  • B. Users do not need to be a member of a realm
  • C. A user can be a member of exactly one realm
  • D. A user can be a member of one or more realms

Answer: D

Explanation:
In PingAM 8.0.2, Realms are the primary organizational units used to group configuration, policies, and identities.13 A common misconception is that a user is "locked" into a single realm. However, according to the "Realms" and "Identity Stores" documentation, the relationship is highly flexible.
A Realm does not actually "contain" users in a physical sense; instead, a realm is configured with one or more Identity Stores (such as an LDAP directory or a database). Multiple realms can be configured to point to the same underlying Identity Store. Therefore, if a user profile exists in an LDAP directory that is shared by "Realm A" and "Realm B," that user is effectively a member of both realms. They can authenticate to either realm and receive different policies or session properties based on the realm-specific configuration.
Key points from the documentation:
Logical Partitioning: Realms provide a way to apply different authentication logic (different trees) to the same set of users.14 Multi-tenancy: An organization can create separate realms for different departments or customer groups, even if they overlap in the back-end user database.
Identity Store Mapping: Because a realm maps to an identity store, and an identity store can be reused across realms, a user's membership is determined by where the realm is "looking" for data.
Thus, Option A is the correct description of the architecture: a user can be a member of one or more realms depending on how the administrator has mapped the identity repositories.
Would you like me to proceed with more questions, or would you like to focus on a specific area such as OAuth2 Grant Flows?


NEW QUESTION # 33
Which of the following components is used to return data to PingGateway or the agent to be included with the policy decision?

  • A. Response attributes
  • B. Resources
  • C. Subjects
  • D. Actions

Answer: A

Explanation:
When PingAM 8.0.2 evaluates an authorization policy, the primary output is a "Permit" or "Deny" decision. However, applications and Policy Enforcement Points (PEPs)-like PingGateway or a Web Agent-often require additional metadata about the user or the session to function correctly (e.g., the user's employee ID, department, or a specific preference).
According to the PingAM documentation on "Policies" and "Requesting Decisions":
The mechanism used to provide this extra information is Response Attributes. When defining a policy in the PingAM UI or via REST, an administrator can configure "Response Attributes" which map internal attributes (from the User Profile or the Session) to keys that are sent back in the policy decision payload.
How it works: If a policy is configured with a response attribute mapping uid to User-ID, when PingGateway asks "Can user X access resource Y?", PingAM responds with "Permit" AND a map containing User-ID: X.
Consumption: PingGateway or the Web Agent can then take these attributes and inject them into HTTP headers (e.g., X-User-ID) so the downstream application can consume them without having to query AM again.
Subjects (Option A), Resources (Option B), and Actions (Option D) are all input components used to define the scope of a policy; they are not used to return data to the enforcer. Only Response Attributes serve the purpose of enriching the decision response with additional context.


NEW QUESTION # 34
Which authentication node checks and validates a recovery code used during a multi-factor authentication challenge sequence?

  • A. Recovery Code Verifier node
  • B. Recovery Code Comparator node
  • C. Recovery Code Display node
  • D. Recovery Code Collector Decision node

Answer: D


NEW QUESTION # 35
Which OAuth2 web endpoint is used to validate a token?

  • A. /oauth2/userinfo
  • B. /oauth2/introspect
  • C. /oauth2/access_token
  • D. /oauth2/validate

Answer: B

Explanation:
While several endpoints in PingAM 8.0.2 interact with tokens, only one is explicitly designed for the purpose of checking the metadata and validity of an opaque or structured OAuth2 token.
According to the "OAuth 2.0 Endpoints" and "Token Introspection" documentation:
/oauth2/introspect (Option B): This is the RFC 7662-compliant endpoint. It is used by resource servers (or other authorized clients) to determine the "activeness" of a token. When a token is sent to this endpoint, PingAM returns a JSON object indicating if the token is valid, its scope, its expiration time, and the subject it represents. This is the standard way to validate tokens that are not self-validated (like opaque tokens stored in the CTS).
Why other options are incorrect:
/oauth2/userinfo (Option A): This endpoint is part of OpenID Connect. While it requires a valid token to function, its purpose is to return user claims, not to provide a "valid/invalid" metadata check of the token itself.
/oauth2/validate (Option C): This is a legacy endpoint used in older versions of the product. In PingAM 8.0.2, introspection is the standardized replacement.
/oauth2/access_token (Option D): This is the Token Endpoint used to issue tokens, not to validate them.
Using the /oauth2/introspect endpoint is a best practice for security because it allows the authorization server (PingAM) to verify that a token has not been revoked in the Core Token Service (CTS) before a resource server grants access.


NEW QUESTION # 36
In which OAuth2 grant would you find a user code?

  • A. Resource owner password credentials grant
  • B. Authorization code grant
  • C. Device flow
  • D. Client credentials grant

Answer: C

Explanation:
The Device Authorization Grant (commonly referred to as the Device Flow, RFC 8628) is a specialized OAuth 2.0 grant flow supported by PingAM 8.0.2. It is designed for internet-connected devices that either lack a browser or have limited input capabilities (e.g., Smart TVs, IoT devices, or CLI tools).
In this flow, the interaction is split between the "Device" and a "Secondary Device" (like a smartphone or laptop) that has a full browser. The User Code is a fundamental component of this process:
Device Request: The device requests a code from PingAM.
PingAM Response: AM returns a Device Code (for the device) and a User Code (a short, human-readable string like BCDF-GHJK).
User Action: The device displays the User Code and a verification URL to the user.
Authorization: The user navigates to the URL on their smartphone, logs into PingAM, and enters the User Code.
Token Issuance: Once the user authorizes the request, the device (which has been polling AM using the Device Code) receives the Access and Refresh tokens.
The User Code is unique to the Device Flow (Option D). It is not used in the Client Credentials Grant (which is machine-to-machine), the Authorization Code Grant (which uses a redirect-based code), or the Resource Owner Password Credentials Grant (which uses direct username/password submission). In PingAM 8.0.2, administrators can configure the length, character set, and expiration time of these user codes within the OAuth2 Provider settings.


NEW QUESTION # 37
......

Ping Identity Certifications -PT-AM-CPE Exam-Practice-Dumps: https://www.itexamdownload.com/PT-AM-CPE-valid-questions.html

PT-AM-CPE Premium Files Test pdf - Free Dumps Collection: https://drive.google.com/open?id=1BcsdNqUstZmPYhHRhx11WdpxZdcwVQqJ

Related Articles

more
Ping Identity PT-AM-CPE Certification Practice Exam

Copyright © 2026 ITExamDownload NETWORK CO.,LIMITED. All Rights Reserved. All trademarks used are properties of their respective owners. Privacy Policy