Cómo extraje la localKey a mi aspiradora Tuya: reversing de una app Android con root, Frida y MMKV

· android, reversing, frida, tuya, iot

Escuchar este artículo

Descargar MP3 · Ver en Internet Archive

“El robot no tiene API, la app está ofuscada y los datos están cifrados” — todo eso era cierto, y aun así terminé con la clave en la mano en una tarde. Esto es el paso a paso completo: lo que funcionó, lo que falló y por qué falló.

Aviso: todo esto lo hice sobre mi robot, mi teléfono y mi cuenta. No es una guía para tocar el dispositivo de otra persona. Las claves, IDs, IPs y MACs de este post están reemplazadas por placeholders.


Índice

  1. El objetivo
  2. TL;DR
  3. Reconocimiento: es un Tuya disfrazado
  4. Conectar el teléfono (root) por ADB
  5. Intento 1: los datos en reposo
  6. Intento 2: hurgar en la memoria
  7. La app detecta root: Magisk DenyList
  8. Frida: la parte que casi no sale
  9. Reconocimiento de clases
  10. El hook que da la clave
  11. Asociar la clave al dispositivo correcto
  12. Bonus: el schema de DPs
  13. Control local: tinytuya
  14. Mapear la casa sin SLAM
  15. Lo que no usé (y por qué)
  16. Tabla de errores y causas
  17. Seguridad y limpieza
  18. Conclusiones
  19. Glosario

El objetivo

Tengo un robot aspiradora barato, de esos que se manejan con una app. La app funciona, pero:

  • depende de la nube de Tuya (si se cae el servidor, no anda nada);
  • manda telemetría a un servidor que no controlo;
  • te obliga a pasar por el teléfono para programar una limpieza;
  • y la app en cuestión es un white-label: no hay documentación, ni API pública, ni CLI.

Lo que quería era simple: hablarle al robot por la red local, sin nube. Para eso hace falta un dato que la app nunca te muestra: la local_key, una clave de 16 caracteres que el equipo usa para cifrar el protocolo local (TCP 6668).

Sin la local_key, lo único que se puede hacer es descubrir el equipo (deviceScan te da el gwId y la versión del protocolo), pero cualquier comando o consulta de estado vuelve cifrado con AES y no hay forma de leerlo.


TL;DR

Fase Resultado
Reconocimiento de red El robot es Tuya: gwId, productKey y protocolo 3.3 por UDP 6666/6667
Datos en reposo (MMKV, SQLite, logs) Falló: todo cifrado, claves derivadas dentro de la app
Heap dump (am dumpheap) Falló: SecurityException: Process not debuggable
Buscar strings en /proc/<pid>/mem Falló: ART guarda UTF-16LE y el dato no estaba residente
Root detection de la app Burlada con Magisk DenyList (com.ls.smartlife)
Frida attach Falló: unable to open library
Frida spawn + attach(pid) Funcionó: hook a MMKV.decodeString
Resultado localKey en claro + deviceId + schema completo de 18 DPs

El código central son ~30 líneas de JavaScript que enganchan el método decodeString del MMKV de la app. El resto del post es cómo llegué ahí.


Reconocimiento: es un Tuya disfrazado

La app se llama distinto según el fabricante, pero adentro es el SDK de Tuya (com.thingclips.smart, antes com.tuya.smart). Una forma rápida de confirmarlo sin descompilar nada: escanear la red local con tinytuya, que manda un broadcast UDP en los puertos 6666/6667.

import tinytuya

for ip, info in tinytuya.deviceScan(False, 18).items():
    print(ip, info.get("gwId"), info.get("productKey"), info.get("version"), info.get("encrypt"))

Salida (redactada):

192.0.2.88  <DEVICE_ID>  <PRODUCT_KEY>  3.3  True

Eso ya me dijo tres cosas:

  1. Es Tuya y está en mi LAN.
  2. El gwId que anuncia por broadcast tiene que coincidir con el devId que la app guarda. Es mi chequeo cruzado para no confundirme de equipo.
  3. Protocolo 3.3 con encrypt: True → AES-128-ECB con md5(local_key) como clave. Sin local_key no hay nada que hacer.

También confirmé el paquete de la app:

adb shell pm path com.ls.smartlife
# package:/data/app/com.ls.smartlife-1/base.apk
# package:/data/app/com.ls.smartlife-1/split_config.armeabi_v7a.apk

Dato importante: el APK tiene split armeabi_v7a, o sea la app corre en 32 bits. Eso va a importar cuando elija el binario de Frida.


Conectar el teléfono (root) por ADB

Requisitos: el teléfono con root (Magisk), depuración USB activada y el celular en la misma red que la PC. En mi caso un Moto G4 con Android 7.0.

adb connect 192.0.2.50:5555
adb devices -l
# 192.0.2.50:5555  device product:athene model:Moto_G__4_ device:athene

Comprobaciones rápidas:

