improvement(sns-media): 统一朋友圈远程媒体下载/解密/缓存逻辑

- 新增 sns_media 模块：CDN URL 归一化、远程下载、图片 wcdb_api 解密、视频 WxIsaac64(WeFlow WASM)/ISAAC64 兜底解密与缓存

- routers/sns 与 sns_export_service 复用该模块，收敛重复实现

- 调整 ISAAC64 兜底实现：明确 keystream 生成与字节序格式，作为 WASM 不可用时的 best-effort

- 增加单测覆盖：URL 改写、视频异或解密、缓存命中/升级、解密失败

Author: 2977094657

src/wechat_decrypt_tool/isaac64.py

@@ -1,13 +1,23 @@
 from __future__ import annotations
 
-"""ISAAC-64 PRNG (WeFlow compatible).
+"""ISAAC-64 PRNG (best-effort fallback).
 
-WeChat SNS live photo/video decryption uses a keystream generated by ISAAC-64 and
-XORs the first 128KB of the mp4 file. WeFlow's implementation reverses the
-generated byte array, so we mirror that behavior for compatibility.
+In this repo, Moments (SNS) *video* decryption uses a keystream generator that
+matches WeFlow's WxIsaac64 (WASM) behavior and XORs only the first 128KB of the
+MP4.
+
+This module provides a pure-Python ISAAC-64 implementation so the backend can
+still attempt to generate a keystream when the WASM helper is unavailable.
+
+Notes:
+- Moments *image* decryption is handled via `wcdb_api.dll` (`wcdb_decrypt_sns_image`)
+  because "ISAAC-64 full-file XOR" is not reliably reproducible for images across
+  different versions/samples.
+- This ISAAC-64 implementation may not perfectly match WxIsaac64; treat it as
+  best-effort.
 """
 
-from typing import Any
+from typing import Any, Literal
 
 _MASK_64 = 0xFFFFFFFFFFFFFFFF
 
@@ -143,27 +153,58 @@ def _isaac64(self) -> None:
             self.bb = _u64(self.mm[(y >> 11) & 255] + x)
             self.randrsl[i] = self.bb
 
-    def get_next(self) -> int:
+    def rand_u64(self) -> int:
+        """Return the next ISAAC-64 output as an unsigned 64-bit integer.
+
+        Note: The original reference `rand()` consumes `randrsl[]` in reverse order.
+        """
         if self.randcnt == 0:
             self._isaac64()
             self.randcnt = 256
-        idx = 256 - self.randcnt
         self.randcnt -= 1
-        return _u64(self.randrsl[idx])
-
-    def generate_keystream(self, size: int) -> bytes:
-        """Generate a keystream of `size` bytes (must be multiple of 8)."""
-        if size <= 0:
+        return _u64(self.randrsl[self.randcnt])
+
+    # Backward-compatible alias (older callers used `get_next()`).
+    def get_next(self) -> int:  # pragma: no cover
+        return self.rand_u64()
+
+    KeystreamWordFormat = Literal["raw_le", "raw_be", "be_swap32", "le_swap32"]
+
+    @staticmethod
+    def _raw_to_bytes(raw: int, word_format: KeystreamWordFormat) -> bytes:
+        """Serialize one 64-bit `rand()` output to 8 bytes.
+
+        - raw_le/raw_be: direct endianness of the 64-bit integer.
+        - be_swap32: big-endian bytes with 32-bit halves swapped (BE(lo32)||BE(hi32)).
+          This matches the byte layout implied by the doc's `htonl(hi32)||htonl(lo32)`
+          pattern when the resulting u64 is read as bytes on little-endian hosts.
+        - le_swap32: little-endian bytes with 32-bit halves swapped.
+        """
+        v = _u64(raw)
+        if word_format == "raw_le":
+            return int(v).to_bytes(8, "little", signed=False)
+        if word_format == "raw_be":
+            return int(v).to_bytes(8, "big", signed=False)
+        if word_format == "be_swap32":
+            b = int(v).to_bytes(8, "big", signed=False)
+            return b[4:8] + b[0:4]
+        if word_format == "le_swap32":
+            b = int(v).to_bytes(8, "little", signed=False)
+            return b[4:8] + b[0:4]
+        raise ValueError(f"Unknown ISAAC64 word_format: {word_format}")
+
+    def generate_keystream(self, size: int, *, word_format: KeystreamWordFormat = "be_swap32") -> bytes:
+        """Generate a keystream of `size` bytes.
+
+        This mirrors the decryption loop behavior: produce a new 8-byte keyblock
+        for every 8 bytes of input, and slice for tail bytes.
+        """
+        want = int(size or 0)
+        if want <= 0:
             return b""
-        if size % 8 != 0:
-            raise ValueError("ISAAC64 keystream size must be multiple of 8 bytes.")
 
+        blocks = (want + 7) // 8
         out = bytearray()
-        count = size // 8
-        for _ in range(count):
-            out.extend(int(self.get_next()).to_bytes(8, "little", signed=False))
-
-        # WeFlow reverses the entire byte array (Uint8Array.reverse()).
-        out.reverse()
-        return bytes(out)
-
+        for _ in range(blocks):
+            out.extend(self._raw_to_bytes(self.rand_u64(), word_format))
+        return bytes(out[:want])