petr.polezhaev
359203abfe
- PROTOCOL.md: полная спецификация (KDF, envelope/CBC-цепочка, local_reg, key exchange, commands.json 206/200, datapoint push, тайминги, таблицы свойств шаблонов A/B/F, облачный provisioning). Факты из APK помечены [APK], проверенные живыми экспериментами на AP-WC1E — [ПРОВЕРЕНО НА ПРИБОРЕ]: mDNS только :10276; лимит 2 LAN-сессии (3-я -> 503); принудительный re-key при возрасте сессии >= ~44с (единственный механизм самолечения десинхрона — 400/401 модуль игнорирует); записи не эхируются; delete_session освобождает слот. - LEGACY_ANALYSIS.md: причины рассинхрона (keep-alive 1200с вместо 10-15с + seq_no-фильтр) и перегрузки модуля; требования к новой реализации. - PLAN_CORE_LIBRARY.md: план C++20-библиотеки fglair-core (Linux + ESP-IDF), ключ lanip_key считается статичным, ротация — только ошибка + ручной перепровижининг. - PLAN_HOME_ASSISTANT.md: pyfglair (cffi wheel) + custom component, облачный provisioning только в config flow, ключ виден в диагностике для копирования в ESPHome. - PLAN_ESPHOME.md: external component, только ESP-IDF framework. - tools/probe_reference.py: эталонный клиент протокола (проверен на приборе end-to-end); tools/probe_mdns.py — mDNS-проба. - legacy/: снимок скрипта (апстрим gyro-labs/AirCon, вложенный клон не версионируется); apk/*.apk исключены из версионирования.
269 lines
12 KiB
Python
269 lines
12 KiB
Python
#!/usr/bin/env python3
|
|
"""Эталонный клиент LAN-протокола FGLair (сторона «приложения»).
|
|
|
|
Проверен на реальном модуле AP-WC1E (fw 2.6.17-fgl2). Соответствует
|
|
docs/PROTOCOL.md, включая поведение, подтверждённое живыми тестами:
|
|
- keep-alive каждые 15 c (модуль сам инициирует re-key при возрасте
|
|
сессии >= ~44 c — это штатная ротация, обрабатывается прозрачно);
|
|
- 206/200 в commands.json, NUL-паддинг (Java-вариант);
|
|
- 401 при ошибке расшифровки, 412 при несовпадении key_id;
|
|
- записи не эхируются: оптимистичное обновление + GET-подтверждение;
|
|
- delete_session при выходе (освобождает один из 2 слотов модуля).
|
|
|
|
Использование:
|
|
python probe_reference.py config_kata.json monitor 60
|
|
python probe_reference.py config_kata.json get operation_mode fan_speed
|
|
python probe_reference.py config_kata.json set fan_speed 3
|
|
Зависимости: pycryptodome."""
|
|
import base64, hmac, json, random, socket, string, sys, threading, time
|
|
import http.client
|
|
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
|
from Crypto.Cipher import AES
|
|
|
|
T0 = time.time()
|
|
log = lambda *a: print(f"+{time.time()-T0:7.1f}s", *a, flush=True)
|
|
|
|
def rand_token(n=16):
|
|
return "".join(random.choice(string.ascii_letters + string.digits) for _ in range(n))
|
|
|
|
class Crypto:
|
|
"""Ключи/цепочки по PROTOCOL.md §3. ВНИМАНИЕ: CBC-состояние непрерывно
|
|
в рамках сессии (одно сообщение — следующее продолжает цепочку)."""
|
|
def __init__(self, lanip_key, rnd1, rnd2, t1, t2):
|
|
k = lanip_key.encode()
|
|
b1, b2, s1, s2 = rnd1.encode(), rnd2.encode(), str(t1).encode(), str(t2).encode()
|
|
def m(msg, suf):
|
|
msg = msg + bytes([suf])
|
|
return hmac.digest(k, hmac.digest(k, msg, "sha256") + msg, "sha256")
|
|
A, D = b1 + b2 + s1 + s2, b2 + b1 + s2 + s1
|
|
self.app_sign, self.dev_sign = m(A, 0x30), m(D, 0x30)
|
|
self._e = AES.new(m(A, 0x31), AES.MODE_CBC, m(A, 0x32)[:16])
|
|
self._d = AES.new(m(D, 0x31), AES.MODE_CBC, m(D, 0x32)[:16])
|
|
self.seq = 0
|
|
def enc_sign(self, data) -> bytes:
|
|
self.seq += 1
|
|
raw = json.dumps({"seq_no": self.seq - 1, "data": data},
|
|
separators=(",", ":")).encode()
|
|
n = ((len(raw) + 1 + 15) // 16) * 16 # >=1 NUL, кратно 16
|
|
sign = base64.b64encode(hmac.digest(self.app_sign, raw, "sha256")).decode()
|
|
enc = base64.b64encode(self._e.encrypt(raw.ljust(n, b"\x00"))).decode()
|
|
return json.dumps({"enc": enc, "sign": sign}, separators=(",", ":")).encode()
|
|
def decrypt_validate(self, body: dict):
|
|
ptb = self._d.decrypt(base64.b64decode(body["enc"])).rstrip(b"\x00")
|
|
ok = base64.b64encode(hmac.digest(self.dev_sign, ptb, "sha256")).decode() == body.get("sign")
|
|
return ok, ptb
|
|
|
|
class ReferenceClient:
|
|
def __init__(self, cfg_path, port=10275, keepalive=15.0):
|
|
cfg = json.load(open(cfg_path))
|
|
self.ip, self.dsn = cfg["ip_address"], cfg["dsn"]
|
|
self.key, self.key_id = cfg["lanip_key"], cfg["lanip_key_id"]
|
|
self.port, self.keepalive = port, keepalive
|
|
self.crypto = None
|
|
self.queue = [] # [(payload, note)]
|
|
self.cmd_id = 0
|
|
self.props = {} # кэш значений
|
|
self.pushes = 0
|
|
self.online = threading.Event()
|
|
self.lock = threading.Lock()
|
|
self._ka_stop = threading.Event()
|
|
|
|
# ---------------- HTTP-сервер (входящие от модуля) ----------------
|
|
def _handler(self):
|
|
cli = self
|
|
class H(BaseHTTPRequestHandler):
|
|
protocol_version = "HTTP/1.1"
|
|
def log_message(self, *a): pass
|
|
def _body(self):
|
|
n = int(self.headers.get("Content-Length") or 0)
|
|
return self.rfile.read(n) if n else b""
|
|
def _send(self, code, body=b""):
|
|
self.send_response(code)
|
|
self.send_header("Content-Type", "application/json; charset=utf-8")
|
|
self.send_header("Content-Length", str(len(body)))
|
|
self.end_headers()
|
|
if body: self.wfile.write(body)
|
|
def do_POST(self):
|
|
body, path = self._body(), self.path.split("?")[0]
|
|
if path == "/local_lan/key_exchange.json":
|
|
ke = json.loads(body)["key_exchange"]
|
|
if ke.get("ver") != 1 or ke.get("proto") != 1:
|
|
self._send(426, b'{"error":"Unsupported crypto version"}'); return
|
|
if ke.get("key_id") != cli.key_id:
|
|
log(f"KEY ROTATED: {ke.get('key_id')} != {cli.key_id} -> 412")
|
|
self._send(412, b'{"error":"Keys do not match"}'); return
|
|
rnd2, t2 = rand_token(), time.monotonic_ns()
|
|
cli.crypto = Crypto(cli.key, ke["random_1"], rnd2, ke["time_1"], t2)
|
|
log(f"KEY_EXCHANGE (re-key ok, random_1={ke['random_1']!r})")
|
|
self._send(200, json.dumps(
|
|
{"random_2": rnd2, "time_2": t2}).encode()); return
|
|
if path.endswith("/local_lan/property/datapoint.json"):
|
|
if cli.crypto is None:
|
|
self._send(401, b'{"error":"Decryption failed"}'); return
|
|
ok, ptb = cli.crypto.decrypt_validate(json.loads(body))
|
|
if not ok:
|
|
log("DATAPPOINT: подпись/расшифровка НЕ сошлись -> 401")
|
|
self._send(401, b'{"error":"Decryption failed"}'); return
|
|
cli.pushes += 1
|
|
try:
|
|
d = json.loads(ptb)["data"]
|
|
with cli.lock:
|
|
cli.props[d["name"]] = d.get("value")
|
|
log(f"PUSH {d['name']} = {d.get('value')}"
|
|
f" (query={self.path.split('?', 1)[-1] or '-'})")
|
|
except Exception as e:
|
|
log("PUSH parse error:", e)
|
|
self._send(200); return
|
|
if path.endswith("/ack.json"):
|
|
log("ACK", body[:120]); self._send(200); return
|
|
self._send(404)
|
|
def do_GET(self):
|
|
if self.path.split("?")[0] == "/local_lan/commands.json":
|
|
if cli.crypto is None:
|
|
self._send(401, b'{"error":"Decryption failed"}'); return
|
|
with cli.lock:
|
|
payload, note = cli.queue.pop(0) if cli.queue else ({}, "empty")
|
|
rest = len(cli.queue)
|
|
code = 206 if rest else 200
|
|
log(f"COMMANDS -> {note} [{code}]")
|
|
self._send(code, cli.crypto.enc_sign(payload)); return
|
|
self._send(404)
|
|
return H
|
|
|
|
# ---------------- исходящие ----------------
|
|
def local_reg(self, notify, first=False):
|
|
method = "POST" if first else "PUT"
|
|
url = f"/local_reg.json" + (f"?dsn={self.dsn}" if first else "")
|
|
body = json.dumps({"local_reg": {"ip": self._my_ip(), "notify": 1 if notify else 0,
|
|
"port": self.port, "uri": "/local_lan"}})
|
|
c = http.client.HTTPConnection(self.ip, timeout=10)
|
|
try:
|
|
c.request(method, url, body=body, headers={
|
|
"Accept": "application/json", "Connection": "keep-alive",
|
|
"Content-Type": "application/json", "Accept-Encoding": "gzip"})
|
|
r = c.getresponse(); r.read()
|
|
if r.status == 503:
|
|
log("local_reg -> 503: нет свободных слотов (заняты 2 сессии)")
|
|
return r.status
|
|
finally:
|
|
c.close()
|
|
|
|
@staticmethod
|
|
def _my_ip():
|
|
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
|
|
try:
|
|
s.connect(("10.255.255.255", 1)); return s.getsockname()[0]
|
|
finally:
|
|
s.close()
|
|
|
|
def queue_get(self, prop):
|
|
with self.lock:
|
|
self.cmd_id += 1
|
|
cid = self.cmd_id
|
|
self.queue.append(({"cmds": [{"cmd": {
|
|
"method": "GET", "resource": "property.json?name=" + prop,
|
|
"uri": "/local_lan/property/datapoint.json", "data": "",
|
|
"cmd_id": cid}}]}, f"GET {prop}"))
|
|
|
|
def queue_set(self, prop, value):
|
|
with self.lock:
|
|
self.queue.append(({"properties": [{"property": {
|
|
"base_type": "integer", "name": prop, "value": value,
|
|
"id": rand_token(8)}}]}, f"SET {prop}={value}"))
|
|
self.props[prop] = value # оптимистично: эха нет
|
|
|
|
def queue_delete_session(self):
|
|
with self.lock:
|
|
self.queue.append(({"cmds": [{"cmd": {"cmd_id": 0, "method": "DELETE",
|
|
"resource": "local_reg.json", "data": "delete_session",
|
|
"uri": "/local_lan"}}]}, "DELETE session"))
|
|
|
|
# ---------------- жизненный цикл ----------------
|
|
def start(self, timeout=15):
|
|
srv = ThreadingHTTPServer(("0.0.0.0", self.port), self._handler())
|
|
srv.handle_error = lambda *a: None # RST от модуля — норма
|
|
threading.Thread(target=srv.serve_forever, daemon=True).start()
|
|
self._srv = srv
|
|
st = self.local_reg(notify=0, first=True)
|
|
t0 = time.time()
|
|
while time.time() - t0 < timeout:
|
|
if self.crypto and self.pushes >= 0 and self._activated:
|
|
break
|
|
time.sleep(0.05)
|
|
if not self._activated:
|
|
raise RuntimeError("сессия не активировалась (нет опроса commands.json после KE)")
|
|
threading.Thread(target=self._keepalive_loop, daemon=True).start()
|
|
self.online.set()
|
|
|
|
_activated = False
|
|
def notify_activation(self):
|
|
self._activated = True
|
|
|
|
def _keepalive_loop(self):
|
|
while not self._ka_stop.wait(self.keepalive):
|
|
try:
|
|
notify = bool(self.queue)
|
|
self.local_reg(notify=notify)
|
|
except Exception as e:
|
|
log("keep-alive error:", e)
|
|
|
|
def stop(self):
|
|
self._ka_stop.set()
|
|
try:
|
|
self.queue_delete_session()
|
|
self.local_reg(notify=True)
|
|
time.sleep(2)
|
|
except Exception:
|
|
pass
|
|
self._srv.shutdown()
|
|
|
|
# ------------------------------------------------------------------
|
|
def patch_activation(cli):
|
|
"""Активация = первый GET commands.json после KE."""
|
|
orig = cli._handler
|
|
def wrapper():
|
|
H = orig()
|
|
class H2(H):
|
|
def do_GET(self):
|
|
cli.notify_activation()
|
|
H.do_GET(self)
|
|
return H2
|
|
cli._handler = wrapper
|
|
|
|
def main():
|
|
if len(sys.argv) < 3:
|
|
print(__doc__); return
|
|
cfg, cmd = sys.argv[1], sys.argv[2]
|
|
cli = ReferenceClient(cfg)
|
|
patch_activation(cli)
|
|
cli.start()
|
|
log("сессия установлена")
|
|
try:
|
|
if cmd == "get":
|
|
for p in sys.argv[3:]:
|
|
cli.queue_get(p)
|
|
cli.local_reg(notify=True)
|
|
time.sleep(8)
|
|
elif cmd == "set":
|
|
prop, val = sys.argv[3], int(sys.argv[4])
|
|
cli.queue_set(prop, val)
|
|
time.sleep(0.3)
|
|
cli.local_reg(notify=True)
|
|
time.sleep(3)
|
|
cli.queue_get(prop) # GET-подтверждение (эха нет)
|
|
cli.local_reg(notify=True)
|
|
time.sleep(5)
|
|
elif cmd == "monitor":
|
|
for p in ("operation_mode", "fan_speed", "adjust_temperature",
|
|
"display_temperature", "wifi_led_enable"):
|
|
cli.queue_get(p)
|
|
cli.local_reg(notify=True)
|
|
time.sleep(int(sys.argv[3]) if len(sys.argv) > 3 else 60)
|
|
log("кэш свойств:", json.dumps(cli.props, ensure_ascii=False))
|
|
finally:
|
|
cli.stop()
|
|
log("сессия закрыта (delete_session)")
|
|
|
|
if __name__ == "__main__":
|
|
main()
|