Files
universal-web-api/app/utils/image_validation.py
T
2026-11-02 22:54:14 +08:00

453 lines
16 KiB
Python

"""
app/utils/image_validation.py - 通用图片比对、特征签名与参考图过滤模块
职责:
1. 提取图片指纹特征(SHA256、像素 SHA256、尺寸、dHash 感知哈希)。
2. 精确比对与感知相似度比对,判断两张图片是否一致。
3. 从本地路径、Base64 data URI、HTTP(s) 或浏览器会话中读取图片字节。
4. 在多模态生成完成后,过滤掉与用户上传参考图一致的图片,防止误将原图当下发。
5. 提供通用的生成图片校验接口,供 Arena 等适配器复用。
"""
from __future__ import annotations
import base64
import hashlib
from io import BytesIO
from pathlib import Path
from typing import Any, Callable, Dict, Iterable, List, Optional
from urllib.parse import urlsplit
from PIL import Image, ImageOps
from app.core.config import logger
from app.utils.remote_resource import UnsafeRemoteResourceError, get_public_remote_resource
from app.core.driver import driver_for_tab
# S10:比对/C2PA 路径读取第三方页面图片时的预算(与 image_handler 的上传图片上限保持同一量级)。
MAX_VALIDATION_IMAGE_BYTES = 20 * 1024 * 1024
MAX_VALIDATION_IMAGE_PIXELS = 40_000_000
MAX_VALIDATION_IMAGE_DIMENSION = 16_384
def _decode_data_uri_bytes(source: str) -> bytes:
"""解码 data URI;先按 base64 长度预估解码大小,超预算直接放弃(不做完整解码)。"""
try:
encoded = source.split(",", 1)[1]
except IndexError:
return b""
if (len(encoded) * 3) // 4 > MAX_VALIDATION_IMAGE_BYTES + 3:
logger.warning("[IMAGE_VALIDATION] data URI 超过字节预算,跳过比对")
return b""
try:
payload = base64.b64decode(encoded)
except Exception:
return b""
return payload if len(payload) <= MAX_VALIDATION_IMAGE_BYTES else b""
def _read_remote_image_limited(source: str, headers: Dict[str, str], timeout: Any) -> bytes:
"""经受限抓取器读取远程图片:逐跳私网/重定向校验 + DNS pinning + 流式字节上限。"""
response = get_public_remote_resource(
source,
headers=headers,
credential_origin_url=source,
timeout=timeout,
stream=True,
)
try:
if int(getattr(response, "status_code", 0) or 0) >= 400:
return b""
declared = str((getattr(response, "headers", None) or {}).get("Content-Length") or "").strip()
if declared.isdigit() and int(declared) > MAX_VALIDATION_IMAGE_BYTES:
logger.warning("[IMAGE_VALIDATION] 远程图片 Content-Length 超过预算,跳过比对")
return b""
chunks: List[bytes] = []
total = 0
for chunk in response.iter_content(chunk_size=65536):
if not chunk:
continue
total += len(chunk)
if total > MAX_VALIDATION_IMAGE_BYTES:
logger.warning("[IMAGE_VALIDATION] 远程图片超过字节预算,已中止读取")
return b""
chunks.append(chunk)
return b"".join(chunks)
finally:
close = getattr(response, "close", None)
if callable(close):
close()
def get_current_page_url(tab: Any) -> str:
"""获取当前标签页 URL"""
if tab is None:
return ""
try:
return str(driver_for_tab(tab).run_js("return location.href") or "").strip()
except Exception:
return str(getattr(tab, "url", "") or "").strip()
def read_image_bytes(
tab: Any,
url: str,
timeout: Any = (2.0, 5.0),
) -> bytes:
"""通过 HTTP 请求或浏览器上下文安全读取图片二进制数据。"""
source = str(url or "").strip()
if not source:
return b""
if source.startswith("data:"):
return _decode_data_uri_bytes(source)
# 规范化超时时间为 (connect_timeout, read_timeout)
if isinstance(timeout, (int, float)):
eff_timeout: Any = (
(min(2.0, float(timeout)), float(timeout))
if float(timeout) > 5.0
else float(timeout)
)
elif isinstance(timeout, (tuple, list)) and len(timeout) >= 2:
try:
c_to = float(timeout[0]) if timeout[0] is not None else None
r_to = float(timeout[1]) if timeout[1] is not None else None
eff_timeout = (c_to, r_to)
except (TypeError, ValueError):
eff_timeout = (2.0, 5.0)
else:
eff_timeout = (2.0, 5.0)
if source.startswith(("http://", "https://")):
try:
referer = get_current_page_url(tab)
headers = {"User-Agent": "Mozilla/5.0"}
if referer:
headers["Referer"] = referer
payload = _read_remote_image_limited(source, headers, eff_timeout)
if payload:
return payload
except UnsafeRemoteResourceError as exc:
# S10:私网/非法目标不再退回浏览器 fetch(那会绕过同一道校验)
logger.warning(f"[IMAGE_VALIDATION] 拒绝读取非公网图片地址: {exc}")
return b""
except Exception:
pass
if tab is None:
return b""
try:
result = driver_for_tab(tab).run_js(
r"""
return (async function(url, maxBytes) {
let timer = null;
try {
const controller = typeof AbortController !== 'undefined' ? new AbortController() : null;
timer = controller ? setTimeout(() => controller.abort(), 6000) : null;
const response = await fetch(url, {
signal: controller ? controller.signal : undefined
});
if (!response.ok) return '';
const declared = Number(response.headers.get('content-length') || 0);
if (declared && declared > maxBytes) return '';
const buffer = await response.arrayBuffer();
if (buffer.byteLength > maxBytes) return '';
const bytes = new Uint8Array(buffer);
let binary = '';
const step = 0x8000;
for (let index = 0; index < bytes.length; index += step) {
binary += String.fromCharCode(...bytes.subarray(index, index + step));
}
return btoa(binary);
} catch (e) {
return '';
} finally {
if (timer) clearTimeout(timer);
}
})(arguments[0], arguments[1]);
""",
source,
MAX_VALIDATION_IMAGE_BYTES,
)
encoded = str(result or "")
if (len(encoded) * 3) // 4 > MAX_VALIDATION_IMAGE_BYTES + 3:
return b""
return base64.b64decode(encoded)
except Exception:
return b""
def read_local_image_bytes(path_value: Any) -> bytes:
"""读取本地文件图片字节"""
try:
path = Path(str(path_value or "")).expanduser()
return path.read_bytes() if path.is_file() else b""
except Exception:
return b""
def read_uploaded_image_bytes(
value: Any,
*,
local_reader: Optional[Callable[[Any], bytes]] = None,
) -> bytes:
"""读取上传的参考图片字节(支持 bytes、data URI、本地路径)"""
if isinstance(value, (bytes, bytearray)):
return bytes(value)
source = str(value or "").strip()
if source.startswith("data:"):
return _decode_data_uri_bytes(source)
reader = local_reader or read_local_image_bytes
return reader(source)
def extract_media_item_bytes(
tab: Any,
item: Dict[str, Any],
*,
local_reader: Optional[Callable[[Any], bytes]] = None,
) -> bytes:
"""从媒体描述字典中提取图片二进制数据"""
if not isinstance(item, dict):
return b""
reader = local_reader or read_local_image_bytes
# 优先读本地落盘路径
for key in ("local_path", "path", "file_path"):
payload = reader(item.get(key))
if payload:
return payload
# 其次从 data_uri / url / src 中读取
for key in ("data_uri", "url", "src"):
value = str(item.get(key) or "").strip()
if value:
payload = read_image_bytes(tab, value)
if payload:
return payload
return b""
def image_signatures(payload: bytes) -> Dict[str, Any]:
"""计算图片指纹(字节哈希、像素哈希、尺寸与差异哈希)"""
data = bytes(payload or b"")
signatures: Dict[str, Any] = {
"sha256": hashlib.sha256(data).hexdigest() if data else None,
"pixel_sha256": None,
"size": None,
"dhash": None,
}
if not data:
return signatures
try:
with Image.open(BytesIO(data)) as source:
# S10:解码前按头部尺寸做像素预算,防解压炸弹(只算 sha256,不做像素级比对)
width, height = source.size
if (
width <= 0
or height <= 0
or width > MAX_VALIDATION_IMAGE_DIMENSION
or height > MAX_VALIDATION_IMAGE_DIMENSION
or width * height > MAX_VALIDATION_IMAGE_PIXELS
):
logger.warning(f"[IMAGE_VALIDATION] 图片尺寸 {width}x{height} 超过像素预算,跳过像素签名")
return signatures
image = ImageOps.exif_transpose(source).convert("RGBA")
signatures["size"] = image.size
signatures["pixel_sha256"] = hashlib.sha256(image.tobytes()).hexdigest()
grayscale = image.convert("L").resize((17, 16), Image.Resampling.LANCZOS)
flattened_data = getattr(grayscale, "get_flattened_data", grayscale.getdata)
pixels = list(flattened_data())
bits = 0
for row in range(16):
offset = row * 17
for column in range(16):
bits = (bits << 1) | int(pixels[offset + column] > pixels[offset + column + 1])
signatures["dhash"] = bits
except Exception:
pass
return signatures
def same_image(
candidate: Dict[str, Any],
reference: Optional[Dict[str, Any]],
*,
max_dhash_distance: Optional[int] = 4,
) -> bool:
"""比对两张图片是否一致。优先严格匹配,可选感知哈希。"""
if not reference:
return False
# 1. 字节完全一致
if candidate.get("sha256") and candidate.get("sha256") == reference.get("sha256"):
return True
# 2. 解码像素与尺寸完全一致(防御服务端无损重新封装/元数据变动)
if (
candidate.get("size") == reference.get("size")
and candidate.get("pixel_sha256")
and candidate.get("pixel_sha256") == reference.get("pixel_sha256")
):
return True
# 3. 感知哈希汉明距离比对
candidate_dhash = candidate.get("dhash")
reference_dhash = reference.get("dhash")
return bool(
max_dhash_distance is not None
and isinstance(candidate_dhash, int)
and isinstance(reference_dhash, int)
and (candidate_dhash ^ reference_dhash).bit_count() <= max_dhash_distance
)
def compute_reference_signatures(
uploaded_images: Iterable[Any],
*,
local_reader: Optional[Callable[[Any], bytes]] = None,
) -> List[Dict[str, Any]]:
"""批量计算用户上传参考图的签名列表"""
signatures: List[Dict[str, Any]] = []
for raw in uploaded_images or []:
payload = read_uploaded_image_bytes(raw, local_reader=local_reader)
if payload:
sig = image_signatures(payload)
if sig.get("sha256") or sig.get("pixel_sha256"):
signatures.append(sig)
return signatures
def is_candidate_matching_reference(
candidate_signatures: Dict[str, Any],
reference_signatures: List[Dict[str, Any]],
*,
max_dhash_distance: Optional[int] = None,
) -> bool:
"""检查候选图签名是否命中任一参考图"""
if not candidate_signatures or not reference_signatures:
return False
return any(
same_image(candidate_signatures, ref, max_dhash_distance=max_dhash_distance)
for ref in reference_signatures
)
def filter_reference_images(
media_items: Iterable[Dict[str, Any]],
uploaded_images: Iterable[Any],
*,
tab: Any = None,
logger_context: str = "",
max_dhash_distance: Optional[int] = None,
local_reader: Optional[Callable[[Any], bytes]] = None,
) -> List[Dict[str, Any]]:
"""
通用参考图过滤器:
遍历媒体项列表,识别并剔除与用户上传参考图一致的图片项。
保留非图片媒体(如音频、视频)以及真正由 AI 生成的新图片。
"""
if not media_items:
return []
items = [item for item in media_items if isinstance(item, dict)]
if not items:
return []
reference_sigs = compute_reference_signatures(uploaded_images, local_reader=local_reader)
if not reference_sigs:
return items
tag = f"[{logger_context}] " if logger_context else ""
filtered_items: List[Dict[str, Any]] = []
dropped_count = 0
for item in items:
media_type = str(item.get("media_type") or item.get("type") or "image").strip().lower()
if media_type not in {"image", "image_url", "input_image"}:
filtered_items.append(item)
continue
payload = extract_media_item_bytes(tab, item, local_reader=local_reader)
if not payload:
# 无法读取字节时,保留该项(避免误杀)
filtered_items.append(item)
continue
candidate_sig = image_signatures(payload)
if is_candidate_matching_reference(
candidate_sig,
reference_sigs,
max_dhash_distance=max_dhash_distance,
):
dropped_count += 1
src_info = item.get("url") or item.get("local_path") or item.get("src") or "data_uri"
logger.info(
f"{tag}检测到提取结果与上传参考图一致,已自动过滤该图片项: "
f"source={str(src_info)[:100]}"
)
else:
filtered_items.append(item)
if dropped_count > 0:
logger.debug(
f"{tag}参考图过滤完成: 原始 {len(items)} 项, 过滤参考图 {dropped_count} 张, 剩余 {len(filtered_items)} 项"
)
return filtered_items
def validate_generated_images(
uploaded_images: Iterable[Any],
generated_media_items: Iterable[Dict[str, Any]],
*,
tab: Any = None,
max_dhash_distance: Optional[int] = None,
error_builder: Optional[Callable[[str], Exception]] = None,
local_reader: Optional[Callable[[Any], bytes]] = None,
) -> None:
"""
校验生成图片列表中是否存在与上传参考图完全相同的图片。
若存在,则调用 error_builder 抛出异常;若未提供 error_builder,则抛出 ValueError。
"""
reference_sigs = compute_reference_signatures(uploaded_images, local_reader=local_reader)
if not reference_sigs:
return
for item in generated_media_items or []:
if not isinstance(item, dict):
continue
media_type = str(item.get("media_type") or item.get("type") or "image").strip().lower()
if media_type not in {"image", "image_url", "input_image"}:
continue
payload = extract_media_item_bytes(tab, item, local_reader=local_reader)
if not payload:
continue
candidate = image_signatures(payload)
if is_candidate_matching_reference(
candidate,
reference_sigs,
max_dhash_distance=max_dhash_distance,
):
msg = "生成结果与上传图片一致"
if error_builder:
raise error_builder(msg)
raise ValueError(msg)
__all__ = [
"compute_reference_signatures",
"extract_media_item_bytes",
"filter_reference_images",
"get_current_page_url",
"image_signatures",
"is_candidate_matching_reference",
"read_image_bytes",
"read_local_image_bytes",
"read_uploaded_image_bytes",
"same_image",
"validate_generated_images",
]