evolcore 0.0.23 → 0.0.25

package/dist/utils/avatar-upload.js

@@ -1,12 +1,19 @@
 import fs from 'fs';
-import os from 'os';
-import path from 'path';
 import crypto from 'crypto';
+import dns from 'dns/promises';
+import net from 'net';
 import { agentmdGet, agentmdPut, updateAgentMdFrontmatterAvatar } from '../aun/aid/agentmd.js';
 import { storageRm, storageUpload } from '../aun/storage/index.js';
 import { logger } from './logger.js';
 import { validateImage } from './media-cache.js';
 const MAX_AVATAR_BYTES = 500 * 1024;
+const MIN_AVATAR_DIMENSION = 128;
+const MAX_AVATAR_DIMENSION = 2048;
+const MIN_AVATAR_RATIO = 0.8;
+const MAX_AVATAR_RATIO = 1.25;
+const MAX_AVATAR_REDIRECTS = 3;
+const AVATAR_DOWNLOAD_TIMEOUT_MS = 10_000;
+const AVATAR_DNS_TIMEOUT_MS = 2_000;
 const ALLOWED_AVATAR_MIMES = new Set(['image/png', 'image/jpeg', 'image/webp']);
 const MIME_EXT = {
     'image/png': 'png',
@@ -64,16 +71,230 @@ export async function uploadAvatar(aid, dataUrl, opts) {
     const parsed = parseAvatarDataUrl(dataUrl);
     if ('ok' in parsed)
         return parsed;
-    const validated = await validateImage(parsed.buffer, {
-        maxSize: MAX_AVATAR_BYTES,
-        allowedMimes: ALLOWED_AVATAR_MIMES,
-    });
-    if (validated.mime === null) {
-        return fail(`头像格式验证失败：${validated.reason}`, 'INVALID_ARGS');
-    }
+    const validated = await validateAvatarBuffer(parsed.buffer);
+    if (!('dimensions' in validated))
+        return validated;
     if (validated.mime !== parsed.mime) {
         return fail(`头像格式验证失败：声明 ${parsed.mime}，实际 ${validated.mime}`, 'INVALID_ARGS');
     }
+    return uploadValidatedAvatar(aid, parsed.buffer, validated.mime, validated.dimensions, opts);
+}
+function parseJpegDimensions(buffer) {
+    let offset = 2;
+    while (offset + 3 < buffer.length) {
+        if (buffer[offset] !== 0xff) {
+            offset++;
+            continue;
+        }
+        while (offset < buffer.length && buffer[offset] === 0xff)
+            offset++;
+        if (offset >= buffer.length)
+            return undefined;
+        const marker = buffer[offset++];
+        if (marker === 0xd8 || marker === 0xd9 || (marker >= 0xd0 && marker <= 0xd7))
+            continue;
+        if (offset + 1 >= buffer.length)
+            return undefined;
+        const segmentLength = buffer.readUInt16BE(offset);
+        if (segmentLength < 2 || offset + segmentLength > buffer.length)
+            return undefined;
+        const isSof = (marker >= 0xc0 && marker <= 0xc3)
+            || (marker >= 0xc5 && marker <= 0xc7)
+            || (marker >= 0xc9 && marker <= 0xcb)
+            || (marker >= 0xcd && marker <= 0xcf);
+        if (isSof && segmentLength >= 7) {
+            const height = buffer.readUInt16BE(offset + 3);
+            const width = buffer.readUInt16BE(offset + 5);
+            return { width, height };
+        }
+        offset += segmentLength;
+    }
+    return undefined;
+}
+function parseWebpDimensions(buffer) {
+    if (buffer.length < 16 || buffer.toString('ascii', 0, 4) !== 'RIFF' || buffer.toString('ascii', 8, 12) !== 'WEBP')
+        return undefined;
+    const chunk = buffer.toString('ascii', 12, 16);
+    if (chunk === 'VP8X' && buffer.length >= 30) {
+        const width = 1 + buffer[24] + (buffer[25] << 8) + (buffer[26] << 16);
+        const height = 1 + buffer[27] + (buffer[28] << 8) + (buffer[29] << 16);
+        return { width, height };
+    }
+    if (chunk === 'VP8L' && buffer.length >= 25 && buffer[20] === 0x2f) {
+        const bits = buffer[21] | (buffer[22] << 8) | (buffer[23] << 16) | (buffer[24] << 24);
+        const width = 1 + (bits & 0x3fff);
+        const height = 1 + ((bits >>> 14) & 0x3fff);
+        return { width, height };
+    }
+    if (chunk === 'VP8 ' && buffer.length >= 30) {
+        const frame = buffer.indexOf(Buffer.from([0x9d, 0x01, 0x2a]), 20);
+        if (frame >= 0 && frame + 7 < buffer.length) {
+            return { width: buffer.readUInt16LE(frame + 3) & 0x3fff, height: buffer.readUInt16LE(frame + 5) & 0x3fff };
+        }
+    }
+    return undefined;
+}
+function parseAvatarDimensions(buffer, mime) {
+    try {
+        if (mime === 'image/png' && buffer.length >= 24
+            && buffer.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) {
+            return { width: buffer.readUInt32BE(16), height: buffer.readUInt32BE(20) };
+        }
+        if (mime === 'image/jpeg' && buffer.length >= 4 && buffer[0] === 0xff && buffer[1] === 0xd8)
+            return parseJpegDimensions(buffer);
+        if (mime === 'image/webp')
+            return parseWebpDimensions(buffer);
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+function validateAvatarDimensions(buffer, mime) {
+    const dimensions = parseAvatarDimensions(buffer, mime);
+    if (!dimensions || !Number.isSafeInteger(dimensions.width) || !Number.isSafeInteger(dimensions.height)
+        || dimensions.width < MIN_AVATAR_DIMENSION || dimensions.height < MIN_AVATAR_DIMENSION
+        || dimensions.width > MAX_AVATAR_DIMENSION || dimensions.height > MAX_AVATAR_DIMENSION) {
+        return fail(`头像分辨率必须在 ${MIN_AVATAR_DIMENSION}x${MIN_AVATAR_DIMENSION} 至 ${MAX_AVATAR_DIMENSION}x${MAX_AVATAR_DIMENSION} 之间`, 'INVALID_ARGS');
+    }
+    const aspectRatio = dimensions.width / dimensions.height;
+    if (aspectRatio < MIN_AVATAR_RATIO || aspectRatio > MAX_AVATAR_RATIO) {
+        return fail(`头像宽高比必须在 ${MIN_AVATAR_RATIO} 至 ${MAX_AVATAR_RATIO} 之间（当前: ${aspectRatio.toFixed(3)}）`, 'INVALID_ARGS');
+    }
+    return dimensions;
+}
+function isPrivateAddress(address) {
+    if (net.isIPv4(address)) {
+        const [a, b] = address.split('.').map(Number);
+        return a === 0 || a === 10 || a === 127 || (a === 169 && b === 254)
+            || (a === 100 && b >= 64 && b <= 127) || (a === 172 && b >= 16 && b <= 31)
+            || (a === 192 && (b === 0 || b === 168)) || (a === 198 && (b === 18 || b === 19))
+            || a >= 224;
+    }
+    if (net.isIPv6(address)) {
+        const normalized = address.toLowerCase();
+        const mapped = normalized.match(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/)?.[1];
+        if (mapped)
+            return isPrivateAddress(mapped);
+        return normalized === '::1' || normalized === '::' || normalized.startsWith('fc')
+            || normalized.startsWith('fd') || normalized.startsWith('fe8') || normalized.startsWith('fe9')
+            || normalized.startsWith('fea') || normalized.startsWith('feb') || normalized.startsWith('ff');
+    }
+    return false;
+}
+async function validateAvatarUrl(url) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return { ok: false, reason: '头像 URL 无效' };
+    }
+    if (parsed.protocol !== 'https:')
+        return { ok: false, reason: '头像 URL 仅支持 HTTPS' };
+    if (!parsed.hostname)
+        return { ok: false, reason: '头像 URL 缺少主机名' };
+    if (parsed.username || parsed.password)
+        return { ok: false, reason: '头像 URL 不允许携带认证信息' };
+    if (parsed.port && parsed.port !== '443')
+        return { ok: false, reason: '头像 URL 仅支持 HTTPS 默认端口' };
+    const hostname = parsed.hostname.replace(/^\[|\]$/g, '');
+    if (isPrivateAddress(hostname))
+        return { ok: false, reason: '头像 URL 指向受限地址' };
+    let dnsTimer;
+    try {
+        const addresses = await Promise.race([
+            dns.lookup(hostname, { all: true, verbatim: true }),
+            new Promise((_, reject) => { dnsTimer = setTimeout(() => reject(new Error('DNS lookup timeout')), AVATAR_DNS_TIMEOUT_MS); }),
+        ]);
+        if (dnsTimer)
+            clearTimeout(dnsTimer);
+        if (!addresses.length || addresses.some(({ address }) => isPrivateAddress(address))) {
+            return { ok: false, reason: '头像 URL 指向受限地址' };
+        }
+    }
+    catch {
+        if (dnsTimer)
+            clearTimeout(dnsTimer);
+        return { ok: false, reason: '头像 URL 主机名无法解析' };
+    }
+    return { ok: true, url: parsed };
+}
+async function downloadAvatarBuffer(sourceUrl) {
+    let current = sourceUrl;
+    for (let redirect = 0; redirect <= MAX_AVATAR_REDIRECTS; redirect++) {
+        const checked = await validateAvatarUrl(current);
+        if (!checked.ok)
+            return fail(checked.reason, 'INVALID_ARGS');
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), AVATAR_DOWNLOAD_TIMEOUT_MS);
+        let response;
+        try {
+            response = await fetch(checked.url, {
+                redirect: 'manual',
+                headers: { accept: 'image/png,image/jpeg,image/webp', 'accept-encoding': 'identity' },
+                signal: controller.signal,
+            });
+        }
+        catch (e) {
+            clearTimeout(timeout);
+            return fail(`头像 URL 下载失败: ${messageOf(e)}`, 'UPLOAD_FAILED');
+        }
+        if (response.status >= 300 && response.status < 400) {
+            const location = response.headers.get('location');
+            clearTimeout(timeout);
+            if (!location || redirect === MAX_AVATAR_REDIRECTS)
+                return fail('头像 URL 重定向次数过多或缺少目标', 'INVALID_ARGS');
+            try {
+                current = new URL(location, checked.url).toString();
+            }
+            catch {
+                return fail('头像 URL 重定向目标无效', 'INVALID_ARGS');
+            }
+            continue;
+        }
+        if (!response.ok) {
+            clearTimeout(timeout);
+            return fail(`头像 URL 返回 HTTP ${response.status}`, 'UPLOAD_FAILED');
+        }
+        const length = Number(response.headers.get('content-length') || 0);
+        if (length > MAX_AVATAR_BYTES) {
+            clearTimeout(timeout);
+            return fail('头像大小超过 500KB 限制', 'INVALID_ARGS');
+        }
+        if (!response.body) {
+            clearTimeout(timeout);
+            return fail('头像 URL 返回空响应', 'INVALID_ARGS');
+        }
+        const reader = response.body.getReader();
+        const chunks = [];
+        let total = 0;
+        try {
+            while (true) {
+                const part = await reader.read();
+                if (part.done)
+                    break;
+                const chunk = Buffer.from(part.value);
+                total += chunk.length;
+                if (total > MAX_AVATAR_BYTES) {
+                    await reader.cancel();
+                    return fail('头像大小超过 500KB 限制', 'INVALID_ARGS');
+                }
+                chunks.push(chunk);
+            }
+        }
+        catch (e) {
+            return fail(`头像 URL 下载失败: ${messageOf(e)}`, 'UPLOAD_FAILED');
+        }
+        finally {
+            clearTimeout(timeout);
+            reader.releaseLock();
+        }
+        return Buffer.concat(chunks, total);
+    }
+    return fail('头像 URL 重定向次数过多', 'INVALID_ARGS');
+}
+async function uploadValidatedAvatar(aid, buffer, mime, dimensions, opts) {
     let agentMd;
     try {
         agentMd = await agentmdGet(aid, { aunPath: opts?.aunPath });
@@ -81,21 +302,18 @@ export async function uploadAvatar(aid, dataUrl, opts) {
     catch (e) {
         return fail(`agent.md 不存在或无法读取: ${messageOf(e)}`, classifyAgentMdReadError(e));
     }
-    const ext = MIME_EXT[validated.mime] ?? 'img';
+    const ext = MIME_EXT[mime] ?? 'img';
     const objectKey = `shared/avatars/${crypto.randomUUID()}.${ext}`;
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'evolcore-avatar-'));
-    const tmpPath = path.join(tmpDir, `avatar.${ext}`);
+    const sha256 = crypto.createHash('sha256').update(buffer).digest('hex');
     let uploaded = false;
     try {
-        fs.writeFileSync(tmpPath, parsed.buffer);
-        const uploadedAvatar = await storageUpload(aid, tmpPath, objectKey, {
+        const uploadedAvatar = await storageUpload(aid, buffer, objectKey, {
             isPublic: true,
-            contentType: validated.mime,
+            contentType: mime,
             aunPath: opts?.aunPath,
         });
-        if (!uploadedAvatar.ok) {
+        if (!uploadedAvatar.ok)
             return fail(`上传到 AUN storage 失败: ${uploadedAvatar.error || 'unknown error'}`, 'UPLOAD_FAILED');
-        }
         uploaded = true;
         const publicUrl = uploadedAvatar.publicUrl ?? `https://${aid}/${uploadedAvatar.objectKey}`;
         const updated = updateAgentMdFrontmatterAvatar(agentMd, publicUrl);
@@ -107,17 +325,58 @@ export async function uploadAvatar(aid, dataUrl, opts) {
             return fail(`更新 agent.md 失败: ${messageOf(e)}`, 'UPLOAD_FAILED');
         }
         logger.info(`[avatar-upload] uploaded ${uploadedAvatar.objectKey} -> ${publicUrl}`);
-        return { ok: true, publicUrl, objectKey: uploadedAvatar.objectKey };
+        return {
+            ok: true,
+            publicUrl,
+            objectKey: uploadedAvatar.objectKey,
+            sha256,
+            mime,
+            width: dimensions.width,
+            height: dimensions.height,
+            aspectRatio: dimensions.width / dimensions.height,
+        };
     }
     catch (e) {
         if (uploaded)
             await cleanupUploadedAvatar(aid, objectKey, opts?.aunPath);
         return fail(messageOf(e), 'UPLOAD_FAILED');
     }
-    finally {
-        try {
-            fs.rmSync(tmpDir, { recursive: true, force: true });
-        }
-        catch { /* ignore */ }
+}
+async function validateAvatarBuffer(buffer) {
+    const validated = await validateImage(buffer, {
+        maxSize: MAX_AVATAR_BYTES,
+        allowedMimes: ALLOWED_AVATAR_MIMES,
+    });
+    if (validated.mime === null)
+        return fail(`头像格式验证失败：${validated.reason}`, 'INVALID_ARGS');
+    const dimensions = validateAvatarDimensions(buffer, validated.mime);
+    if ('ok' in dimensions)
+        return dimensions;
+    return { ok: true, mime: validated.mime, dimensions };
+}
+/** Upload an image file after validating its bytes and real MIME type. */
+export async function uploadAvatarFile(aid, filePath, opts) {
+    try {
+        const buffer = fs.readFileSync(filePath);
+        return await uploadAvatarBuffer(aid, buffer, opts);
     }
+    catch (e) {
+        return fail(`头像文件读取失败: ${messageOf(e)}`, 'NOT_FOUND');
+    }
+}
+/** Upload already-read image bytes; callers can use this after secure fd validation. */
+export async function uploadAvatarBuffer(aid, buffer, opts) {
+    const validated = await validateAvatarBuffer(buffer);
+    if (!('dimensions' in validated))
+        return validated;
+    return uploadValidatedAvatar(aid, buffer, validated.mime, validated.dimensions, opts);
+}
+/** Download an HTTPS image with redirect/SSRF/size guards, then upload it. */
+export async function uploadAvatarUrl(aid, url, opts) {
+    if (typeof url !== 'string' || !url.trim())
+        return fail('头像 URL 不能为空', 'INVALID_ARGS');
+    const downloaded = await downloadAvatarBuffer(url.trim());
+    if (!Buffer.isBuffer(downloaded))
+        return downloaded;
+    return uploadAvatarBuffer(aid, downloaded, opts);
 }