Openssl Encrypt

Authentication bypass in the openssl_encrypt Python library (versions before 1.4.0) lets attackers who can tamper with ciphertext in transit defeat integrity protection, because a failed AES-GCM authenticated decryption in pqc.py silently falls back to unauthenticated AES-CTR. Reported by VulnCheck and carrying a CVSS 4.0 base score of 9.3, the flaw enables undetected bit-flipping and ciphertext manipulation. No public exploit identified at time of analysis, but a vendor patch is available.

Cryptographic shared-secret disclosure in the openssl_encrypt Python library (maintainer 'jahlives') before 1.4.0 lets an attacker reconstruct the KEM shared secret and decrypt all protected ciphertext once they obtain only 16 bytes of the private key. The flaw lives in pqc.py, where any post-quantum KEM decapsulation failure silently falls back to a 'simulation mode' that derives a deterministic secret from those 16 key bytes plus attacker-visible encapsulated-key data, rather than raising an error. Reported by VulnCheck; there is no public exploit identified at time of analysis and it is not listed in CISA KEV.

Sandbox escape in the openssl_encrypt Python library (jahlives) before 1.4.0 lets attacker-supplied plugin code break out of the IsolatedPluginExecutor and run arbitrary OS commands. The restricted exec() environment still leaks live Python type objects, so an attacker walks the class hierarchy to reach system primitives despite the intended sandbox. Rated CVSS 4.0 9.3 (critical) and reported by VulnCheck; no public exploit identified at time of analysis and it is not listed in CISA KEV.

Sandbox escape leading to remote code execution affects openssl_encrypt (the jahlives Python package) in all versions before 1.4.0, where the DangerousPatternVisitor AST analyzer fails to catch dunder-based attribute traversal. Because the library's security model is to safely execute untrusted plugin code, an attacker who can supply a plugin can chain __class__, __bases__, __subclasses__() and __globals__ to reach restricted functions and run arbitrary OS commands, fully defeating the sandbox. Reported by VulnCheck with a vendor patch available; no public exploit or CISA KEV listing was identified at time of analysis.

Sandbox escape in the openssl_encrypt Python library (jahlives) before 1.4.0 allows attacker-supplied plugins to run without any isolation because the default process-isolation mode silently fails to enforce its sandbox restrictions. An attacker able to supply or influence a plugin gains unrestricted filesystem, network, subprocess, and full Python-module access equivalent to arbitrary code execution. Reported by VulnCheck with a vendor patch available; no public exploit code or CISA KEV listing is identified at time of analysis (CVSS 4.0 base 9.3).

Authentication bypass in the jahlives openssl_encrypt library (all versions before 1.4.0) lets remote unauthenticated attackers fully control the key-management API because verify_api_token treats any non-empty Bearer string as valid. An attacker can upload attacker-controlled public keys, enumerate every stored key, and revoke keys belonging to arbitrary users, undermining the confidentiality and integrity guarantees the tool is meant to provide. The flaw is vendor-confirmed with a patch available and was reported by VulnCheck; no public exploit identified at time of analysis, though the trivial nature makes weaponization simple.

Hardcoded JWT signing secrets embedded in config.py of openssl_encrypt versions before 1.4.0 allow any party with access to the library's publicly hosted source code to forge cryptographically valid JWT tokens for arbitrary client IDs, bypassing authentication on keyserver and telemetry APIs. The static secrets pass all validation checks, making exploitation a matter of reading the source and generating a token with standard JWT tooling-no brute-force or cryptographic attack is required. No CISA KEV listing or public proof-of-concept exploit has been identified at time of analysis, but the trivially low exploitation complexity makes this a high-priority remediation for any network-exposed deployment running an unpatched version.

Authentication bypass in the jahlives/openssl_encrypt PHP library (all versions before 1.4.0) exposes deployments running the standalone telemetry server to full API authentication compromise via hardcoded credentials. The static default secret key embedded in the telemetry server configuration is used for API key hashing; any attacker who obtains this now-public value can reconstruct valid API key hashes and authenticate to the telemetry API without possessing legitimate credentials. The vendor has released a fix in version 1.4.0, confirmed via GHSA-p926-6hjp-w9jw; no public exploit code or CISA KEV listing has been identified at the time of analysis.

