/

CVE-2026-50091

Severity:

CRITICAL RISK

(9.1)

Hard-coded Crypto Keys (CWE-321) in Aqara Home App

CVE-2026-50091

Analyzed

Vulnerability type

Category:

Use of Hard-coded Cryptographic Key

CWE:

CWE-321, CWE-798

Impact:

Compromise of cryptographic confidentiality and integrity

Severity:

CRITICAL RISK

(9.1)

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

Aqara Home for Android and white-label variants embed hard-coded cryptographic keys inside the application binary.

When an attacker can reverse-engineer the app or access its package, these static keys undermine encryption, allowing unauthorized data decryption and message forgery over the network.

Affected context

This vulnerability occurs in mobile applications that bundle cryptographic material directly in their binaries or shared libraries, such as liblumidevsdk.so.

It is present when encryption, authentication, or signing operations reuse these embedded keys across devices, users, or deployments, rather than deriving secrets per user or per device.

The risk grows in environments where attackers can easily obtain the APK or shared library, perform static analysis, and then reuse the recovered keys against cloud APIs, device communication channels, or local encrypted data.

Exploit preconditions

  • Attack surface: Network interfaces and encrypted channels that rely on the embedded keys, plus local encrypted data protected solely by those keys.
  • Required access: Ability to obtain and analyze the application package or shared library (e.g., downloading APK from a store, extracting liblumidevsdk.so).
  • Trigger point: Any operation that uses the hard-coded keys for encryption, authentication, or signing, such as API calls, device pairing traffic, or secure storage access.
  • Why exploitation is possible: The keys are constant and shared; reverse engineering or binary inspection exposes them, enabling attackers to impersonate clients, decrypt traffic, or craft valid cryptographic messages without per-user secrets.

Why this happens

The underlying flaw is the direct embedding of cryptographic keys into application code or libraries, rather than managing them as dynamic, secret values derived or provisioned at runtime.

This maps to CWE-321: Use of Hard-coded Cryptographic Key and is closely related to CWE-798: Use of Hard-coded Credentials, where authentication or protection relies on static secrets baked into software artifacts.

Architecturally, this insecure pattern treats the application binary as a secure storage medium, ignoring that client-side code can be freely inspected and modified by attackers, making any embedded key inherently untrustworthy.

Potential impact

  • Attackers may decrypt supposedly secure communication between the app and backend or IoT devices.
  • Adversaries could forge or replay authenticated requests, impersonating legitimate clients or devices.
  • Malicious actors can bypass access controls that rely on the embedded keys for authorization or pairing.
  • Threat actors may tamper with device configuration or user data by sending cryptographically valid but unauthorized commands.

General mitigation guidance

Effective mitigation focuses on eliminating static, shared secrets in client-side software and redesigning key management.

Recommended patterns include:

  • Deriving per-user or per-device keys from secure server-side processes, never embedding master keys in the app.
  • Delegating sensitive cryptographic operations to trusted backends or hardware security modules, reducing what must run on the client.
  • Using established key-exchange protocols (e.g., TLS with mutual authentication) that rely on server-managed credentials rather than app-embedded keys.
  • Applying least-privilege to any client tokens or keys, limiting their scope, lifetime, and accessible operations.
  • Designing update and provisioning flows that can rotate keys and invalidate compromised secrets without requiring app binary changes.

How teams detect issues like this

Organizations typically detect hard-coded key issues through:

  • Static analysis rules that flag suspicious constants used in crypto APIs, such as long byte arrays passed to cipher or MAC constructors.
  • Manual code review targeted at encryption, authentication, and signing logic, looking for inline key material and shared secrets.
  • Binary and reverse-engineering audits of mobile apps or SDKs, inspecting native libraries for recognizable key patterns or credential strings.
  • Policy-based enforcement in CI/CD that prohibits embedding keys or credentials in source repositories and build artifacts, backed by automated scanners.

Sources

SourceLink
github.comgithub.com/xn0tsa/theres-no-place-like-home
runzero.comrunzero.com/advisories/aqara-hardcoded-sdk-keys-cve-2026-50091

Frequently asked

questions

It is typically broadly exploitable because anyone can download the app, extract the binary, recover the keys, and use them against any environment that trusts those keys.

No. An attacker generally only needs access to the application package (e.g., APK) or distribution artifacts; root access is not required to recover embedded keys.

Remove hard-coded keys entirely and move key management to secure, server-side infrastructure, issuing per-user or per-device secrets via authenticated provisioning flows and standard key-exchange protocols.

Establish secure design guidelines that forbid embedding cryptographic material in client code, enforce repository and build-time scanning for keys/credentials, and require threat modeling of crypto and authentication schemes before implementation.

Find out what's already
exploitable in your codebase.