Cómo extraje la localKey a mi aspiradora Tuya: reversing de una app Android con root, Frida y MMKV
Escuchar este artículo
“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
- El objetivo
- TL;DR
- Reconocimiento: es un Tuya disfrazado
- Conectar el teléfono (root) por ADB
- Intento 1: los datos en reposo
- Intento 2: hurgar en la memoria
- La app detecta root: Magisk DenyList
- Frida: la parte que casi no sale
- Reconocimiento de clases
- El hook que da la clave
- Asociar la clave al dispositivo correcto
- Bonus: el schema de DPs
- Control local: tinytuya
- Mapear la casa sin SLAM
- Lo que no usé (y por qué)
- Tabla de errores y causas
- Seguridad y limpieza
- Conclusiones
- 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:
- Es Tuya y está en mi LAN.
- El
gwIdque anuncia por broadcast tiene que coincidir con eldevIdque la app guarda. Es mi chequeo cruzado para no confundirme de equipo. - Protocolo 3.3 con
encrypt: True→ AES-128-ECB conmd5(local_key)como clave. Sinlocal_keyno 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 fsrven el mismosu -cque 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á enconfig.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,obstaculosyeventos; cortar conpkillno 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
- 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.
- 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. - Enumerá antes de hookear. El SDK ofusca y renombra todo; asumir nombres de clase es perder tiempo.
spawn>attachcuando querés ver el arranque de una app. Y en este caso puntual, era la única forma.- 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).