/

CVE-2026-10557

Severity:

CRITICAL RISK

(9.8)

Hard-Coded MQTT Credentials (CWE-798) in Yarbo Apps

CVE-2026-10557

Deferred

Vulnerability type

Category:

Hard-Coded Credentials

CWE:

CWE-798

Impact:

Global Unauthorized Access to MQTT Telemetry and Commands

Severity:

CRITICAL RISK

(9.8)

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

The Yarbo Android and iOS applications embed hard-coded MQTT broker credentials that are shared across all users and devices, and can be easily extracted from the app binaries.

Anyone who obtains these credentials can subscribe to global robot telemetry and send commands to any robot using only its serial number, creating significant privacy, safety, and fleet-wide compromise risk.

Affected context

This vulnerability exists in Yarbo's mobile applications where MQTT connection credentials are compiled directly into the Android APK and iOS binaries.

The same credentials appear to be reused across the entire Yarbo robot fleet and associated cloud MQTT brokers, rather than being unique per customer, app instance, or device.

The issue becomes relevant whenever an attacker can obtain the application package (for example, from an app store, device backup, or shared installation file) and perform basic reverse engineering to recover embedded secrets.

Exploit preconditions

  • Attack surface: Public internet–accessible MQTT brokers used by Yarbo cloud infrastructure.
  • Required access: Ability to download or otherwise acquire the Yarbo Android or iOS application package and perform offline decompilation or binary inspection.
  • Trigger point: Use of the extracted MQTT username/password or client credentials to connect to the cloud broker over the documented or discoverable host/port.
  • Why exploitation is possible: The MQTT credentials are hard-coded, identical across all customers and robots, and treated as static secrets rather than per-tenant or per-device credentials, so once disclosed they cannot distinguish between legitimate and malicious clients.

Why this happens

At its core, this is a hard-coded credentials problem consistent with CWE-798: Use of Hard-coded Credentials.

The mobile apps embed MQTT broker credentials directly in the client code, effectively publishing a shared secret to every user.

Because these credentials are global and not bound to a specific user or device, anyone who reverse engineers the app can impersonate trusted clients, subscribe with wide topic wildcards, and publish commands to arbitrary robots.

The design conflates application distribution with secure credential storage, instead of using dynamic, per-identity authentication and short-lived tokens obtained from a properly authenticated backend.

Potential impact

  • Unauthorized subscription to telemetry for any or all Yarbo robots, potentially exposing location, usage patterns, and sensor data.
  • Unauthorized command injection to any robot that accepts MQTT commands, which could affect physical behavior or safety.
  • Fleet-wide surveillance, including mass monitoring of device states, environments, and operational profiles.
  • Abuse of the MQTT infrastructure for spam or denial-of-service by flooding topics with fake commands or telemetry.
  • Loss of customer trust and reputational damage due to privacy violations and potential physical-world safety incidents.
  • Increased risk of regulatory scrutiny where physical device safety and personal data protection are in scope.

General mitigation guidance

Effective mitigation focuses on eliminating shared, hard-coded secrets and moving to identity-bound, revocable credentials:

  • Replace global MQTT credentials with per-user, per-device, or per-robot identities, issued and validated by a backend service.
  • Use short-lived tokens (for example, JWTs or signed access tokens) obtained via authenticated API calls instead of static passwords embedded in the app.
  • Introduce broker-side authorization policies that constrain each identity to a minimal set of topics (no fleet-wide wildcards) following a strict least-privilege model.
  • Implement secure remote configuration so that credentials and endpoints can be rotated centrally without shipping new app binaries.
  • Ensure secrets are provisioned at runtime via secure channels (e.g., mutual TLS and authenticated APIs), rather than compiled into client-side code.
  • Design the system so that compromise of one client identity does not grant access to the entire fleet, and so credentials can be revoked without affecting other users.

How teams detect issues like this

Identifying similar issues typically involves both code-centric and architecture-level reviews:

  • Use static analysis or mobile security scanning tools to detect hard-coded passwords, API keys, or broker credentials in mobile app source code and compiled binaries.
  • During secure code review, flag any embedded secrets in configuration files, string constants, or build scripts that relate to MQTT, cloud endpoints, or authentication.
  • Incorporate mobile application penetration testing that includes APK/IPA decompilation and manual inspection of strings, configuration, and network flows.
  • Enforce build-time policies that prevent inclusion of known secret patterns in the final binary, such as secret scanning in the CI pipeline.
  • Monitor MQTT broker logs for anomalous patterns, such as unexpected client IDs, mass wildcard subscriptions, or command traffic from unrecognized sources, which may indicate misuse of shared credentials.

Sources

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

Frequently asked

questions

Yes. Once an attacker extracts the MQTT credentials from the mobile app, they can connect to the cloud MQTT broker remotely over the internet, without physical access to any robot or phone, assuming the broker is reachable from the public network.

The attacker only needs the ability to obtain and reverse engineer the Yarbo mobile app package, which is generally accessible from public app stores or shared installation files; no prior account on the Yarbo platform is inherently required to recover the embedded credentials.

The most robust fix is to remove all hard-coded, shared MQTT credentials from the apps and adopt a model where each user or device authenticates via a backend service, which then issues scoped, short-lived credentials tied to that identity and restricted to specific topics.

Prevention relies on security-by-design: avoid embedding secrets in client apps, treat brokers as zero-trust surfaces that require strong authentication and fine-grained authorization, and integrate secret-scanning, mobile reverse-engineering checks, and architecture reviews into the development lifecycle before release.

Find out what's already
exploitable in your codebase.