Study guide

4.3 CPM Plug-in Architecture, Process/Prompts Files & Custom Plug-in Troubleshooting

CyberArk Defender - PAM PAM-DEF

Track your progress as you read

Finished sections get a check mark.

1 Chapter 1: Vault Architecture, Network & Security

1.1 CyberArk PAS Core Architecture & Component Topology 1.2 Vault OS Hardening, Network Isolation & Port Requirements 1.3 Vault Cryptography, Encryption Keys & Master User Recovery

2 Chapter 2: Vault Configuration, Administration & CLI Utilities

2.1 Vault Server Configuration Files & DBParm.ini Tuning 2.2 Vault Administrative Utilities & PARClient Commands 2.3 Event Notification Engine (ENE) & Notification Administration

3 Chapter 3: Password Vault Web Access (PVWA) Administration

3.1 PVWA Web Portal Architecture & Interface Configuration 3.2 PVWA REST API Administration & Lifecycle Automation 3.3 PVWA Security Settings, User Access & Session Timeouts

4 Chapter 4: Central Policy Manager (CPM) Architecture & Operations

4.1 CPM Service Architecture, Logs & Multi-CPM Load Distribution 4.2 The Credential Management State Machine: Change, Verify & Reconcile 4.3 CPM Plug-in Architecture, Process/Prompts Files & Custom Plug-in Troubleshooting 4.4 Loosely Connected Devices: Rotating Laptop & Workstation Credentials

5 Chapter 5: Safe Design, RBAC & Account Governance

5.1 Enterprise Safe Architecture & Naming Conventions 5.2 Safe Permissions, Authorizations & Safe Handler Delegation 5.3 Object Versioning, Retention Policies & Storage Quotas 5.4 Mandatory Account Properties, Account Types & Linked Accounts 5.5 Vault Users, Predefined Groups & Vault-Level Authorizations

6 Chapter 6: Account Discovery & Lifecycle Workflows

6.1 Automated Account Discovery, Detection Rules & Pending Accounts 6.2 Dual Control Workflows, Multi-Level Approvals & Master Approver 6.3 Exclusive Access, One-Time Passwords (OTP) & Check-out Automation 6.4 Bulk Onboarding: Password Upload Utility, Bulk Upload REST API & AccountUploader

7 Chapter 7: Master Policy & Platform Management

7.1 Master Policy Framework & Enterprise Compliance Rules 7.2 Platform Architecture, Settings Tree & Platform Duplication 7.3 Platform Policy Overrides, Advanced Settings & Target Tuning

8 Chapter 8: Privileged Session Manager (PSM) Core Architecture

8.1 PSM Architecture, Jump Host Isolation & Service Accounts 8.2 PSM Connection Components (PSM-RDP, PSM-SSH, PSM-Web) 8.3 PSM Universal Connector Framework & Custom Integrations 8.4 Split Workflow: Separating Session Use from Credential Retrieval

9 Chapter 9: PSMP, HTML5 Gateway & Session Security

9.1 PSM for SSH (PSMP) Architecture & Unix Proxy Brokering 9.2 PSM HTML5 Gateway Architecture & Clientless Web Access 9.3 Session Recording, Storage in Recordings Safes & Vault Retention 9.4 CyberArk Remote Access (Vendor PAM): Administering Third-Party Privileged Access

10 Chapter 10: Live Session Auditing, Reporting & Privileged Threat Analytics

10.1 Live Session Monitoring, Shadowing & Active Termination 10.2 Privileged Threat Analytics (PTA) Behavioral Anomaly Detection 10.3 PTA Automated Incident Response & SIEM Integration (CEF/Syslog) 10.4 Vault Reports, Report Authorizations & the Export Vault Data (EVD) Utility

11 Chapter 11: Application Access Manager (AAM) & Secrets Management

11.1 AAM Credential Provider (CP) Architecture & Local Memory Cache 11.2 Central Credential Provider (CCP) & Web Service Integration 11.3 Application Server Credential Provider (ASCP) & Application Authentication (AppID) 11.4 Conjur Secrets Manager & Cloud-Native DevOps Workflows

