fix(photo-session): 审查修复 8 项——store 失败回滚/像素上限/计数口径/互斥窗口/Esc 与 resize/裁剪越界/再来一组

Author: Aparencia

app/src-tauri/src/commands_photo.rs

@@ -54,11 +54,14 @@ fn now_unix_ms() -> u64 {
 ///              （JS Date 格式化，Rust 侧免引本地时间依赖）。
 #[tauri::command]
 pub fn start_photo_session(state: State<'_, AppState>, title: Option<String>) -> Result<i64, String> {
+    let mut guard = state.photo_session.lock().map_err(|_| "图文采集状态锁中毒".to_string())?;
+    // 互斥检查（审查修复：live_active 读取移入锁内——缩小"检查后占用前被
+    // live 抢先"的 TOCTOU 窗口；残余窗口：live 侧检查与置位分属不同临界区，
+    // 双面板极端时序仍可能并存——UX 级防护已足够，live 侧同样在开始时查本槽）
     #[cfg(target_os = "windows")]
     let live_active = state.live_session.active_session_id().is_some();
     #[cfg(not(target_os = "windows"))]
     let live_active = false;
-    let mut guard = state.photo_session.lock().map_err(|_| "图文采集状态锁中毒".to_string())?;
     check_photo_mutex(live_active, *guard)?;
     let title = title
         .map(|t| t.trim().to_string())
@@ -73,10 +76,14 @@ pub fn start_photo_session(state: State<'_, AppState>, title: Option<String>) ->
             kind: Some("photo".to_string()),
         })
         .map_err(|e| e.to_string())?;
-    *guard = Some(session.id);
-    // 长驻图片库 store（跨截图保持去重 FIFO 与预算计数——实时链路同模式）
+    // 长驻图片库 store（跨截图保持去重 FIFO 与预算计数——实时链路同模式）；
+    // 审查修复：先建 store 再占用互斥槽——创建失败回滚会话，不留占用与空壳
     let dir = state.data_dir.join("session-images").join(session.id.to_string());
-    let store = SessionImageStore::new(dir).map_err(|e| e.to_string())?;
+    let store = SessionImageStore::new(dir).map_err(|e| {
+        let _ = state.db.delete_session(session.id);
+        format!("初始化图片库失败: {}", e)
+    })?;
+    *guard = Some(session.id);
     *state.photo_store.lock().map_err(|_| "图文图片库锁中毒".to_string())? = Some(store);
     Ok(session.id)
 }
@@ -148,9 +155,9 @@ pub fn finish_photo_session(state: State<'_, AppState>, session_id: i64) -> Resu
         return Err("该会话不是进行中的图文采集".to_string());
     }
     let dir = state.data_dir.join("session-images").join(session_id.to_string());