Hardcoded PostgreSQL credentials embedded in openssl_encrypt standalone server configuration files expose backend databases to unauthorized access in all versions before 1.4.0. Network-adjacent attackers who obtain the well-known static credentials - trivially available from the distributed software package or public advisory - can authenticate directly to the PostgreSQL instance and retrieve sensitive stored data without any legitimate account. No public exploit code has been identified and this CVE is not listed in the CISA KEV catalog, but the CWE-798 root cause makes exploitation mechanically trivial for any attacker within network reach of the database port.

Integrity-protection bypass in the jahlives openssl_encrypt Python library (all versions before 1.4.0) lets an attacker who can influence the process environment silently disable HMAC authentication in the CamelliaCipher code path. When the PYTEST_CURRENT_TEST environment variable is present, the library skips generating and verifying HMAC tags, so ciphertext is produced and accepted without integrity protection, enabling undetected tampering of encrypted data. Reported by VulnCheck with a vendor patch available; no public exploit identified at time of analysis and it is not listed in CISA KEV.

Weak cryptographic key derivation in the openssl_encrypt Python library (all versions before 1.4.0) stems from its key-normalization routines invoking HKDF with no salt and a static info parameter, making derived keys deterministic for identical inputs. This reduces effective entropy and weakens resistance to multi-target (batch) attacks, letting an adversary who collects ciphertexts or derived-key material amortize cryptanalytic effort across many victims. No public exploit identified at time of analysis; the flaw was reported by VulnCheck and a vendor patch is available in 1.4.0.

Weak key derivation in openssl_encrypt versions prior to 1.4.0 enables accelerated offline password cracking against files encrypted by the library. The jahlives/openssl_encrypt PHP library implements PBKDF2 in a non-standard construction - using iterations=1 per inner call within an outer application loop - a design whose formal security properties have not been analyzed and whose brute-force resistance is materially lower than a correctly parameterized PBKDF2 implementation. No public exploit code has been identified at time of analysis, and the library has not been listed in CISA KEV; exploitation is bounded to attackers who have already obtained the encrypted artifacts.

Insecure PRNG import in the jahlives openssl_encrypt Python package (all versions before 1.4.0) places Python's non-cryptographic 'random' module (Mersenne Twister) into openssl_encrypt/modules/pqc.py, though the code makes no calls to it, so no cryptographic operation is presently weakened. VulnCheck reported this as a latent hazard: the import invites future maintainers to reach for random.randint() instead of secrets/os.urandom, which would yield predictable values recoverable from ~624 outputs. There is no public exploit identified at time of analysis and it is not on CISA KEV; the flaw was fixed by removing the import in version 1.4.0.

Arbitrary code execution in jahlives openssl_encrypt before 1.4.0 stems from an inconsistent sandbox: the runtime PluginImportGuard and the static AST analyzer enforce two different blocklists, so an attacker who slips past the AST's DANGEROUS_MODULES check can still import high-risk modules at runtime. By using string obfuscation or encoding to hide imports of sys, shutil, multiprocessing, importlib, or pickle, a supplied plugin escapes the sandbox and runs on the host. Reported by VulnCheck with a vendor patch available; no public exploit has been identified at time of analysis and it is not listed in CISA KEV.

Audit-trail corruption and a security-control race condition in the Python library openssl_encrypt (by jahlives) before version 1.4.0 undermine its module-hiding defenses. The restore_hidden_modules() function logs module counts after clearing them, so it always records zero restored modules and produces misleading audit logs (CWE-117), while a separate time-of-check/time-of-use race between module hiding and import-hook installation lets a concurrent thread re-import modules that were meant to be blocked. Reported by VulnCheck with a vendor patch available; no public exploit identified at time of analysis and it is not on CISA KEV.