12 Chapter 12: Directory Integration, Disaster Recovery & Troubleshooting

12.1 Directory Integration: LDAP Mapping, RADIUS MFA & SAML 2.0 SSO 12.2 Disaster Recovery (DR) Vault & PADR Replication Architecture 12.3 Vault Backup Operations with PAReplicate & Safe Recovery 12.4 Diagnostic Procedures, Vault/CPM/PSM Error Codes & System Recovery

4.3 CPM Plug-in Architecture, Process/Prompts Files & Custom Plug-in Troubleshooting

Key Takeaways Explain This Topic AI

The CPM plug-in framework decouples core credential policy logic from target communication protocols, relying on specialized binaries, standard out-of-the-box plug-ins, and the Terminal Plugin Controller (TPC).

Terminal Plugin Controller (CyberArk.TPC.exe) modernizes legacy PMTerminal.exe with a 64-bit .NET architecture, native SSH.NET cryptographic libraries, and enhanced regular expression parsing for Unix, network, and firewall devices.

Plug-in execution is governed by three primary components: the platform configuration file (.ini), the Process file (directing the state machine transition steps), and the Prompts file (defining regex patterns matching expected endpoint responses).

Diagnosing custom plug-in failures requires running standalone command-line simulations and analyzing PMTrace.log to identify regex mismatches, terminal pagination hangs, unexpected login banners, or protocol error codes.

Last updated: September 2026

4.3 CPM Plug-in Architecture, Process/Prompts Files & Custom Plug-in Troubleshooting

Quick Answer: The Central Policy Manager (CPM) Plug-in Architecture decouples target protocol communications from the core policy engine. While standard out-of-the-box plug-ins manage Windows (via NetAPI/RPC/WMI), Databases (via ODBC), and Cloud APIs (via REST), terminal-based systems (Unix, Linux, routers, firewalls) are managed by the modern Terminal Plugin Controller ( CyberArk.TPC.exe ) . TPC replaced the legacy 32-bit Cygwin-based PMTerminal.exe with a 64-bit .NET engine supporting modern SSH ciphers. Plug-ins are driven by three components: the platform INI file (executable binding and timeouts), the Process file (state-machine transition steps), and the Prompts file (regex patterns matching target output).

The CPM Plug-in Framework & Protocol Handlers

The Central Policy Manager does not hardcode target protocol communications into its primary service ( PasswordManager.exe ). Instead, it utilizes an extensible plug-in framework. When a credential operation (Change, Verify, Reconcile) is triggered, the CPM identifies the target platform, loads the associated plug-in binary or script, and spawns an isolated execution process.

During execution, the CPM passes account metadata, target host addresses, and credentials into the plug-in via command-line arguments, environment variables, or temporary staging files within Password Manager\Tmp . Upon completion, the plug-in returns a standard exit code to the CPM engine:

Exit Code 0 : Operation completed successfully.

Exit Code 8000–8999 : Standardized CyberArk plug-in error codes denoting authentication failures, network timeouts, prompt mismatches, or syntax rejections.

This modular architecture allows organizations to import specialized plug-ins from the CyberArk Marketplace or author completely custom plug-ins for proprietary mainframes, network appliances, and web management portals without modifying core software.

Standard Out-of-the-Box Plug-ins Across Target Platforms

CyberArk provides robust, pre-packaged plug-ins for common enterprise technologies:

1. Windows Operating Systems & Active Directory

Protocols: Microsoft RPC (TCP port 135) and SMB (TCP port 445), utilizing native Windows NetAPI functions ( NetUserChangePassword for user changes, NetUserSetInfo for administrative resets).

Active Directory: Communicates with domain controllers over LDAP (TCP port 389) or LDAPS (TCP port 636) to modify domain user attributes.

Service Account Dependencies: Detects and automatically restarts dependent Windows Services, Scheduled Tasks, and IIS Application Pools associated with rotated credentials.

2. Databases (Oracle, MS SQL, MySQL, PostgreSQL, DB2)

Protocols: Relational database connections established via Open Database Connectivity (ODBC) or OLE DB drivers.

