/

CVE-2025-63912

Severity:

HIGH RISK

(7.5)

Use of Weak Cryptography in Cohesity TranZman Migration

CVE-2025-63912

Modified

Vulnerability type

Category:

Use of Weak Cryptography

CWE:

CWE-327

Impact:

Credential Exposure and Unauthorized Access

Severity:

HIGH RISK

(7.5)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

Cohesity TranZman Migration Appliance Release 4.0 Build 14614 uses a weak cryptographic algorithm to encrypt sensitive data, including credentials.

Because the encryption is trivially reversible, an attacker who can access the encrypted data may recover plaintext credentials and leverage them to gain unauthorized access to associated systems or data.

Affected context

This vulnerability occurs in environments running Cohesity TranZman Migration Appliance Release 4.0 Build 14614 where the product encrypts credentials and other sensitive configuration data using a weak or easily reversible cryptographic algorithm.

The issue is most relevant when encrypted values are stored on disk, in configuration files, logs, or transmitted over internal channels that could be read by an attacker with local or adjacent access.

The risk increases in deployments where appliance storage, backups, or administrative interfaces are not strictly isolated from untrusted users or compromised internal accounts.

Exploit preconditions

  • Attack surface: Access to encrypted data produced or stored by the appliance (e.g., configuration files, database records, backups, or exported settings).
  • Required access: Local or remote read access to the underlying storage or interfaces exposing encrypted credential blobs; no need for cryptographic key compromise if the algorithm is inherently weak.
  • Trigger point: Offline or on-the-fly decryption of captured ciphertext using public knowledge of the weak algorithm and its parameters.
  • Why exploitation is possible: The system relies on a cryptographic algorithm or scheme that does not provide modern confidentiality guarantees (e.g., outdated cipher, fixed or predictable keys/IVs, or reversible "encryption" that behaves like encoding), allowing attackers to derive plaintext with minimal effort.

Why this happens

The root cause is the use of a cryptographic algorithm or construction that does not meet contemporary security requirements for protecting credentials at rest, corresponding to CWE-327: Use of a Broken or Risky Cryptographic Algorithm.

Instead of using a well-vetted, industry-standard cipher and mode with proper key management, the implementation appears to rely on an algorithm that can be easily reversed or brute-forced with negligible cost.

This design treats confidentiality as an obfuscation problem rather than a cryptographic one, meaning that compromise of stored ciphertext almost directly implies compromise of the underlying secrets.

Potential impact

  • Attackers may recover plaintext credentials from appliance storage or configuration.
  • Compromise of accounts or services that rely on the exposed credentials (e.g., storage systems, migration targets, administrative interfaces).
  • Lateral movement within the environment using recovered credentials to access additional systems.
  • Long-lived access if credentials are reused across multiple systems or if secret rotation is infrequent.
  • Undetected data access, as attackers can authenticate legitimately using exposed credentials.

General mitigation guidance

Mitigation focuses on replacing weak cryptography with strong, contemporary primitives and hardening how credentials are handled overall:

  • Use industry-standard, peer-reviewed cryptographic algorithms and modes (e.g., AES with an authenticated mode such as GCM) for encrypting data at rest.
  • Apply proper key management: generate high-entropy keys, store them in dedicated secret stores or hardware-backed keystores, and separate keys from encrypted data.
  • For passwords or long-term secrets that do not need to be decrypted by users, prefer one-way password hashing (e.g., Argon2, bcrypt, scrypt) instead of reversible encryption.
  • Minimize where and how long credentials are stored; avoid logging or exporting them and restrict backup access.
  • Enforce least privilege on appliance access so that only strictly necessary roles can read configuration or storage areas containing encrypted credentials.
  • Encourage operational practices that include regular credential rotation to limit damage if exposure occurs.

How teams detect issues like this

Detection typically involves reviewing cryptographic design and implementation rather than runtime behavior:

  • Static analysis rules or manual code review focused on cryptographic usage, flagging non-standard algorithms, insecure modes, home-grown ciphers, or custom "encryption" utilities.
  • Policy-based checks in CI/CD that prevent introduction of deprecated algorithms and ensure use of approved crypto libraries and configurations.
  • Configuration and architecture review to confirm that secrets are stored only where necessary and that key management follows organizational standards.
  • Periodic security assessments or penetration tests that attempt to recover plaintext from stored ciphertext to validate that cryptographic controls are robust.

Sources

SourceLink
gist.github.comgist.github.com/GregDurys/4c2765d76272cda64dfc78f7a75a9251
github.comgithub.com/GregDurys/Cohesity-TranZman-CVEs

Frequently asked

questions

Exploitability depends on an attacker's ability to access the encrypted data. If they can read appliance storage, backups, or configuration exports, the weak cryptography makes it feasible to recover credentials, even without knowledge of keys.

Some level of access is typically required, such as file-system access, backup access, or authenticated access to an interface that exposes encrypted values. However, once ciphertext is obtained, the weakness of the algorithm significantly lowers the barrier to recovering plaintext.

Replace the weak algorithm with a modern, vetted cryptographic primitive, use established libraries instead of custom schemes, and apply robust key management practices. Additionally, re-encrypt or re-store existing secrets and rotate any credentials that may have been exposed.

Establish a cryptography standard for the organization, restrict developers to approved libraries and configurations, and enforce automated checks for risky ciphers. Combine this with regular security reviews focusing on how secrets are stored, encrypted, and rotated across the product lifecycle.

Find out what's already
exploitable in your codebase.