adbproxy 0.1.0__py3-none-any.whl

adbproxy/observers/shell.py

@@ -0,0 +1,371 @@
+import re
+import threading
+
+from adbproxy.config import IDLE_TIMEOUT, MAX_CMD, MAX_V2_BUF
+from adbproxy.protocols.payload.shell_v2 import split_v2_frames
+from adbproxy.protocols.smart_socket.classifier import ServiceClassifier
+
+
+class ShellSession:
+    """处理 shell 服务的命令/输出配对与 PTY 回显/提示符剥离。
+    非 shell 流（host: / sync: 等）由 StreamBuffer 走原碎片缓冲路径或委托 SyncSession。
+    """
+
+    # shell_mode 取值：None / oneshot_raw / oneshot_v2 / interactive_pty / interactive_v2
+    # AOSP shell_service 默认 PS1：user@host:cwd# / ...:/ $，覆盖 root@device:/ # 等
+    prompt_re = re.compile(rb"\r?\n?[A-Za-z0-9._-]+@[A-Za-z0-9._-]+:[^\r\n]*[#$] ")
+
+    def __init__(self, logger):
+        self.logger = logger
+        self.lock = threading.Lock()
+        self.shell_mode = None
+        self.is_v2 = False
+        self.has_echo = False
+        # 拆为 client/server 独立缓冲，避免单缓冲被双方共用导致串扰触发 v2_corrupt_s 粘性降级
+        self.c_v2_buf = bytearray()  # client 侧 v2 半包重组缓冲
+        self.s_v2_buf = bytearray()  # server 侧 v2 半包重组缓冲
+        self.v2_corrupt_c = False  # client 侧 v2 解析失败标志
+        self.v2_corrupt_s = False  # server 侧 v2 解析失败标志
+        self.pending_cmd = None
+        self.cmd_buf = bytearray()
+        self.out_buf = bytearray()
+        # P2: client stdin 展示缓冲（只读旁路，与 cmd_buf 解耦，不影响 _maybe_commit_cmd 配对）
+        self.in_disp_buf = bytearray()
+        self.idle_timer = None
+        self._idle_gen = (
+            0  # idle Timer 世代号：_reset_idle 自增，回调校验防竿态多跑一次 flush
+        )
+
+    @property
+    def active(self):
+        return self.shell_mode is not None
+
+    def set_mode_from_service(self, svc):
+        """首帧调用：按 service 串定 shell 模式与 has_echo。回显判据 = type==kPty。"""
+        kind, args, cmd = ServiceClassifier.parse_service(svc)
+        if kind != "shell":
+            self.shell_mode = None
+            return
+        self.is_v2 = "v2" in args
+        has_raw = "raw" in args
+        has_pty = "pty" in args
+        # 对应 daemon/services.cpp:103-113：type = cmd.empty()?kPty:kRaw；若 pty arg 则覆盖 kPty
+        self.has_echo = has_pty or (cmd == "" and not has_raw)
+        if cmd:
+            self.shell_mode = "oneshot_v2" if self.is_v2 else "oneshot_raw"
+            self.pending_cmd = self._normalize_cmd(cmd.encode())
+        else:
+            self.shell_mode = "interactive_v2" if self.is_v2 else "interactive_pty"
+
+    def on_client(self, data):
+        with self.lock:
+            self._reset_idle()
+            if self.shell_mode == "interactive_v2":
+                self._on_client_v2(data)
+            elif self.shell_mode == "interactive_pty":
+                self._on_client_nonv2(data)
+            # oneshot：命令已在 service 串，此处通常无 stdin
+
+    def _on_client_v2(self, data):
+        self.c_v2_buf.extend(data)
+        if self.v2_corrupt_c:
+            return
+        frames, leftover, ok = split_v2_frames(self.c_v2_buf)
+        if not ok:
+            self.v2_corrupt_c = True
+            return
+        self.c_v2_buf = leftover
+        for id_, payload in frames:
+            if id_ == 0:  # stdin
+                self.cmd_buf.extend(payload)
+                # P2: client stdin 展示缓冲累积（只读旁路，与 cmd_buf 配对解耦，idle flush 打 [pty-input]）
+                self.in_disp_buf.extend(payload)
+                self._maybe_commit_cmd()
+            # id 4(window change)/5(close) 忽略
+        if len(self.cmd_buf) > MAX_CMD:
+            self.cmd_buf = self.cmd_buf[:MAX_CMD]  # 截断而非静默清空
+            self.logger.event("[!] shell cmd over MAX_CMD, truncated")
+
+    def _on_client_nonv2(self, data):
+        self.cmd_buf.extend(data)
+        # P2: interactive_pty stdin 展示缓冲累积（只读旁路，与 cmd_buf 配对解耦）
+        self.in_disp_buf.extend(data)
+        self._maybe_commit_cmd()
+        if len(self.cmd_buf) > MAX_CMD:
+            self.cmd_buf = self.cmd_buf[:MAX_CMD]  # 截断而非静默清空
+            self.logger.event("[!] shell cmd over MAX_CMD, truncated")
+
+    def _maybe_commit_cmd(self):
+        """client 流累积到 \\r/\\n = 一条命令完成 -> pending_cmd。"""
+        idx = -1
+        for i, b in enumerate(self.cmd_buf):
+            if b in (0x0A, 0x0D):
+                idx = i
+                break
+        if idx < 0:
+            return
+        cmd_bytes = bytes(self.cmd_buf[:idx])
+        self.cmd_buf = self.cmd_buf[idx + 1 :]
+        cmd = self._normalize_cmd(cmd_bytes)
+        if cmd:
+            self.pending_cmd = cmd
+
+    def on_server(self, data):
+        with self.lock:
+            self._reset_idle()
+            if self.shell_mode in ("oneshot_v2", "interactive_v2"):
+                self._on_server_v2(data)
+            else:
+                self._on_server_nonv2(data)
+
+    def _on_server_v2(self, data):
+        self.s_v2_buf.extend(data)
+        if self.v2_corrupt_s:
+            self.logger.debug(f"📤 [Server Stream]: <v2 corrupt, raw {len(data)}B>")
+            return
+        frames, leftover, ok = split_v2_frames(self.s_v2_buf)
+        if not ok:
+            self.v2_corrupt_s = True
+            self.logger.debug("📤 [Server Stream]: <v2 frame invalid, degrading>")
+            return
+        self.s_v2_buf = leftover
+        for id_, payload in frames:
+            if id_ in (1, 2):  # stdout / stderr
+                self.out_buf.extend(payload)
+                if len(self.out_buf) > MAX_V2_BUF:
+                    self._flush_output()
+            elif id_ == 3:  # exit
+                self._flush_output()
+                self._reset_session()
+            # id 4/5 忽略
+
+    def _on_server_nonv2(self, data):
+        if self.pending_cmd is not None:
+            self.out_buf.extend(data)
+            if len(self.out_buf) > MAX_V2_BUF:
+                self._flush_output()
+        else:
+            # 交互 PTY 首屏 banner/提示符（命令尚未提交）：分离提示符行单独标注
+            raw = bytes(data)
+            pos = 0
+            for m in self.prompt_re.finditer(raw):
+                if m.start() > pos:
+                    t = raw[pos : m.start()].decode("utf-8", errors="replace")
+                    if t.strip():
+                        self.logger.debug(f"📤 [Server Stream]: {t!r}")
+                self.logger.debug(
+                    f"📤 [prompt]: {m.group().decode('utf-8', errors='replace')!r}"
+                )
+                pos = m.end()
+            if pos < len(raw):
+                t = raw[pos:].decode("utf-8", errors="replace")
+                if t.strip():
+                    self.logger.debug(f"📤 [Server Stream]: {t!r}")
+
+    def _flush_output(self):
+        """输出当前 out_buf（可重复调用，分块带 $ cmd 标签）。不清 pending_cmd/cmd_buf，
+        不调 _cancel_idle。锁契约：调用方须已持 self.lock（本方法不自取，防 Lock 重入死锁）。
+
+        按 shell_mode 分支（3B 综合方案）：
+        - interactive_v2/interactive_pty：不剥 echo、不查 pending_cmd；out_buf 按行切分打
+          [pty-output]/[prompt]/[pty-partial]，末尾半行保留续接（消除逐字符碎块与 kept raw 噪声）。
+          同时 flush client stdin 展示缓冲（in_disp_buf）打 [pty-input]/[pty-input-partial]。
+        - oneshot_v2/oneshot_raw/None：保留原逻辑（strip_echo + _strip_prompts + $ cmd 标签）。
+        """
+        mode = self.shell_mode
+        if mode in ("interactive_v2", "interactive_pty"):
+            self._flush_interactive()
+            self._flush_interactive_input()
+            return
+        # oneshot 分支（含 shell_mode=None 兜底：首屏未定模式按 oneshot 走，不误入 interactive）
+        if self.pending_cmd is not None and self.out_buf:
+            out = bytes(self.out_buf)
+            if self.has_echo:
+                stripped = self._strip_echo(out, self.pending_cmd)
+                if stripped is not None:
+                    out = stripped
+                else:
+                    self.logger.debug("📥 [echo-strip]: no prefix match, kept raw")
+            # 剥 PTY 提示符行，不混入配对块（#3）
+            out = self._strip_prompts(out)
+            text = out.decode("utf-8", errors="replace").replace("\x00", "")
+            if text.strip():
+                self.logger.event(f"========\n$ {self.pending_cmd}\n{text.strip()}")
+        self.out_buf = bytearray()
+
+    def _flush_interactive(self):
+        """interactive 分支（server 输出）：不剥 echo、不查 pending_cmd；out_buf 按行切分打
+        [pty-output]/[prompt]/[pty-partial]。整行输出后清出已打印部分；末尾无换行的半行打
+        [pty-partial] 并保留在 out_buf 续接（不丢字节）。退格还原+末尾 \\r 剥除由 _emit_pty_line 统一处理。
+        锁契约：调用方须已持 self.lock。"""
+        if not self.out_buf:
+            return
+        raw = bytes(self.out_buf)
+        # 找最后一个行结束符（\r 或 \n）
+        last_nl = raw.rfind(b"\n")
+        last_cr = raw.rfind(b"\r")
+        last = max(last_nl, last_cr)
+        if last < 0:
+            # 整块无换行 → 半行，打 [pty-partial] 不清出（保留续接）
+            self._emit_pty_line(raw, direction="output", partial=True)
+            return  # out_buf 保持原样，等下次续接
+        consumed = raw[: last + 1]  # 到最后换行符为止（含），整行区
+        partial = raw[last + 1 :]  # 末尾半行（无换行），保留续接
+        # 按行切分：每行含其结束符（\r\n / \r / \n）
+        pos = 0
+        for m in re.finditer(rb"\r\n|\r|\n", consumed):
+            line = consumed[pos : m.end()]
+            pos = m.end()
+            self._emit_pty_line(line, direction="output")
+        # 末尾半行
+        if partial:
+            self._emit_pty_line(partial, direction="output", partial=True)
+        # out_buf 仅保留半行（无半行则清空）
+        self.out_buf = bytearray(partial)
+
+    def _flush_interactive_input(self):
+        """interactive 分支（client 输入）：in_disp_buf 按行切分打 [pty-input]/[pty-input-partial]。
+        只读旁路，与 cmd_buf/_maybe_commit_cmd 命令配对逻辑完全解耦（不清 cmd_buf）。
+        退格还原+末尾 \\r 剥除由 _emit_pty_line 统一处理。锁契约：调用方须已持 self.lock。"""
+        if not self.in_disp_buf:
+            return
+        raw = bytes(self.in_disp_buf)
+        last_nl = raw.rfind(b"\n")
+        last_cr = raw.rfind(b"\r")
+        last = max(last_nl, last_cr)
+        if last < 0:
+            # 整块无换行 → 半行，打 [pty-input-partial] 不清出（保留续接）
+            self._emit_pty_line(raw, direction="input", partial=True)
+            return  # in_disp_buf 保持原样，等下次续接
+        consumed = raw[: last + 1]
+        partial = raw[last + 1 :]
+        pos = 0
+        for m in re.finditer(rb"\r\n|\r|\n", consumed):
+            line = consumed[pos : m.end()]
+            pos = m.end()
+            self._emit_pty_line(line, direction="input")
+        # in_disp_buf 仅保留半行（无半行则清空）
+        self.in_disp_buf = bytearray(partial)
+
+    def _emit_pty_line(self, line, direction="output", partial=False):
+        """单行 PTY 输入/输出展示：先退格还原，再剥末尾 \\r/\\r\\n，按 direction 标签。
+        prompt 行（行首匹配 prompt_re）仍标 [prompt]。空行跳过。统一行 emit 入口。
+        direction: "input"(client stdin)/"output"(server stdout)；partial=True 标 [pty-*-partial]。
+        锁契约：调用方须已持 self.lock。"""
+        text = line.decode("utf-8", errors="replace").replace("\x00", "")
+        if not text.strip():
+            return
+        text = self._apply_backspace(text)
+        text = text.rstrip("\r\n")
+        if not text.strip():
+            return
+        if partial:
+            label = "[pty-input-partial]" if direction == "input" else "[pty-partial]"
+        elif self.prompt_re.match(line):
+            label = "[prompt]"
+        else:
+            label = "[pty-input]" if direction == "input" else "[pty-output]"
+        self.logger.debug(f"📥 {label}: {text!r}")
+
+    def _reset_session(self):
+        """彻底清状态：仅在 exit(id==3)/close 调用。锁契约：调用方须已持 self.lock。"""
+        self.pending_cmd = None
+        self.out_buf = bytearray()
+        self.cmd_buf = bytearray()
+        self.in_disp_buf = bytearray()
+        # 复位粘性降级标志与 v2 半包缓冲，避免新连接或后续命令复用旧状态
+        self.v2_corrupt_c = False
+        self.v2_corrupt_s = False
+        self.c_v2_buf = bytearray()
+        self.s_v2_buf = bytearray()
+        self._cancel_idle()
+
+    def _strip_prompts(self, chunk):
+        """从输出块剥离 PTY 提示符行并单独标 [prompt]。剥不净保留原文兜底。"""
+        kept = bytearray()
+        last = 0
+        for m in self.prompt_re.finditer(chunk):
+            if m.start() > last:
+                kept.extend(chunk[last : m.start()])
+            self.logger.debug(
+                f"📤 [prompt]: {m.group().decode('utf-8', errors='replace')!r}"
+            )
+            last = m.end()
+        kept.extend(chunk[last:])
+        return bytes(kept)
+
+    def _reset_idle(self):
+        """每次 on_client/on_server 入口重置 0.15s 兜底计时。调用方须持 self.lock。"""
+        self._cancel_idle()
+        self._idle_gen += 1
+        gen = self._idle_gen
+
+        # 世代号闭包捕获：回调入口校验 gen，杜绝 Timer 已进持锁等待时 cancel no-op 多跑一次 flush
+        def fire():
+            self._on_idle(gen)
+
+        self.idle_timer = threading.Timer(IDLE_TIMEOUT, fire)
+        self.idle_timer.daemon = True
+        self.idle_timer.start()
+
+    def _cancel_idle(self):
+        if self.idle_timer:
+            self.idle_timer.cancel()
+            self.idle_timer = None
+
+    def _on_idle(self, gen):
+        """Timer 回调 wrapper：世代号校验后持锁调 _flush_output（不 reset，保留 pending_cmd）。"""
+        with self.lock:
+            if gen != self._idle_gen:
+                return  # 旧世代 Timer，已被 _reset_idle 作废，丢弃本次 flush
+            self._flush_output()
+
+    def _normalize_cmd(self, buf):
+        """归一化命令文本：退格(\\x7f/\\x08)删前字符、剥控制符/ANSI、strip。"""
+        out = bytearray()
+        skip_ansi = False
+        for b in buf:
+            if skip_ansi:
+                if 0x40 <= b <= 0x7E:  # CSI 终止符
+                    skip_ansi = False
+                continue
+            if b == 0x1B:  # ESC -> 跳过 ANSI 序列
+                skip_ansi = True
+                continue
+            if b in (0x7F, 0x08):  # DEL / BS
+                if out:
+                    out.pop()
+                continue
+            if b < 0x20 and b not in (0x0A, 0x0D):  # 其它控制符
+                continue
+            out.append(b)
+        return out.decode("utf-8", errors="replace").strip("\r\n ").strip()
+
+    @staticmethod
+    def _apply_backspace(text):
+        """退格还原：\\x08(BS)/\\x7f(DEL) 删前字符，纯列表扫描一次（不用正则）。
+        镜像 _normalize_cmd 的 0x7f/0x08 pop 逻辑，但只做退格还原、不剥 ANSI/控制符（PTY 行展示用）。
+        对 BS-SP-BS 与裸 BS 都正确：普通字符入栈，BS/DEL 弹栈顶。"""
+        out = []
+        for ch in text:
+            if ch in ("\x08", "\x7f"):
+                if out:
+                    out.pop()
+                continue
+            out.append(ch)
+        return "".join(out)
+
+    def _strip_echo(self, chunk, cmd):
+        """剥离开头等于命令回显的前缀。返回剥除后的 bytes，或 None（未匹配，调用方保留原文）。"""
+        for prefix in (cmd + "\r\n", cmd + "\r", cmd + "\n", cmd):
+            pb = prefix.encode()
+            if chunk.startswith(pb):
+                return chunk[len(pb) :]
+        return None
+
+    def close(self):
+        """连接关闭时收尾未决配对块并彻底 reset。"""
+        with self.lock:
+            self._cancel_idle()
+            self._flush_output()
+            self._reset_session()