Execution: Authenticates over database listener ports (e.g., Oracle TCP 1521, MS SQL TCP 1433, MySQL TCP 3306) and executes Data Definition/Control Language statements, such as ALTER USER <username> IDENTIFIED BY "<newpassword>" .

3. Unix, Linux & Network Appliances

Protocols: Secure Shell (SSH over TCP port 22) or legacy Telnet (TCP port 23).

Execution: Spawns an interactive terminal emulation session, navigates command shells, executes /usr/bin/passwd or administrative commands, and handles privilege escalation via su or sudo .

Evolution from PMTerminal to Terminal Plugin Controller (TPC)

For over a decade, CyberArk utilized PMTerminal.exe to manage terminal-based targets. Understanding the architectural shift from PMTerminal to TPC is a prominent topic on the PAM-DEF certification exam:

The Legacy PMTerminal Architecture: PMTerminal.exe was a 32-bit application compiled against the Cygwin POSIX emulation layer. While functional, it introduced severe limitations in modern enterprise environments:

Required 32-bit runtime libraries on 64-bit Windows Server.

Relied on outdated cryptographic libraries that lacked support for modern SSH ciphers, Elliptic Curve algorithms (ECDSA, Ed25519), and SHA-2 key exchange algorithms (such as rsa-sha2-256 and diffie-hellman-group14-sha256 ).

Frequently triggered false positives with enterprise Endpoint Detection and Response (EDR) agents due to Cygwin memory injection techniques.

The Modern Terminal Plugin Controller ( CyberArk.TPC.exe ): Developed as a native 64-bit .NET Core / .NET Framework application built upon the robust SSH.NET library:

Full Cipher Support: Natively supports modern cryptographic standards, advanced SSH key algorithms, and strong key exchange methods required by modern Linux distributions (RHEL 9, Ubuntu 22.04+) and network firewalls.

Backward Compatibility: TPC directly consumes existing Process.ini and Prompts.ini configuration files without requiring state-machine rewrites.

Performance: Eliminates the Cygwin emulation layer, drastically reducing CPU overhead and execution latency during large-scale rotation waves.

Anatomy of a Plug-in: INI, Process, and Prompts Files

A terminal plug-in consists of three tightly coupled configuration artifacts:

1. Platform Policy File ( <PlatformName>.ini )

Stored in the Vault's PVWAConfig Safe and cached locally. Governs execution binaries and timing:

ExeName=CyberArk.TPC.exe : Defines the executable invoked by CPM.

ProcessFile=UnixProcess.ini : Names the state machine sequence file.

PromptsFile=UnixPrompts.ini : Names the regex pattern definitions file.

Timeout=60 : Maximum overall execution time (seconds) before terminating.

ConnectionTimeout=30 : Maximum time allowed to establish initial TCP/SSH connectivity.

2. The Prompts File ( <Name>Prompts.ini )

