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.