Path traversal in the jahlives openssl_encrypt plugin (versions before 1.4.0) permits unauthenticated remote attackers to escape the intended plugin configuration directory by supplying crafted plugin_id values containing sequences such as '../'. The _is_safe_path method fails to sanitize the plugin_id parameter before using it to construct filesystem paths, exposing arbitrary server-side files readable by the application process. No active exploitation is confirmed (not in CISA KEV) and no public POC has been identified at time of analysis, though the network-accessible, zero-authentication attack profile makes this straightforward to exploit from the vulnerability description alone.

Sandbox bypass in the openssl_encrypt Python plugin (jahlives, all versions before 1.4.0) allows attackers to completely circumvent the restricted_open file access control layer by importing Python's standard pathlib or io modules within the sandbox context, enabling arbitrary file read and write on the host filesystem. The vulnerability is exploitable over the network with no privileges required but requires passive user interaction (UI:P per CVSS 4.0), scoring 8.7 on the CVSS 4.0 scale. No public exploit has been identified at time of analysis, and a vendor-released patch is available in version 1.4.0.

openssl_encrypt (jahlives, versions before 1.4.0) ships with an insecure default trusted_proxies configuration that grants implicit trust to all RFC 1918 private address space in IntegrityProxyConfig, enabling mutual TLS authentication bypass via forged client certificate headers. Any attacker with access to a co-located private network segment can inject a crafted header that the library accepts as a legitimate certificate identity, effectively impersonating an authenticated mTLS principal. No public exploit code has been identified at time of analysis, and the vulnerability is not listed in CISA KEV; however, the authentication bypass class is operationally severe for any deployment relying on mTLS for access control.

CORS misconfiguration in the openssl_encrypt pip package (versions before 1.4.0) enables any website to issue fully credentialed cross-origin API requests on behalf of authenticated users, exposing sensitive API responses to attacker-controlled origins. Both standalone server components - key-server and telemetry-server - ship with the maximally permissive combination of allow_origins=["*"] and allow_credentials=True as their default configuration, propagated through docker-compose.yml and .env.example. No active exploitation has been confirmed (not in CISA KEV) and no public exploit code is known at time of analysis, though the attack pattern is a well-understood, low-complexity web exploit.

Sensitive-token exposure in openssl_encrypt (the jahlives Python package, pip 'openssl-encrypt') before 1.4.0 stems from the keyserver and telemetry server accepting refresh tokens as GET query parameters. Because URLs are routinely written to server access logs, proxy/CDN logs, browser history, and forwarded in HTTP Referer headers, any party with access to those artifacts can harvest a valid refresh token and mint new access tokens, effectively bypassing authentication. Reported by VulnCheck; no public exploit identified at time of analysis and it is not on CISA KEV.

Information disclosure in the openssl-encrypt Python pip package (jahlives/openssl_encrypt, all versions before 1.4.0) allows any unauthenticated network caller to extract sensitive database infrastructure details by hitting the /ready health-check endpoint. The endpoint returns raw Python exception strings - including database hostnames, IP addresses, port numbers, driver version, and potentially credentials embedded in connection strings - whenever a database error is triggered. No public exploit code has been identified at time of analysis, but the attack requires only a standard HTTP client and no special conditions against default deployments.

Authentication brute-force protection can be bypassed in jahlives openssl_encrypt before 1.4.0 because the TOTP rate limiter is held in per-process in-memory state (a class-level defaultdict) rather than shared storage. In multi-worker or multi-instance deployments each worker enforces its own independent counters, and all lockout state evaporates on restart, so an attacker can parallelize or restart-reset their way through TOTP guesses. No public exploit is identified at time of analysis, and it is not listed in CISA KEV; a vendor patch exists in 1.4.0.

Insecure Direct Object Reference (IDOR) in the openssl_encrypt Python pip package (versions before 1.4.0) allows any authenticated client to revoke another client's cryptographic key without owning it. The keyserver's revoke_key method at lines 195-270 of service.py validates the requester's ML-DSA post-quantum signature but never checks whether the requesting client_id matches the key's owner_client_id - meaning an attacker with valid credentials can target any key in the server by presenting their own legitimate signature against a victim's key ID. No public exploit is identified at time of analysis, though the low attack complexity and the availability of a detailed GHSA advisory make exploitation straightforward for authenticated clients.

