Severity:

HIGH RISK

(7.3)

Use of Hard-coded Cryptographic Key in MAXHUB Pivot Client

CVE-2026-6411

Awaiting Analysis

Vulnerability type

Category:

Use of Hard-coded Cryptographic Key

CWE:

CWE-327

Impact:

Exposure of Sensitive Information and Denial of Service

Severity:

HIGH RISK

(7.3)

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

MAXHUB Pivot client versions prior to v1.36.2 contain a hardcoded AES key that is used to encrypt tenant email addresses and related metadata.

An attacker who extracts this key from the client can decrypt captured data for any tenant and may also enroll multiple unauthorized devices via MQTT, potentially causing denial-of-service conditions and disrupting tenant operations.

Affected context

This vulnerability affects environments where the MAXHUB Pivot client application (pre-v1.36.2) is deployed and used for multi-tenant communication and device management.

The issue is relevant when:

  • Tenants rely on the client for handling email address–based identities and associated metadata.
  • Encrypted tenant data can be observed, intercepted, or accessed by parties who can also obtain the client binary.
  • MQTT infrastructure is reachable such that devices can be enrolled into tenants based on client-side logic.

Under these conditions, the hardcoded AES key becomes a shared secret across all installations, weakening tenant isolation and making it easier to manipulate device enrollment flows.

Exploit preconditions

  • Attack surface:
  • Access to the MAXHUB Pivot client binary or installation package (e.g., via local access, download, or reverse engineering).
  • Network-level access to capture or access encrypted tenant data and MQTT communication where tenant context is managed.
  • Required access:
  • Ability to inspect or reverse engineer the client to extract the hardcoded AES key.
  • Ability to observe or obtain ciphertext that was produced with that key (e.g., via logs, intercepted traffic, or stored data).
  • Ability to connect to the MQTT broker used by the system and perform device enrollment actions.
  • Trigger point:
  • Using the extracted AES key to decrypt captured tenant email addresses and metadata.
  • Leveraging MQTT enrollment mechanisms to repeatedly register unauthorized devices into a tenant.
  • Why exploitation is possible:
  • The same AES key is hardcoded into every vulnerable client, turning what should be a tenant- or deployment-specific secret into a publicly recoverable constant.
  • Client-side controls on MQTT device enrollment appear insufficient to prevent unauthorized or repeated registrations once an attacker can imitate a valid client.

Why this happens

The core problem is the use of a hardcoded, shared AES key within the MAXHUB Pivot client for protecting tenant email addresses and related metadata.

Embedding cryptographic keys in client-side applications allows anyone with access to the binary to recover the key through static analysis, debugging, or reverse engineering.

This design violates cryptographic best practices and falls under CWE-327: Use of a Broken or Risky Cryptographic Algorithm, in this case specifically a risky key management pattern where confidentiality hinges on the obscurity of a client-embedded key.

Because the same key appears to be used across tenants, the compromise of one client effectively compromises the secrecy of all encrypted tenant identifiers, and undermines authorization logic that depends on those values for MQTT-based device enrollment and tenant scoping.

Potential impact

  • An attacker could decrypt encrypted tenant email addresses and related metadata, exposing sensitive identity and organizational information.
  • Tenant enumeration and mapping of users or devices across the service could become significantly easier.
  • Unauthorized devices may be enrolled into tenants via MQTT, potentially polluting device inventories or misdirecting communications.
  • Operational disruption or denial-of-service conditions could occur if large numbers of unauthorized devices are registered, overwhelming tenant resources or management interfaces.
  • Loss of trust between tenants and the service provider if tenant boundaries or privacy expectations are perceived as compromised.

General mitigation guidance

Effective mitigation generally focuses on replacing hardcoded keys with robust, centrally managed secrets and tightening enrollment controls:

  • Eliminate client-embedded keys: Move cryptographic key material out of the client and into secure, server-side key management systems. Clients should never contain long-lived master keys that protect cross-tenant data.
  • Use per-tenant and per-session keys: Derive keys per tenant and, where practical, per session, using standard key derivation functions and server-side authorization, so that compromise of one context does not expose others.
  • Adopt authenticated protocols for identity data: Instead of relying on client-side encryption with a shared key, use secure transport (e.g., TLS) combined with server-side access control and token-based authentication for email and metadata operations.
  • Harden device enrollment flows: Require strong, server-validated credentials or enrollment tokens for MQTT device registration, and rate-limit enrollment attempts per tenant and per device identifier.
  • Apply least privilege and isolation: Ensure tenants are logically isolated, and that any metadata required on the client is minimal, non-sensitive, and not reusable for cross-tenant impersonation.

How teams detect issues like this

Organizations can look for this class of issue and its effects via a mix of code-level and behavioral monitoring:

  • Static analysis and binary review:
  • Scan source and compiled binaries for embedded cryptographic keys, static IVs, or suspicious constants used with crypto APIs.
  • Flag patterns where the same AES key is reused across multiple code paths or tenants.
  • Code review signals:
  • Examine cryptographic usage to ensure keys are injected from secure configuration or key management services rather than defined as literals.
  • Review client authentication and MQTT enrollment logic for reliance on client-side secrets or opaque identifiers.
  • Policy enforcement and build-time checks:
  • Integrate secret-scanning tools into CI/CD pipelines to block commits that introduce hardcoded secrets or cryptographic keys.
  • Enforce security guidelines requiring server-side key management and per-tenant isolation.
  • Runtime monitoring:
  • Monitor MQTT brokers and backend services for abnormal spikes in device enrollment events, especially bursts associated with a single tenant.
  • Alert on repetitive failed enrollment attempts or unusually high numbers of devices attached to a tenant.

Sources

SourceLink
github.comgithub.com/cisagov/CSAF/blob/develop/csaf_files/OT/white/2026/icsa-26-127-01.json
cisa.govcisa.gov/news-events/ics-advisories/icsa-26-127-01
maxhub.commaxhub.com/en/support/

Frequently asked

questions

Yes, in many deployments it can be. Once an attacker extracts the hardcoded AES key from any client instance, they can potentially decrypt encrypted tenant email data they can access and may interact with MQTT-based services to affect other tenants, assuming network reachability and insufficient server-side checks.

An attacker needs the ability to obtain or analyze the MAXHUB Pivot client binary to recover the hardcoded key, and some form of access to the environment where encrypted tenant data or MQTT services are available (e.g., network access to observe traffic, query APIs, or connect to the MQTT broker).

Replace the hardcoded AES key with centrally managed, server-side keys; design the protocol so that clients never hold long-lived master keys, and rely on authenticated, server-issued tokens and secure transport rather than shared secrets embedded in the application.

Establish development policies that prohibit hardcoded secrets, adopt a dedicated key management service, integrate automated secret scanning into CI/CD, and design authentication and enrollment flows under a zero-trust mindset where client-side code is always considered observable and modifiable by attackers.

Find out what's already
exploitable in your codebase.