Description

openssl_encrypt (pip package openssl-encrypt) versions <= 1.4.8 contain a CWD-relative configuration file resolution flaw in crypt_settings.py, where CONFIG_FILE (originally the absolute per-user path ~/.crypt_settings.json) is reassigned at line 84 to the bare relative name 'crypt_settings.json'. As a result, the legacy Tk GUI's SettingsTab reads and writes KDF settings from crypt_settings.json in the process launch (current working) directory instead of the user's home directory. An attacker who plants a malicious crypt_settings.json (e.g. sha256:1 with all memory-hard KDFs disabled) can silently downgrade encryption performed in that GUI session to roughly one hash round, bypassing the weak-KDF preflight and enabling offline brute-force attacks against the resulting ciphertext. Fixed in 1.4.9.

Executive Summary

Technical Details

Mitigations

References

Additional Metadata

{
  "score": "5.5",
  "pubDate": "2026-08-27T17:20:59.893Z",
  "pubdate": "2026-08-27T17:20:59.893Z",
  "executiveSummary": "The openssl-encrypt pip package (versions 1.4.8 and earlier) is susceptible to a configuration file resolution vulnerability that allows for the silent degradation of cryptographic settings.\nThe vulnerability stems from an insecure re-assignment of the CONFIG_FILE path variable within crypt_settings.py, causing the application to prioritize a configuration file located in the current working directory (CWD) over the expected user-specific configuration in the home directory.\nAn attacker can exploit this by placing a malicious 'crypt_settings.json' file within the directory from which the application is launched. This file can be crafted to disable memory-hard Key Derivation Functions (KDFs) or reduce iteration counts to a negligible level.\nThe primary impact is the significant weakening of encryption strength for data processed through the legacy Tk GUI. By bypassing mandatory KDF preflight checks, the resulting ciphertext becomes vulnerable to efficient offline brute-force or dictionary attacks.\nExploitation requires the attacker to successfully influence the environment from which the user launches the GUI, such as dropping a file into a shared or reachable directory. This issue is resolved in version 1.4.9.",
  "technicalDetails": "The vulnerability resides in the crypt_settings.py module of the openssl-encrypt package. The application is designed to manage user-specific encryption settings via a JSON configuration file. Originally, the software correctly identifies the storage location as an absolute path referencing the user's home directory ('~/.crypt_settings.json').\nThe flaw is introduced at line 84 of crypt_settings.py, where the variable CONFIG_FILE is explicitly reassigned to the bare filename 'crypt_settings.json'. In Python's file I/O operations, providing a relative path instead of an absolute path causes the interpreter to resolve the file location relative to the process's current working directory (CWD) rather than the application's intended data directory.\nWhen a user executes the legacy Tk GUI, the application attempts to read the KDF configuration from the local CWD. If a malicious 'crypt_settings.json' exists in this directory, the application will load the attacker-supplied parameters rather than the user's secure default settings.\nThe exploitation flow proceeds as follows: 1) An attacker identifies a target directory where the user is likely to execute the openssl-encrypt GUI. 2) The attacker places a crafted 'crypt_settings.json' file in this directory. 3) The attacker modifies the JSON structure to minimize KDF work factors—for example, setting the hash round count to 1 and disabling all memory-hard parameters. 4) The user launches the GUI from the compromised directory. 5) The application imports the malicious configuration due to the improper path resolution. 6) The GUI performs encryption operations using the weak parameters defined in the attacker's file. 7) The resulting ciphertext, intended to be protected by robust KDFs, is significantly easier to crack offline by an unauthorized party.\nThis vulnerability effectively bypasses the integrity of the KDF preflight checks, as the application assumes the configuration file being read is the trusted, user-controlled instance. Because the file read/write operations are redirected to the CWD, the application also inadvertently writes session-specific settings to this external file if the user performs subsequent operations, potentially persisting the weakened state if the file is not managed securely."
}