adb shell 'su -c "id"'
# uid=0(root) gid=0(root) context=u:r:magisk:s0

adb shell 'su -c "uname -m"'
# armv7l        <-- 32 bits, clave para elegir frida-server

adb shell 'su -c "svc power stayon true"'   # que no se apague la pantalla

Todo lo que sigue lo hice por adb shell + su -c. Un detalle que parece una boludez y te hace perder una hora: el quoting de su -c con comandos compuestos se rompe. Si necesitás varias líneas, escribí un .sh en /data/local/tmp y ejecutalo:

adb push script.sh /data/local/tmp/script.sh
adb shell 'su -c "sh /data/local/tmp/script.sh"'

Intento 1: los datos en reposo

Lo primero que uno piensa: agarro los archivos de la app y busco la clave.

adb shell 'su -c "ls -R /data/data/com.ls.smartlife"'

Lo que hay adentro:

Archivo Qué es
files/thingmmkv MMKV (el key-value store nativo que reemplazó a SharedPreferences)
shared_prefs/global_preference.xml preferencias, con valores cifrados
databases/thingsmart_stat_encrypted.db SQLite “encrypted” (el nombre ya adelanta)
files/log/**.xlog logs de Tencent Mars xlog: comprimidos y cifrados

Busqué la clave ahí, obviamente:

adb shell 'su -c "grep -a -i localkey /data/data/com.ls.smartlife/files/thingmmkv"'

Nada. Los valores de MMKV están cifrados con una clave que la app deriva de app_global_base_key / preferences_global_key, y los logs de Mars usan su propio esquema de cifrado + compresión. En reposo no hay nada legible. Confirmado también con strings sobre el MMKV: puro ruido.

Moraleja: si el dato está cifrado con una clave derivada dentro del proceso, no lo vas a sacar copiando archivos. Hay que preguntarle a la app, ya descifrado, en memoria.


Intento 2: hurgar en la memoria

El heap de Java

Android tiene un comando para volcar el heap de un proceso:

adb shell 'su -c "am dumpheap com.ls.smartlife /data/local/tmp/heap.hprof"'

Error:

java.lang.SecurityException: Process not debuggable

am dumpheap solo funciona con apps debuggable=true. Repackear el APK para volverla debuggable rompe la firma, y la app verifica firma en varios lados (adiós login). Descartado.

La memoria nativa

Plan B: leer /proc/<pid>/mem y buscar la clave. Suena fácil hasta que te acordás de un detalle de ART: los String de Java viven en UTF-16LE. Si buscás localKey en ASCII no encontrás nada, porque en memoria está l\0o\0c\0a\0l\0K\0e\0y\0.

Volqué las regiones rw anónimas y busqué el patrón UTF-16. Encontré localKey… pero solo en plantillas internas del framework de mini-apps, no el valor real. El dato no estaba residente en ese momento (o el bean todavía no se había cargado, o el GC lo había movido).

Moraleja: buscar en memoria es tirar un tarro al océano. Sirve para entender qué hay, pero no es determinista: dependés de que el objeto esté vivo y en la región que leíste.


La app detecta root: Magisk DenyList

Con el teléfono rooteado, la app no arrancaba o se cerraba al login. Busqué los chequeos en el DEX:

unzip -o base.apk 'classes*.dex' -d dex/
strings dex/classes*.dex | grep -E '/su$|test-keys|frida|Xposed'

Aparecían, entre otros:

/sbin/su
/system/bin/su
/system/xbin/su
test-keys
frida-agent
frida.server
XposedBridge.jar

En este caso el que disparaba era /sbin/su (típico de Magisk en Android 7).

La solución no es desrootear: es Magisk DenyList, que hace que Magisk se “esconda” para los procesos de esa app (desmonta los paths y oculta su solo ahí).

adb shell 'su -c "magisk --denylist add com.ls.smartlife"'
adb shell 'su -c "magisk --denylist enable"'
adb shell 'su -c "magisk --denylist ls | grep smartlife"'
# com.ls.smartlife|com.ls.smartlife

En mi Magisk (30.7) no hizo falta reiniciar: cerré la app, la abrí, y el login y la home funcionaron. La app queda con root, pero sin verlo.

Ojo: DenyList es preventivo. Si la app ya arrancó sin estar en la lista, matala (am force-stop) y abrila de nuevo. No alcanza con agregarla.


Frida: la parte que casi no sale

Con root y DenyList listo, el plan era enganchar el SDK con Frida. Acá se juntaron cuatro problemas distintos que parecían uno solo.

1) La arquitectura

El teléfono reporta armv7l. Si bajás frida-server arm64, no arranca (o arranca y crashea al inyectar). Tiene que ser arm.

2) La versión tiene que coincidir EXACTA

Cliente y servidor con versiones distintas = el clásico:

frida.TransportError: connection closed

Instalé el cliente con la misma versión del server:

python3 -m venv frvenv
./frvenv/bin/pip install 'frida==<VERSION>'   # = la del frida-server
./frvenv/bin/python -c 'import frida; print(frida.__version__)'

3) El server, escuchando solo en loopback

frida-server abre un puerto que permite ejecutar código. No lo expongas en 0.0.0.0 en la WiFi. Escuchá en loopback y pasá por adb forward:

adb shell 'su -c "nohup /data/local/tmp/fsrv -l 127.0.0.1:27042 >/dev/null 2>&1 &"'
adb forward tcp:27042 tcp:27042

Y verificalo desde Python:

import frida
dev = frida.get_device_manager().add_remote_device("127.0.0.1:27042")
print(len(dev.enumerate_processes()))   # p.ej. 106

Si te da Address already in use, ya había un server corriendo (o quedó el forward).

4) attach falla, spawn funciona

Este fue el que me volvió loco:

dev.attach(pid)
# frida.InvalidArgumentError: unable to open library: No such file or directory

El mismo error con cualquier proceso ya en ejecución. Pero dev.spawn("com.ls.smartlife") andaba perfecto. La inyección en un proceso existente fallaba al cargar el agente; al hacer spawn el agente se carga en el fork y no hay problema.

Y además, para este caso spawn es mejor: querés el hook instalado antes de que la app lea el MMKV. El flujo correcto:

pid = dev.spawn(pkg)      # arranca suspendida
s = dev.attach(pid)       # attach al PID recién creado: esto sí funciona
sc = s.create_script(js)
sc.load()
dev.resume(pid)           # recién acá la app empieza a correr

Detalle: si tenés pkill -f fsrv en el mismo su -c que arranca el server, el patrón matchea la línea de comandos del propio shell y se autodestruye (Terminated). Separá los comandos o usá pkill -x.


Reconocimiento de clases

No se puede hookear a ciegas: el SDK viene ofuscado y los nombres cambian. Primero listé las clases ya cargadas que me interesaban:

Java.perform(function(){
  var res = {gson:[], mmkv:[], devbean:[]};
  Java.enumerateLoadedClasses({
    onMatch: function(n){
      if (/gson/i.test(n) && n.split('.').pop().match(/^Gson/i)) res.gson.push(n);
      if (/mmkv/i.test(n)) res.mmkv.push(n);
      if (/DeviceBean$/.test(n)) res.devbean.push(n);
    },
    onComplete: function(){ send(res); }
  });
});

Hallazgos:

Lo que asumí Lo que era en realidad
com.google.gson.Gson No existe: Gson está shadeado con otro paquete
com.tencent.mmkv.MMKV com.thingclips.smart.mmkv.MMKV
DeviceBean Se carga tarde (y además no hacía falta)

El primer intento con Gson explotó con TypeError: cannot read property 'overload' of undefined, y el de MMKV con ClassNotFoundException. Ahí aprendí: primero enumerar, después hookear.


El hook que da la clave

La idea: la app guarda el estado de los dispositivos en MMKV. En disco está cifrado, pero decodeString() devuelve el JSON en claro. Engancho decodeString (y encodeString, para capturar también lo que escribe), filtro los strings que contienen localKey y listo.

function report(src, s){
  if (typeof s !== "string" || s.length < 20) return;
  if (s.indexOf("localKey") < 0 && s.indexOf("local_key") < 0) return;
  var m = s.match(/"?local_?[kK]ey"?\s*[:=]\s*"?([A-Za-z0-9+\/=]{8,40})/g);
  send({src: src, match: m});
}

Java.perform(function(){
  send("ready");

  var M = Java.use("com.thingclips.smart.mmkv.MMKV");
  ["decodeString","encodeString"].forEach(function(mn){
    M[mn].overloads.forEach(function(ov){
      ov.implementation = function(){
        var r = ov.apply(this, arguments);
        try {
          [].slice.call(arguments).forEach(function(x,i){
            var s = String(x); if (s && s.length > 20) report("MMKV."+mn+" arg"+i, s);
          });
          report("MMKV."+mn+" ret", String(r));
        } catch(e){}
        return r;
      };
    });
  });

  // Además del store nativo, el manager de la app
  var MG = Java.use("com.thingclips.smart.android.base.mmkv.manager.MMKVManager");
  ["getString","putString"].forEach(function(mn){
    MG[mn].overloads.forEach(function(ov){
      ov.implementation = function(){
        var r = ov.apply(this, arguments);
        try {
          [].slice.call(arguments).forEach(function(x,i){
            var s = String(x); if (s && s.length > 20) report("MMKVManager."+mn+" arg"+i, s);
          });
          report("MMKVManager."+mn+" ret", String(r));
        } catch(e){}
        return r;
      };
    });
  });
});

El lanzador (spawn + espera):

import frida, time, json

dev = frida.get_device_manager().add_remote_device("127.0.0.1:27042")
pkg = "com.ls.smartlife"

try: dev.kill(pkg)          # matar la instancia vieja
except Exception: pass
time.sleep(1)

pid = dev.spawn(pkg)        # arranca suspendida
s   = dev.attach(pid)
sc  = s.create_script(open("hook.js").read())
sc.on("message", lambda m, d: print("MSG:", json.dumps(m.get("payload"))[:1200])
      if m["type"] == "send" else print("ERR:", m.get("description")))
sc.load()
dev.resume(pid)             # ahora sí, la app corre con el hook puesto
time.sleep(60)              # tiempo para que cargue la home y lea el store
s.detach()

Salida (redactada):

MSG: "ready"
MSG: "hooked MMKV"
MSG: {"src": "MMKV.decodeString ret", "match": ["\"localKey\":\"<LOCAL_KEY>"]}
MSG: {"src": "MMKVManager.putString arg1", "match": ["\"localKey\":\"<LOCAL_KEY>"]}

En la vida real aparecieron varias claves (equipos BLE, otros dispositivos, cuentas). Por eso el paso siguiente es asociar cada clave a su devId.


Asociar la clave al dispositivo correcto

Capturando el JSON completo (no solo el match) se ve todo junto:

{
  "devId": "<DEVICE_ID>",
  "name": "<NOMBRE_DEL_ROBOT>",
  "productId": "<PRODUCT_KEY>",
  "category": "sd",
  "localKey": "<LOCAL_KEY>",
  "mac": "<MAC>"
}

Y después el chequeo cruzado con el broadcast de la LAN: el gwId que anuncia el robot por UDP tiene que ser igual al devId de la nube. Si coincide, es ese equipo y no el del vecino.

nube:  devId = <DEVICE_ID>
LAN:   gwId  = <DEVICE_ID>     ✅

Con eso terminó la parte difícil. La local_key es de 16 caracteres y funciona como contraseña del protocolo local.


Bonus: el schema de DPs

Un problema aparte: los IDs de los data points (DPs) no son estándar entre modelos. Si asumís que “el DP 6 es la batería” te podés comer un garrón. La app tiene el schema real cacheado en el MMKV, dentro de schemaInfo.dpCodeSchemaMap. Se puede extraer con el mismo truco:

var seen = {};
Java.perform(function(){
  var M = Java.use("com.thingclips.smart.mmkv.MMKV");
  M.decodeString.overloads.forEach(function(ov){
    ov.implementation = function(){
      var r = ov.apply(this, arguments);
      try {
        var s = String(r);
        if (s && s.indexOf('dpCodeSchemaMap') > 0 && !seen[s.length]) {
          seen[s.length] = 1;
          var o = JSON.parse(s);
          var map = o[0].schemaInfo.dpCodeSchemaMap, out = [];
          for (var k in map) {
            var p = JSON.parse(map[k].property);
            out.push([map[k].id, map[k].code, map[k].mode, p.type].join("|"));
          }
          send({product: o[0].id, dp: out});
        }
      } catch(e){}
      return r;
    };
  });
});

Resultado típico de un robot categoría sd:

ID Código Tipo
1 switch bool
2 switch_go bool
3 mode enum (standby, random, wall_follow, spiral, …)
4 direction_control enum (forward, backward, turn_left, turn_right, stop)
5 status enum (charging, charge_done, fault, …)
6 residual_electricity valor 0-100
7 edge_brush valor 0-100
8 roll_brush valor 0-100
9 filter valor 0-100
10-12 reset_* bool
13 seek bool (hacerlo sonar)
14 suction enum (small, normal, strong)
17 clean_time valor (min)
18 fault bitmap

Y el bitmap de fallas debería ser oro puro: es el tipo de sensor que el equipo expone. En este modelo, en la práctica, quedó siempre en cero (lo cuento más abajo).

bit 0  FAULT_CLIFF      sensor de precipicio
bit 1  FAULT_IMP        impacto (bumper)
bit 2  FAULT_WHL        rueda
bit 3  FAULT_BRUSH      cepillo
bit 4  FAULT_FAN        ventilador
bit 5  FAULT_ROLLBRUSH  cepillo central
bit 6  FAULT_LOWPOWER   batería baja
...

Nada de lidar, ni cámara, ni encoders, ni IMU. Ese detalle es el que después define qué se puede y qué no se puede hacer con el robot.


Control local: tinytuya

Con device_id, IP, local_key y versión 3.3, el control local es literalmente esto:

import tinytuya

d = tinytuya.Device(
    "<DEVICE_ID>",
    "192.0.2.88",       # IP del robot en la LAN
    "<LOCAL_KEY>",
    version=3.3,
    persist=True,
)
print(d.status())

Salida real (DPs crudos):

{"dps": {"1": true, "2": false, "3": "standby", "4": "stop", "5": "charge_done",
         "6": 100, "7": 100, "8": 50, "9": 100, "10": true, "11": false,
         "12": true, "13": false, "14": "normal", "17": 0, "18": 0}}

De ahí sale todo: batería (6), estado de carga (5), succión (14), vida de cepillos (7, 8) y filtro (9). Los comandos son set_value(dp, valor).

Con eso armé un CLI + interfaz web (control, monitoreo, programación) que no depende de la nube para nada.

Ojo con la local_key: es la contraseña del robot. Quien la tenga y esté en tu LAN lo controla. No la subas a git. En mi repo está en config.json, ignorado, con permisos 600.


Mapear la casa sin SLAM

El robot no tiene lidar, ni cámara, ni encoders, ni IMU, y su firmware no guarda nada. Pero hay un detalle: si los comandos los mando yo, sé cuánto se movió. Integrando tiempo × velocidad de direction_control sale una pose aproximada, y los obstáculos salen de la única señal de contacto que da el equipo: la parada del robot al chocar. Eso es odometría de comando: el robot pone los motores, la PC lleva la cuenta.

Qué De dónde sale
Pose (x, y, θ) Integrar los comandos (forward, backward, turn_left, turn_right)
Obstáculos La parada del propio robot al chocar (power_go=false)
Cobertura Disco de 17 cm (franja de 34 cm) más la mopa corrida 25 cm atrás

Calibrar (con la mopa puesta)

La velocidad cambia con el piso y con lo que arrastres. Dos mediciones y listo:

./run.sh calibrar dist     # avanza 10 s; medís con cinta cuánto avanzó
./run.sh calibrar giro     # gira 10 s; contás los grados

En mi caso quedó en 0,28 m/s y 107 °/s sobre cerámica. El detalle importante: yo siempre uso la mopa colgada atrás con un hilo, así que calibré con la mopa puesta. El arrastre baja la velocidad y cambia cómo patina en los giros; si calibrás sin mopa, el mapa sale estirado. Y como la mopa limpia detrás del robot y no debajo, hay que declararla en el mapa para que la franja barrida se dibuje donde realmente pasó:

./run.sh calibrar set --mopa 0.25 --mopa-ancho 0.30

La mía cuelga de un hilo y sobresale unos 25 cm, así que no queda rígida: el hilo le permite bailar y a veces se traba en el cepillo o en las ruedas. No hay sensor de mopa trabada; si la ves arrastrando de costado, acortá el hilo.

Que maneje sola

Manejar una casa entera con WASD es un embole de horas, así que la PC conduce: avanza hasta chocar, marca el obstáculo, gira 90°, se corre 35 cm y vuelve por una línea paralela. Corta por tiempo o con batería por debajo del 15 %, y cada 5 segundos imprime distancia, área y choques para que puedas mirarlo avanzar desde el log.

./run.sh explorar --nuevo --minutos 10 --mapa living.json

Hay tres estrategias (--estrategia): serpiente (la de arriba, pasadas paralelas; la que mejor cubre un ambiente cerrado), rebote (tramos largos de 4 a 6 m y giro al chocar, para ambientes abiertos donde no conviene volver por la misma lane) y frontera (va siempre hacia lo no barrido; con odometría sola se va en línea recta, la dejo documentada como experimento fallido).

Antes de arrancar hace una prueba de medio segundo y te pregunta si se movió: así no llena el mapa con movimiento inventado si el robot no obedece. Porque ese es el punto más engañoso de la odometría: no mide el mundo, mide lo que le mandaste. Si el robot está trabado contra una pared y le mandás avanzar, el mapa avanza igual.

Las tres cosas que solo aparecen con el robot en el piso

La primera corrida real sirvió para descubrir que la teoría tenía tres agujeros.

La local_key cambia si volvés a vincular el robot. Después de pasarlo a la red nueva, ./run.sh status empezó a devolver Unexpected Payload from Device (Err 904), aunque el scan seguía mostrando el mismo device_id y la misma IP. La app lo había re-vinculado y con eso rotó la clave; se vuelve a extraer con Frida y listo. Moraleja: si el 904 aparece de golpe, no es la red, es la clave.

El firmware corta el avance si no recibe la orden. Un solo direction_control: forward mueve el robot un segundo y medio y lo frena (seguridad). La PC, mientras tanto, integraba los 4 m completos de la pasada: el mapa crecía y el robot ni se movía. Se arregla reenviando la orden cada 0,6 s mientras dura el movimiento.

El DP de falla no reporta nada. El bitmap fault (DP 18) quedó en 0 toda la sesión, incluso levantando el robot en el aire con la mano. Pero el firmware sí hace algo cuando choca: se frena solo (power_go=false, status=standby). Esa parada es el sensor de choque que hay: si la PC está mandando forward y el robot pasa a standby, se cuenta impacto, se marca el obstáculo al frente y se gira. El robot no dice “choqué”, dice “me detuve”, y con eso alcanza.

Primera sesión: 293 metros y una silla

25 minutos, 293 m recorridos, 42 m² cubiertos y 199 choques. Pero once de esos choques fueron en el mismo metro cuadrado: se quedó abajo de una silla y el patrón serpiente no distingue “pared” de “pata de silla”.

Se arregló con memoria de choques: si los últimos cinco impactos cayeron en menos de 0,8 m, el explorador asume que quedó atrapado, retrocede 1,2 m y prueba ángulos hasta salir. En una sesión de 20 minutos el escape se disparó 17 veces y el robot siguió solo.

Por qué una sesión larga no termina nunca

Cuatro sesiones encima del mismo mapa sumaron 1160 m y 187 m², pero el mapa terminó midiendo 22 × 31 m y la pose quedó a 19 m del origen. La casa no mide eso: es deriva.

Cada giro arrastra dos o tres grados de error, y con 500 giros el dibujo se dobla. Peor: probé una estrategia “frontera” (ir siempre hacia lo no barrido) y fue un desastre, porque para el robot siempre hay algo sin barrer más adelante — es su propia deriva. En 18 minutos se fue en línea recta y el mapa terminó midiendo 25 × 64 m.

Conclusión incómoda: sin una referencia externa, la casa entera no se puede terminar de una sentada. No es cuestión de tiempo: es que la posición se va y lo que falta nunca deja de estar adelante.

Lo que sí funciona: un ambiente por sesión

Cada ambiente se mapea con una sesión corta (8 a 10 minutos) y mapa nuevo, así la deriva no llega a deformar nada. Después se pegan todos en el mismo plano con --origen x,y,grados, que mueve la pose a ese punto sin borrar lo ya mapeado:

# living desde el origen
./run.sh explorar --nuevo --minutos 8 --mapa casa.json --origen 0,0,0
# cocina (5,2 m al este del origen)
./run.sh explorar --minutos 8 --mapa casa.json --origen 5.2,0,0
# dormitorio (4 m al norte)
./run.sh explorar --minutos 8 --mapa casa.json --origen 0,4.0,90
./run.sh mapa --mapa casa.json

Los x,y los sacás con una cinta y un croquis rápido del plano: el origen es la esquina de la primera habitación, equis para un lado, ye para el otro. Si no querés medir, unir_mapas.py alinea dos sesiones por correlación de lo barrido (prueba rotaciones de 90° y todas las traslaciones) y las une en un solo plano:

python3 unir_mapas.py living.json entrada.json casa.json
./run.sh mapa --mapa casa.json

En mi caso unió el living y la entrada con 82 % de solape, rotación de 180° y 10,8 m de desplazamiento; el plano quedó en 118,9 m². Es una unión aproximada: si las dos zonas apenas se tocan, conviene la cinta. Medido en el living, 8 minutos dieron 97 m y 22,6 m²; otros 10 minutos encima, 58 m² (es un ambiente abierto con sillones, mesas y sillas, así que el robot vive chocando).

Arrancar con el mapa que ya tenés

explorar sin --nuevo no borra nada: carga el mapa, arranca desde la última pose guardada y le suma. Con --nuevo lo borra (no hay vuelta atrás).

./run.sh mapa --mapa casa.json                      # qué hay: resumen + dibujo
./run.sh explorar --minutos 8 --mapa casa.json      # sigue desde donde terminó

Si el robot no está en esa pose (lo levantaste, lo cargaste, lo mandaste a la base), le decís dónde quedó:

./run.sh explorar --minutos 8 --mapa casa.json --origen 5.2,0,0

Y si las sesiones arrancan siempre con el robot sobre el cargador, conviene que la base sea el origen del plano:

./run.sh base --nuevo --mapa casa.json                  # robot sobre la base: base = (0,0)
./run.sh explorar --minutos 8 --mapa casa.json --origen 0,0,0
./run.sh volver --mapa casa.json                        # vuelve si está a menos de 3,5 m

Tres cosas que ahorran frustración:

  • En ambientes con muchos muebles, bajá el corrimiento entre pasadas: --paso-lateral 0.25 (por defecto 0.35). Tarda más pero deja menos huecos.
  • Un mapa de 119 m² para un departamento chico no es la casa: es deriva. Si el plano ya salió deformado, empezá un mapa nuevo anclado en la base en vez de seguir sumando.
  • El mapa guarda pose, libre, obstaculos y eventos; cortar con pkill no pierde nada porque el explorador guarda al salir.

Para el baño y los ambientes cerrados: la puerta tiene que estar abierta y sin escalón de más de 1,5 cm. El robot mide ~9 cm de alto y el sensor de precipicio frena en el umbral; si la puerta estaba cerrada no es que faltó mapear, es que no entró.

Chuleta de comandos

Todo lo que hay en run.sh, agrupado. El --config es global (por defecto config.json).

Descubrir y leer

Comando Qué hace
./run.sh scan Busca el robot en la LAN (IP, device_id, versión)
./run.sh spec Autodetecta el schema de DP desde la nube
./run.sh raw Vuelca todos los DP crudos
./run.sh status Batería, estado y modo, legible
./run.sh status --json Lo mismo, para scripts
./run.sh watch Monitoreo continuo (default cada 3 s; --interval)

Control

Comando Qué hace
./run.sh start --mode smart --suction strong Arranca a limpiar
./run.sh pause / ./run.sh stop Pausa / standby
./run.sh dock Vuelve a la base (el firmware busca el haz IR; el mapa no participa)
./run.sh base --nuevo --mapa casa.json Graba la base en el mapa (correr con el robot sobre el cargador)
./run.sh volver --mapa casa.json Vuelve por odometría hasta la base si está a menos de 3,5 m
./run.sh locate Hace sonar el robot
./run.sh mode <modo> Cambia el modo de limpieza
./run.sh suction <nivel> Cambia la succión
./run.sh direction forward Un segundo de movimiento (backward, turn_left, turn_right, stop)

Calibrar

Comando Qué hace
./run.sh calibrar dist Avanza 10 s; medís con cinta
./run.sh calibrar giro Gira 10 s; contás grados
./run.sh calibrar Las dos mediciones seguidas
./run.sh calibrar set --speed 0.28 --turn 107 --cell 0.05 --radio 0.17 --mopa 0.25 --mopa-ancho 0.30 Guarda la calibración

Mapear

Comando Qué hace
./run.sh explorar --nuevo --minutos 8 --mapa living.json Serpiente, mapa nuevo (un ambiente)
./run.sh explorar --minutos 8 --mapa casa.json --origen 5.2,0,0 Sigue el mismo mapa con la pose en ese punto (pegar ambientes)
./run.sh explorar --estrategia rebote --paso-max 6 Tramos largos y giro al chocar: cruza ambientes abiertos
./run.sh explorar --estrategia frontera Va hacia lo no barrido (con odometría sola se va en línea recta; queda como experimento)
./run.sh explorar --paso-lateral 0.35 --giro 90 --paso-max 4 Ajustes de la serpiente
./run.sh explorar --sin-prueba Sin la prueba de movimiento inicial
./run.sh explorar --simular --nuevo --minutos 5 Casa virtual de 5×4 m
./run.sh explorar --simular --ancho 8 --alto 6 Casa virtual más grande
./run.sh manejar / --nuevo WASD con mapa en vivo, sobre el mapa guardado o limpio

Mapa

Comando Qué hace
./run.sh mapa Dibujo ASCII + resumen + últimos eventos
./run.sh mapa --json Todo el mapa (pose, traza, celdas, eventos)
./run.sh mapa --mapa casa.json Otro archivo de mapa
./run.sh mapa --reset Borra el mapa

Web

Comando Qué hace
./run.sh web --port 8787 Interfaz web con el mapa en vivo

Para cortar una exploración a mano: pkill -f "aspiradora.py explorar" (guarda el mapa igual) y después ./run.sh stop.

Probarlo sin robot

--simular levanta una casa virtual de 5×4 m con tres muebles y el mismo modelo de velocidad del robot, así que podés probar la lógica sin sacarlo de la base:

./run.sh explorar --simular --nuevo --minutos 5

En 20 minutos simulados recorrió ~210 m, chocó 177 veces y cubrió ~20 m². En la vida real el error es mayor: el piso cambia, la mopa arrastra y el robot patina.

Lo que sale y lo que no

Aspecto Realidad
Deriva Acumulativa: 1160 m dejaron el mapa en 22 × 31 m. Cada giro suma 2-3°
Alcance 8-10 min por ambiente; más tiempo, más torcido
Precisión Sirve para ver recorrido, cobertura y muebles; no para volver a un punto
Modo random de la app No es mapeable: ahí decide el robot y no sé dónde está
Choques Se detectan por la parada del robot; alguna pausa del firmware puede contarse como choque
fault (DP 18) En este modelo queda en 0: no sirve para detectar impactos
Mopa La franja se corre 25 cm atrás; colgada de un hilo, el borde real baila unos centímetros
Casa entera de una vez No. Sin encoders ni referencia externa, la pose se va antes de terminar
Volver usando el mapa No a más de ~3 m: la pose deriva. dock usa el haz IR del cargador, no el plano
Mover el robot Se puede: arrancá mapa nuevo (--nuevo) o decile dónde quedó (--origen) y uní con unir_mapas.py

Si algún día hace falta un plano de verdad hay dos caminos: una webcam con un marcador ArUco arriba del robot (solvePnP en la PC, sin deriva) o cambiarle el cerebro por una Raspberry Pi con un RPLIDAR. Las dos implican hardware nuevo; la odometría de comando funciona hoy, sin tocar el robot, y con el método por ambiente alcanza para tener la casa entera en un plano aproximado.


Lo que no usé (y por qué)

Alternativa Por qué no
API oficial de Tuya (tinytuya.Cloud) Funciona, pero hay que crear proyecto de desarrollador, sacar Access ID/Secret y vincular la cuenta escaneando un QR. Más pasos manuales y depende de que la app white-label soporte el flujo.
MITM (proxy + CA de sistema) Hay que instalar la CA como certificado de sistema (módulo Magisk), reiniciar, configurar proxy y pelear con el certificate pinning del SDK.
tuya-cloudcutter Requiere resetear el robot a modo pairing y suplantar la nube: el equipo queda desvinculado de la app.
Repackear el APK Rompe la firma; la app verifica firma en varios lados.
Frida + MMKV ✅ Cero interacción manual, no desvincula nada, no toca la nube, tarda minutos.

Tabla de errores y causas

Todo lo que salió mal, con la explicación (para que no te pase):

Síntoma Causa / solución
SecurityException: Process not debuggable en am dumpheap El proceso no es debuggable. No hay forma sin repackear (y romper la firma).
Buscar localKey en /proc/<pid>/mem no encuentra nada ART guarda los strings en UTF-16LE; además el objeto puede no estar vivo.
La app se cierra al abrir con root Root detection. Magisk DenyList para el paquete, cerrar y reabrir.
magisk --sqlite se rompe por quoting en su -c Empujá un .sh a /data/local/tmp y ejecutalo.
frida.TransportError: connection closed Versión cliente ≠ server, arquitectura equivocada, o server caído.
frida.InvalidArgumentError: unable to open library en attach Inyección en proceso existente falla en este equipo. Usar spawn + attach(pid).
Error binding to address ... Address already in use Ya había un server escuchando (o quedó el forward).
pkill -f fsrv imprime Terminated y mata todo El patrón coincide con la línea de comandos del propio shell.
ClassNotFoundException: com.tencent.mmkv.MMKV El SDK usa com.thingclips.smart.mmkv.MMKV.
TypeError: cannot read property 'overload' of undefined (Gson) Gson está shadeado: no existe com.google.gson.Gson. Ir por MMKV.
El JSON del hook viene truncado substring(0, 6000); si el schema es más grande, parseá en el dispositivo y mandá solo lo necesario.
Network Error: Device Unreachable al probar el control La PC está en otra subred que el robot. El control local exige estar en la misma LAN.

Seguridad y limpieza

Después de jugar, apagá el inyector:

adb shell 'su -c "pkill -x fsrv"'
adb forward --remove tcp:27042
adb shell 'su -c "ps | grep fsrv | grep -v grep | wc -l"'   # -> 0

Y del lado del robot:

  • local_key = contraseña. Fuera de git, permisos 600, no la pegues en un chat.
  • Si la cambiás de red, cambia la IP: volvé a escanear.
  • DenyList sirve para que esta app no vea root, pero sigue habiendo root: no es una defensa, es una compatibilidad.

Conclusiones

  1. Si el dato está cifrado en reposo, no lo busques en reposo. Buscalo donde está en claro: dentro del proceso, en la función que lo descifra.
  2. Lo más simple suele ser lo que funciona. Después de volcar memoria, pelear con MITM y leer papers del SDK, la solución fueron 30 líneas de JavaScript sobre decodeString.
  3. Enumerá antes de hookear. El SDK ofusca y renombra todo; asumir nombres de clase es perder tiempo.
  4. spawn > attach cuando querés ver el arranque de una app. Y en este caso puntual, era la única forma.
  5. Root + DenyList + Frida es una combinación ridículamente poderosa para auditar cualquier app Android, incluida la tuya.

El robot ahora se controla por LAN, sin nube. Y de yapa, con la local_key, direction_control y la parada del robot al chocar se puede estimar la odometría y dibujar un mapa aproximado (spoiler: sin lidar ni encoders es un mapa con deriva, pero sirve para ver dónde anduvo). Está todo en Mapear la casa sin SLAM.


Glosario

Término Qué es
DP (data point) Cada campo de estado/comando del dispositivo en Tuya (ej: batería, modo, succión).
local_key Clave de 16 caracteres para el protocolo local (TCP 6668); funciona como contraseña.
gwId / devId Identificador único del dispositivo.
MMKV Key-value store nativo (C++) usado por apps chinas; reemplaza SharedPreferences.
ART Runtime de Android; guarda los String de Java en UTF-16LE.
Magisk DenyList Lista de paquetes para los que Magisk oculta root (paths y binarios).
Frida Framework de instrumentación dinámica: inyecta JS en un proceso y hookea funciones.
spawn vs attach spawn arranca el proceso suspendido con el agente ya cargado; attach se cuelga de uno que ya corre.
hprof Formato del heap dump de Java.
xlog Logger de Tencent Mars: comprimido y cifrado.

Referencias

  • tinytuya — cliente Python para el protocolo local de Tuya.
  • frida — documentación de la API de JavaScript y del CLI.
  • Magisk — DenyList y módulos.
  • MMKV — cómo funciona el store y su cifrado.
  • tuya-cloudcutter — la alternativa que no usé (interesante igual).