adbproxy/observers/stream.py

@@ -0,0 +1,94 @@
+import threading
+
+from adbproxy.config import FILES_DIR, IDLE_TIMEOUT
+from adbproxy.observers.events import ClientBytes, ServerBytes
+from adbproxy.observers.install import InstallStreamCapture
+from adbproxy.observers.shell import ShellSession
+from adbproxy.observers.sync import SyncSession
+from adbproxy.runtime.logging import Logger
+
+
+class StreamBuffer:
+    def __init__(self, conn_id, file_logger, capture_enabled=True):
+        self.logger = Logger(conn_id, file_logger)
+        self.shell = ShellSession(self.logger)
+        self.sync = SyncSession(self.logger, FILES_DIR, capture_enabled)
+        self.install = InstallStreamCapture(self.logger, FILES_DIR, capture_enabled)
+        self.c_buf = bytearray()
+        self.s_buf = bytearray()
+        self.lock = threading.Lock()
+        self.timer = None
+
+    def handle(self, event):
+        """Route a shallow observer event (ClientBytes / ServerBytes)."""
+        if isinstance(event, ClientBytes):
+            self._on_client_bytes(event.data)
+        elif isinstance(event, ServerBytes):
+            self._on_server_bytes(event.data)
+
+    def add_client(self, data):
+        self.handle(ClientBytes(data))
+
+    def add_server(self, data):
+        self.handle(ServerBytes(data))
+
+    def _on_client_bytes(self, data):
+        # 优先级：shell > sync > install > 碎片缓冲
+        if self.shell.active:
+            self.shell.on_client(data)
+        elif self.sync.active:
+            self.sync.on_client(data)
+        elif self.install.active:
+            take = self.install.on_client(data)
+            leftover = data[take:]
+            if leftover:
+                # server 提前回 Success 等残余字节交回可读路径（通常为空）
+                with self.lock:
+                    self.c_buf.extend(leftover)
+                    self._reset_timer()
+        else:
+            with self.lock:
+                self.c_buf.extend(data)
+                self._reset_timer()
+
+    def _on_server_bytes(self, data):
+        if self.shell.active:
+            self.shell.on_server(data)
+        elif self.sync.active:
+            self.sync.on_server(data)
+        else:
+            with self.lock:
+                self.s_buf.extend(data)
+                self._reset_timer()
+
+    def _reset_timer(self):
+        if self.timer:
+            self.timer.cancel()
+        self.timer = threading.Timer(IDLE_TIMEOUT, self._flush)
+        self.timer.daemon = True
+        self.timer.start()
+
+    def _flush(self):
+        with self.lock:
+            c_data = self.c_buf
+            s_data = self.s_buf
+            self.c_buf = bytearray()
+            self.s_buf = bytearray()
+        if c_data:
+            text = bytes(c_data).decode("utf-8", errors="replace").replace("\x00", "")
+            if text.strip():
+                self.logger.debug(f"📥 [Client Stream]: {text!r}")
+        if s_data:
+            text = bytes(s_data).decode("utf-8", errors="replace").replace("\x00", "")
+            if text.strip():
+                if len(text) > 800:
+                    text = text[:800] + "\n... [Data Truncated]"
+                self.logger.debug(f"📤 [Server Stream]:\n{text.strip()}")
+
+    def close(self):
+        self.shell.close()
+        self.sync.close()
+        self.install.close()
+        if self.timer:
+            self.timer.cancel()
+        self._flush()