-    let has_images = SessionImageStore::new(dir.clone())
-        .map(|s| !s.list_images().is_empty())
-        .unwrap_or(false);
+    // 审查修复：store 创建失败视为异常传播（不得当作"无图"而误删会话）
+    let store = SessionImageStore::new(dir.clone()).map_err(|e| format!("读取图片库失败: {}", e))?;
+    let has_images = !store.list_images().is_empty();
     if has_images {
         state.db.finish_session(session_id).map_err(|e| e.to_string())?;
     } else {

app/src-tauri/src/photo_capture.rs

@@ -22,8 +22,11 @@ const OCR_MAX_WIDTH: u32 = 960;
 const MIN_SCORE: f32 = 0.5;
 /// 识别预览条数上限（前端即时反馈）。
 const PREVIEW_MAX: usize = 3;
-/// 单图 base64 解码后字节上限（16MB——解码前拒绝，省 CPU）。
-const MAX_PHOTO_BYTES: usize = 16 * 1024 * 1024;
+/// base64 串长度上限（16MB 字节 → base64 膨胀 4/3——解码前拒绝，省 CPU）。
+const MAX_PHOTO_B64_LEN: usize = 16 * 1024 * 1024 * 4 / 3 + 4;
+/// 解码后像素数上限（40MP——压缩炸弹防御：小体积 PNG 可解出超大位图，
+/// to_rgb8 前拒绝，避免数百 MB 内存分配）。
+const MAX_PIXELS: u64 = 40_000_000;
 
 /// 截图保存结果（前端反馈契约；camelCase 与前端 PhotoResult 对齐）。
 #[derive(Debug, Clone, PartialEq, Serialize)]
@@ -75,10 +78,10 @@ pub fn save_photo_capture(
         if b.score < MIN_SCORE || b.text.trim().is_empty() {
             continue;
         }
-        count += 1;
         if preview.len() < PREVIEW_MAX {
             preview.push(b.text.clone());
         }
+        // 审查修复：成功落库才计数（与 import_frame 链路口径一致——失败不虚高）
         if let Err(e) = db.add_ocr_block(&NewSessionOcrBlock {
             session_id,
             timestamp_ms,
@@ -95,28 +98,37 @@ pub fn save_photo_capture(
             screen_id: None,
         }) {
             eprintln!("[Photo] OCR 块落库失败: {}", e);
+        } else {
+            count += 1;
         }
     }
     Ok(PhotoCaptureResult { duplicated: false, block_count: count, preview, image_ref: rel })
 }
 
 /// base64 解码 + 解码器验证（白名单由 image 解码器把关——capture_fragment 同模式）。
 fn decode_image(image_b64: &str) -> Result<image::RgbImage, String> {
-    let bytes = base64::engine::general_purpose::STANDARD
-        .decode(image_b64.trim())
-        .map_err(|e| format!("图片 base64 解码失败: {}", e))?;
-    if bytes.is_empty() {
+    let trimmed = image_b64.trim();
+    if trimmed.is_empty() {
         return Err("图片数据为空".to_string());
     }
-    if bytes.len() > MAX_PHOTO_BYTES {
-        return Err(format!("图片超限（>{}MB）", MAX_PHOTO_BYTES / 1024 / 1024));
+    // 审查修复：解码前按 base64 长度预估拒绝（16MB 字节上限——省解码 CPU）
+    if trimmed.len() > MAX_PHOTO_B64_LEN {
+        return Err(format!("图片超限（>{}MB）", MAX_PHOTO_B64_LEN / 4 * 3 / 1024 / 1024));
     }
+    let bytes = base64::engine::general_purpose::STANDARD
+        .decode(trimmed)
+        .map_err(|e| format!("图片 base64 解码失败: {}", e))?;
     let img = image::load_from_memory(&bytes)
         .map_err(|e| format!("图片解码失败（仅支持 PNG/JPEG 等常见格式）: {}", e))?;
     let (w, h) = img.dimensions();
     if w == 0 || h == 0 {
         return Err("图片尺寸非法".to_string());
     }
+    // 审查修复：像素数上限（压缩炸弹防御——小体积 PNG 解出超大位图时，
+    // to_rgb8 的 w*h*3 分配可达数百 MB，解码后立即拒绝）
+    if (w as u64) * (h as u64) > MAX_PIXELS {
+        return Err(format!("图片像素超限（>{}MP）", MAX_PIXELS / 1_000_000));
+    }
     Ok(img.to_rgb8())
 }
 

app/src/components/PhotoCapturePanel.tsx

@@ -172,6 +172,18 @@ export default function PhotoCapturePanel({ onOpenSessions, onStatus }: Props) {
                 去会话页查看
               </button>
             )}
+            {/* 审查修复：完成后可原地开始下一组采集（无需切页重挂载回 idle） */}
+            <button
+              onClick={() => {
+                setPhase("idle");
+                setSessionId(null);
+                setCount(0);
+                setMsg("");
+              }}
+              style={{ ...btn, width: "100%", marginTop: 6, background: "#fff", border: "1px solid #e5e7eb", borderRadius: 6 }}
+            >
+              ▶ 再来一组
+            </button>
           </>
         )}
       </div>

app/src/components/ScreenSelectOverlay.tsx

@@ -8,7 +8,7 @@
  *              先减 letterbox 偏移、除以显示缩放，再按图像物理像素换算；
  *              不经 window.devicePixelRatio（显示缩放已含在 letterbox scale）。
  */