Defines Regular Expressions (regex) matching expected output and prompt strings emitted by the target operating system: [Prompts]

  • Username=(?i)login:\s*$
  • Password=(?i)password:\s*$
  • PasswordNew=(?i)(new|enter new)\s*password:\s*$
  • PasswordConfirm=(?i)re-enter\s*new\s*password:\s*$
  • StandardPrompt=(?i)[\$#>\~]\s*$
  • ErrorPrompt=(?i)(permission denied|incorrect|invalid|failed|abort)
  • 3. The Process File ( <Name>Process.ini )

Defines the finite state machine directing the sequence of interactions for each supported action ( [Change] , [Verify] , [Reconcile] ): [Change]

  • WaitPrompt=Username
  • SendUsername=<username>
  • WaitPrompt=Password
  • SendPassword=<currentpassword>
  • WaitPrompt=StandardPrompt
  • SendCommand=passwd
  • WaitPrompt=Password
  • SendPassword=<currentpassword>
  • WaitPrompt=PasswordNew
  • SendPassword=<newpassword>
  • WaitPrompt=PasswordConfirm
  • SendPassword=<newpassword>
  • WaitPrompt=StandardPrompt
  • SendCommand=exit
  • Creating & Extending Custom Plug-ins

When developing custom plug-ins for proprietary devices, administrators must account for common terminal behavioral nuances:

Banners & MotD Screens: Corporate login banners (e.g., "Authorized Access Only - Press Enter to Continue") break default state machines. Prompts must be configured to catch banner text and send carriage returns ( \r\n ).

Terminal Pagination: Network switches (such as Cisco IOS or HP ProCurve) paginate long outputs with --More-- . The Prompts file must detect pagination strings and inject spaces to advance output.

Privilege Escalation: In Unix reconciliation workflows, the state machine logs in as an unprivileged user, executes sudo su - , expects the root password prompt, and transitions to # before executing passwd .

Regex Precision: Prompts must account for variable hostnames, trailing whitespace, and non-printable ANSI terminal color escape sequences (e.g., \[\033[01;32m\] ).

Plug-in Troubleshooting: PMTrace.log, Error Codes & Standalone Simulation

When a CPM plug-in fails, administrators utilize a structured diagnostic methodology:

1. Enabling Granular Tracing

Navigate to PVWA -> Administration -> Platform Management , edit the target platform under Additional Policy Settings , and configure:

  • EnableTrace=yes
  • DebugLevel=3

This instructs TPC to write detailed execution traces into Password Manager\Logs\PMTrace.log .

2. Analyzing PMTrace.log

PMTrace.log records every byte sent and received across the network. Key troubleshooting indicators include:

Prompt Mismatch: The log shows the device sent admin@router> , but TPC hung until timing out because the regex expected # .

Cipher Negotiation Mismatch: The log records No compatible key exchange method found , indicating the remote SSH daemon requires older or newer ciphers not enabled in TPC configuration.

Echoed Passwords: Verifies whether the remote system erroneously echoed plaintext passwords into the terminal buffer.

3. Standalone Plug-in Simulation

The most effective troubleshooting technique is bypassing the Vault entirely by running CyberArk.TPC.exe in standalone test mode from an administrative command prompt on the CPM server: cd "C:\Program Files (x86)\CyberArk\Password Manager\bin"

CyberArk.TPC.exe /action=Verify /processfile=UnixProcess.ini /promptsfile=UnixPrompts.ini /address=192.168.10.50 /username=svc_monitor /password=SecretPass123! /trace=yes

This isolates the plug-in execution from Vault state, providing instant visibility into terminal interactions, regex matches, and authentication outcomes.

PMTerminal vs. Terminal Plugin Controller (TPC) Comparison

Architectural Feature Legacy PMTerminal ( PMTerminal.exe ) Modern TPC ( CyberArk.TPC.exe )

Runtime Architecture 32-bit native process via Cygwin POSIX layer 64-bit managed application (.NET Core / .NET Framework)

SSH Library Legacy OpenSSH / Cygwin cryptographic library Modern SSH.NET fully compliant with modern RFCs

Modern Cipher Support Limited (struggles with ECDSA, Ed25519, SHA-2 KEX) Native support for all modern elliptic curves and SHA-2 ciphers

Process / Prompts Syntax Custom state-machine syntax 100% backward compatible with existing files

EDR / Antivirus Impact Frequent false positives due to Cygwin memory models Clean execution footprint; native Windows API interactions

Operating Status Deprecated; superseded in modern PAS versions Official standard for all terminal-based credential plugins

Common CPM Plug-in Error Codes & Remediation Guide

Error Code Error Description Root Cause Administrative Remediation

8001 Prompt timeout Target prompt did not match regex in Prompts file Review PMTrace.log to identify actual prompt; update regex pattern

8004 Authentication failure Stored password in Vault does not match target Trigger Reconcile workflow or manually reset credential on endpoint

8007 Network connection failed Target port unreachable, firewall block, or host down Verify routing, firewalls (e.g. TCP 22/445), and endpoint service status

8021 Password rejected by policy New password violates target OS complexity/history rules Adjust platform password generation rules ( MinLength , history settings)

Loading diagram... TPC Plug-in Execution Sequence & State-Machine Handshake