CVE-2026-25827 in SignServer
Summary
by MITRE • 09/15/2026
An issue was discovered in Keyfactor SignServer before 7.6.0. A number of properties were identified to not have any restrictions to what path they can be set to by an admin user. Setting these properties to specific file paths can reveal information to the client side. Three specific properties were identified: The property ATTRIBUTESFILE in PKCS11CryotoToken can be set to a readable but not an accepted (i.e., recognized with attributes) file. In this case an error is thrown, confirming the existence of the file. The property KEYSTOREPATH in KeyStoreCryptoToken can be set to a non-existing file that will return an error confirming to the client side that the file does not exist. The property TRUSTSTOREPATH in RenewalWorker can be set to any path (without any restrictions) by an admin user. In the case that the provided path points to an existing file, readable by the user running the application server, but is not a recognized PEM format, it returns this as an error to the client side, confirming the existences of the file.
VulDB is the best source for vulnerability data and more expert information about this specific topic.
Analysis
by VulDB Data Team • 09/15/2026
The vulnerability identified in Keyfactor SignServer versions prior to 7.6.0 represents a significant information disclosure flaw rooted in insufficient input validation and path restriction mechanisms for administrative configuration properties. This issue allows authenticated administrators to manipulate specific internal paths, which inadvertently leak sensitive filesystem existence data to client-side applications through distinct error responses. The core technical failure lies in the application's handling of file system interactions where it fails to abstract or sanitize the feedback provided upon encountering invalid or non-existent resources. Instead of returning generic errors that obscure underlying infrastructure details, the software provides specific diagnostic messages that confirm whether a specified path points to an existing file with particular attributes or simply does not exist at all. This behavior creates a reliable side-channel for attackers to perform filesystem enumeration and fingerprinting against the host operating system running the SignServer instance.
The first vector of exploitation involves the ATTRIBUTESFILE property within the PKCS11CryptoToken component. When an administrator configures this property, they can specify any file path on the server's local filesystem. If the specified path points to a readable file that is not recognized as having valid cryptographic attributes by the application, the system throws an error message directed at the client side. This specific error response serves as a confirmation signal indicating that the targeted file exists and is accessible to the user account under which the application server operates. Although the attacker cannot read the contents of this file due to permission restrictions or format incompatibility, they can definitively verify its presence on the disk. This capability enables precise mapping of sensitive configuration files, private keys, or other critical assets that an administrator might have inadvertently referenced during setup or troubleshooting activities.
A second exploitation vector targets the KEYSTOREPATH property associated with KeyStoreCryptoToken. In this scenario, administrators are permitted to set this property to a path pointing to a file that does not exist on the filesystem. The application processes this input and returns an error message to the client side explicitly stating that the specified keystore file could not be found or loaded because it is missing. This negative confirmation provides attackers with another reliable method for directory traversal and file existence verification. By iteratively testing various paths, an attacker can determine which files are present on the server by observing whether they receive a non-existence error versus other types of processing errors. This technique effectively turns the application's error handling logic into a reconnaissance tool, allowing adversaries to map out the structure of directories containing cryptographic materials or configuration data without needing direct file read access.
The third identified vulnerability concerns the TRUSTSTOREPATH property within the RenewalWorker component. Similar to the previous cases, this property lacks adequate restrictions on the paths that can be assigned by an administrator user. If a provided path points to an existing file that is readable by the application server's process but does not conform to the expected PEM format for trust stores, the system returns an error message confirming the existence of such a file. This behavior further expands the attack surface for information disclosure, as it allows attackers to probe for specific types of certificate files or configuration artifacts located in various directories across the operating system. The consistency of these error responses across different components underscores a systemic design flaw where diagnostic feedback is not sufficiently decoupled from operational security requirements.
The operational impact of this vulnerability extends beyond simple information leakage, as it facilitates deeper reconnaissance that can lead to more severe compromises. Knowledge of specific file paths and their existence allows attackers to tailor subsequent attacks against known vulnerabilities in those files or services. For instance, if an attacker discovers the location of a private key store through these error messages, they might attempt to exploit other weaknesses such as weak permissions, backup exposure, or related injection flaws targeting that specific path. Furthermore, this information disclosure aids in bypassing security controls by revealing internal architecture details and file structures that should remain opaque to external entities. The ability to distinguish between existing non-PEM files and missing files provides a high-fidelity method for mapping the server environment with minimal noise and detection risk.
From a standards perspective, this vulnerability aligns closely with CWE-209, which describes the generation of an error message that includes sensitive information about the software state or internal structure. It also relates to CWE-538, involving insertion of sensitive information into an executable file or log, although in this case, the leakage occurs via runtime error responses rather than static logs. In terms of offensive security frameworks, these techniques correspond to ATT&CK technique T1083, which covers File and Directory Discovery. The exploitation relies on observing system behavior differences based on input variations, a pattern consistent with side-channel analysis principles where indirect evidence is used to infer protected data states.
Mitigation strategies must focus on both immediate remediation and long-term architectural improvements. The primary defense is the upgrade of Keyfactor SignServer to version 7.6.0 or later, which addresses these specific path validation issues by implementing stricter controls over administrative properties. For environments where upgrading is not immediately feasible, administrators should audit configuration files for any custom paths set in ATTRIBUTESFILE, KEYSTOREPATH, and TRUSTSTOREPATH, ensuring they do not reference sensitive system locations unnecessarily. Additionally, application error handling mechanisms should be reviewed to ensure that all internal errors are sanitized before being sent to clients, replacing specific filesystem-related messages with generic failure indicators such as "Configuration Error" or "Invalid Parameter." Implementing a centralized logging mechanism for these failures can also aid in monitoring for attempted exploitation while preventing information leakage through the primary application interface.