-import { useRef, useState } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
 import { normToPixels } from "../utils/photoCrop";
 
 interface Props {
@@ -35,15 +35,28 @@ export default function ScreenSelectOverlay({ src, imageWidth, imageHeight, savi
   const [fit, setFit] = useState<{ scale: number; left: number; top: number } | null>(null);
 
   /** letterbox 布局：图像完整可见居中（含窗口外屏幕区域），比例 = 显示/物理 */
-  const measureFit = () => {
+  const measureFit = useCallback(() => {
     const el = wrapRef.current;
     if (!el) return;
     const rw = el.clientWidth;
     const rh = el.clientHeight;
     if (rw <= 0 || rh <= 0 || imageWidth <= 0 || imageHeight <= 0) return;
     const scale = Math.min(rw / imageWidth, rh / imageHeight);
     setFit({ scale, left: (rw - imageWidth * scale) / 2, top: (rh - imageHeight * scale) / 2 });
-  };
+  }, [imageWidth, imageHeight]);
+
+  // 审查修复：Esc 取消（与提示文案一致）+ 窗口 resize 重算 letterbox（防框选错位）
+  useEffect(() => {
+    const onKey = (e: KeyboardEvent) => {
+      if (e.key === "Escape") onCancel();
+    };
+    window.addEventListener("keydown", onKey);
+    window.addEventListener("resize", measureFit);
+    return () => {
+      window.removeEventListener("keydown", onKey);
+      window.removeEventListener("resize", measureFit);
+    };
+  }, [onCancel, measureFit]);
 
   /** 鼠标坐标 → 图像归一化坐标（减 letterbox 偏移 + 除显示缩放 + clamp） */
   const norm = (clientX: number, clientY: number): Box | null => {

app/src/utils/photoCrop.test.ts

@@ -20,9 +20,19 @@ describe("normToPixels", () => {
     expect(r).toEqual({ x: 480, y: 270, w: 960, h: 540 });
   });
 
-  it("越界输入 clamp 到图像内", () => {
+  it("越界输入 clamp 到图像内且输出不越界", () => {
+    // 输入全越界（起点在右/下边界外）→ 起点收至末行/末列、宽高收至剩余空间
     const r = normToPixels(-0.5, 1.5, 2, 2, 100, 100);
-    expect(r).toEqual({ x: 0, y: 100, w: 100, h: 100 });
+    expect(r).toEqual({ x: 0, y: 99, w: 100, h: 1 });
+  });
+
+  it("起点在界内但宽高越界 → 收窄到图像边界（审查 P7）", () => {
+    // 框选右下角 50%，起点 (0.9, 0.9) → 剩余空间仅 10px
+    const r = normToPixels(0.9, 0.9, 0.5, 0.5, 100, 100);
+    expect(r).toEqual({ x: 90, y: 90, w: 10, h: 10 });
+    // 输出矩形必须完全在图像内（canvas 源矩形越界 → 透明带）
+    expect(r.x + r.w).toBeLessThanOrEqual(100);
+    expect(r.y + r.h).toBeLessThanOrEqual(100);
   });
 
   it("非整数坐标取整（含四舍五入）", () => {

app/src/utils/photoCrop.ts

@@ -3,7 +3,9 @@
  *
  * @ai-context: 归一化坐标（0-1，框选层相对图像）→ 物理像素（GDI 捕获尺寸）。
  *              DPI 换算基准：图像物理像素 × 归一化，不经 window.devicePixelRatio
- *              （显示缩放已由 letterbox 层消化）。clamp 到图像内、宽高取整。
+ *              （显示缩放已由 letterbox 层消化）。输入 clamp 到 [0,1]；输出矩形
+ *              保证完全在图像内（起点 ≤ 末行/末列、宽高不越界——canvas 源矩形
+ *              越界会产生透明带，审查 P7 防御）。
  */
 export function normToPixels(
   x: number,
@@ -17,11 +19,14 @@ export function normToPixels(
   const cy = Math.min(1, Math.max(0, y));
   const cw = Math.min(1, Math.max(0, w));
   const ch = Math.min(1, Math.max(0, h));
+  // 起点 clamp 到图像末行/末列（round 可能越界 1 像素——如 cx=1 → imageW）
+  const px = Math.min(imageW - 1, Math.round(cx * imageW));
+  const py = Math.min(imageH - 1, Math.round(cy * imageH));
   return {
-    x: Math.round(cx * imageW),
-    y: Math.round(cy * imageH),
-    // 越界/零宽防御：至少 1 物理像素（canvas 拒绝 0 尺寸）
-    w: Math.max(1, Math.round(cw * imageW)),
-    h: Math.max(1, Math.round(ch * imageH)),
+    x: px,
+    y: py,
+    // 宽高：至少 1 物理像素且不越出图像右/下边界（canvas 拒绝 0 尺寸）
+    w: Math.max(1, Math.min(imageW - px, Math.round(cw * imageW))),
+    h: Math.max(1, Math.min(imageH - py, Math.round(ch * imageH))),
   };
 }