Secret disclosure affects the openssl_encrypt Python library (all versions before 1.4.0), where PublicKeyBundle.from_dict() constructs key bundles from untrusted serialized data without validating the embedded self-signature, and to_identity() then promotes that unverified bundle into a usable Identity. An application that deserializes an attacker-supplied bundle and encrypts to it - without an intervening verify_signature() call - will encrypt secrets to an attacker-controlled public key, allowing the attacker to decrypt them. Reported by VulnCheck and fixed in 1.4.0; no public exploit has been identified at time of analysis.

Schema validation bypass in the openssl_encrypt Python package (by developer 'jahlives') before version 1.4.0 lets attackers slip malformed or malicious metadata past all JSON schema checks. Because validation fails open when the optional jsonschema library is absent - and because unknown metadata format versions are silently skipped - an attacker who controls the runtime environment or the supplied metadata can process unvalidated data. Reported by VulnCheck and carrying a CVSS 4.0 base score of 9.3; no public exploit identified at time of analysis and it is not listed in CISA KEV.

Cryptographically weak PRNG use in openssl_encrypt before 1.4.0 exposes steganographic pixel selection to full state-recovery attacks. The library's steganography module seeds Python's Mersenne Twister with only 64 bits of SHA-256 hash material derived from the user password, then uses it to select pixel positions for hidden data - a design flaw captured by CWE-338. Any attacker who knows or can brute-force the steganography password can deterministically reconstruct the PRNG sequence and enumerate every pixel carrying concealed data, breaking steganographic confidentiality entirely. No public exploit has been identified at time of analysis and no CISA KEV listing exists, but the MT state-recovery technique is well-documented and requires no novel research.

Password exposure in openssl_encrypt before version 1.4.0 allows any local system user to capture plaintext encryption and keystore passwords by reading process argument listings. When operators pass credentials via the --password or -p CLI flags, those values appear verbatim in /proc/[pid]/cmdline and ps aux output on Linux/Unix multi-user systems. No public exploit is identified at time of analysis, though exploitation requires only standard POSIX utilities universally available on Linux; the CVSS 4.0 vector's AV:N designation appears miscalibrated - actual attack surface is local, meaningfully limiting real-world risk.

Arbitrary native code execution in the jahlives openssl_encrypt Python package (all versions before 1.4.0) arises from its Whirlpool hash routine loading .so extension modules via a broad glob pattern without any integrity check. An attacker who can drop a file matching 'whirlpool*py313*.so' into a site-packages directory gets their code executed in-process the moment the hashing module is imported. Reported by VulnCheck; a vendor patch (1.4.0) exists, and there is no public exploit identified at time of analysis.

Key derivation bypass in jahlives/openssl_encrypt PHP library before 1.4.6 allows offline password cracking at SHA-256 speed against credentials derived under the flawed sequential XOR composition mode. An algebraic cancellation in the key generation routine causes the memory-hard KDF's final stage to nullify itself, stripping the configured computational cost entirely and collapsing security to that of a single SHA-256 hash. No active exploitation has been confirmed (not in CISA KEV) and no public exploit code has been identified at time of analysis, but the impact is severe for any application storing user passwords in the vulnerable configuration.

openssl_encrypt (pip, versions <= 1.4.7) unconditionally prints a derived hardware pepper as a hex string to stdout/stderr when the 'hsm fido2-test' or 'hsm onlykey-test' diagnostic commands are invoked, with output potentially persisting in CI build logs, terminal scrollback buffers, or session recordings. A secondary exposure exists where a related plugin component logged raw prf_data values outside the library's secret-redaction pathway. No public exploit has been identified and no CISA KEV listing exists; critically, the vendor description explicitly states the leaked pepper is derived from a random per-invocation test salt and is salt-bound, meaning it cannot be used to decrypt real files, substantially constraining actual impact despite the elevated CVSS 4.0 score of 8.7.