/

CVE-2024-55027

Severity:

HIGH RISK

(7.5)

Plaintext Credential Storage in Weintek cMT-3072XH2 easyweb

CVE-2024-55027

Analyzed

Vulnerability type

Category:

Plaintext Credential Storage

CWE:

CWE-312, CWE-798

Impact:

Credential Disclosure and Authentication Bypass

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

Weintek cMT-3072XH2 easyweb v2.1.53 (OS v20231011) stores user credentials in plaintext within the uac_temp.db component.

If an attacker gains access to this file via device compromise, backup extraction, or filesystem access, they can directly obtain valid credentials and impersonate legitimate users.

Affected context

The vulnerability appears in the credential handling logic of the Weintek cMT-3072XH2 easyweb interface, where authentication data is persisted in the uac_temp.db database without cryptographic protection.

It becomes relevant in environments where attackers can gain local, physical, or remote filesystem access (for example via another vulnerability, misconfiguration, or backup leakage), allowing them to read this database and recover stored credentials.

Exploit preconditions

  • Attack surface: Access to the device's filesystem or any medium where uac_temp.db is stored or backed up.
  • Required access: Local shell access, physical access, remote file access, or compromise of another service that exposes the file contents.
  • Trigger point: Reading the uac_temp.db file when it contains current user credentials.
  • Why exploitation is possible: Credentials are stored in plaintext (or trivially reversible form) rather than being derived via a one-way hash or protected with encryption and proper key management, so reading the file is enough to recover usable secrets.

Why this happens

This issue stems from an insecure design choice in how the application persists authentication data.

Instead of storing password verifiers using strong, salted, one-way hashes, or encrypting sensitive values under a well-managed key, the system writes credentials in plaintext into uac_temp.db.

This maps primarily to CWE-312: Cleartext Storage of Sensitive Information, and is related to CWE-798: Use of Hard-coded or Insecurely Managed Credentials because the design effectively treats stored plaintext values as reusable secrets that can be harvested and replayed.

Potential impact

  • Attackers may recover administrator and user passwords directly from uac_temp.db.
  • Compromised credentials can be used to log into the easyweb interface and bypass authentication.
  • Unauthorized configuration changes may be performed on the HMI/IIoT device.
  • Stolen credentials reused across systems can enable lateral movement in OT/IT environments.
  • Long-lived or shared accounts can lead to persistent unauthorized access that is hard to detect.

General mitigation guidance

Effective mitigation focuses on hardening credential storage and reducing the value of any local data exposure:

  • Replace plaintext storage with strong, salted password hashing using established algorithms (e.g., bcrypt, scrypt, Argon2) so that the database never contains recoverable passwords.
  • For non-password secrets that must be retrievable, use encryption at rest with keys stored and managed separately from the data store, preferring hardware-backed or OS-provided keystores.
  • Minimize the number of stored credentials and avoid long-lived or shared accounts, aligning permissions with least privilege.
  • Restrict filesystem and backup access through strict access controls, network segmentation, and hardened management interfaces.
  • Design operational procedures for regular credential rotation, especially after suspected device access or compromise, to limit the usefulness of any leaked data.

How teams detect issues like this

Organizations can detect and monitor this class of issue using a combination of code and configuration review:

  • Perform secure design and code reviews focusing on authentication and credential-handling paths, looking for direct storage of passwords or secrets in databases or flat files.
  • Apply static analysis or configuration scanning rules that flag reading/writing of sensitive fields without passing through hashing or encryption utilities.
  • Review firmware images and device backups for presence of human-readable credentials by searching for known usernames or patterns in configuration databases like uac_temp.db.
  • Implement security testing in CI/CD (where source is available) and in periodic product assessments (for embedded/OT devices) to identify cleartext credential storage before deployment.

Sources

SourceLink
gist.github.comgist.github.com/AenganZ/f86ed0da28825a1432ec697f484622de
plain-trick-71d.notion.siteplain-trick-71d.notion.site/weintek-cMT-3072XH2-14687a89c4c181eeb21ad61e0392f34b?pvs=4

Frequently asked

questions

Exploitability depends on how easily an attacker can access the uac_temp.db file. On its own, it does not provide remote access, but once a local or filesystem foothold is gained (through physical access, misconfiguration, or another vulnerability), the plaintext credentials can be directly extracted and used for further compromise.

An attacker needs the ability to read the uac_temp.db database. This could come from local or shell access to the device, access to device backups or images, or other weaknesses that expose the filesystem contents.

The safest pattern is to stop storing passwords in plaintext and instead store only strong, salted hash values for verification. For secrets that must be recoverable, use encryption with properly managed keys, ensuring that compromise of the data store alone does not reveal the underlying credentials.

Treat all credentials and sensitive configuration as high-value secrets from the outset: use established password hashing functions, centralized secret-management solutions, minimal retention of sensitive data, and formal security reviews of authentication flows and storage mechanisms before release.

Find out what's already
exploitable in your codebase.