@anyul/koishi-plugin-rss 5.2.2 → 5.2.4

package/lib/utils/security.js

@@ -0,0 +1,312 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecurityError = void 0;
+exports.isInternalUrl = isInternalUrl;
+exports.isAllowedUrl = isAllowedUrl;
+exports.validateUrl = validateUrl;
+exports.validateUrlOrThrow = validateUrlOrThrow;
+exports.getSecurityOptions = getSecurityOptions;
+exports.createSafeHttpFunction = createSafeHttpFunction;
+/**
+ * 安全验证错误类
+ */
+class SecurityError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'SecurityError';
+    }
+}
+exports.SecurityError = SecurityError;
+// 内网 IP 范围定义
+const INTERNAL_IP_RANGES = [
+    // IPv4 回环地址
+    { start: '127.0.0.0', end: '127.255.255.255' },
+    // IPv4 私有地址 - 10.0.0.0/8
+    { start: '10.0.0.0', end: '10.255.255.255' },
+    // IPv4 私有地址 - 172.16.0.0/12
+    { start: '172.16.0.0', end: '172.31.255.255' },
+    // IPv4 私有地址 - 192.168.0.0/16
+    { start: '192.168.0.0', end: '192.168.255.255' },
+    // IPv4 链路本地地址 - 169.254.0.0/16 (包含 169.254.169.254 云元数据)
+    { start: '169.254.0.0', end: '169.254.255.255' },
+    // IPv4 广播地址
+    { start: '255.255.255.255', end: '255.255.255.255' },
+    // IPv4 0.0.0.0
+    { start: '0.0.0.0', end: '0.0.0.0' },
+    // IPv6 回环地址
+    { start: '::1', end: '::1' },
+    // IPv6 链路本地地址 (fe80::/10)
+    { start: 'fe80::', end: 'febf:ffff:ffff:ffff:ffff:ffff:ffff:ffff' },
+    // IPv6 唯一本地地址 (fc00::/7)
+    { start: 'fc00::', end: 'fdff:ffff:ffff:ffff:ffff:ffff:ffff:ffff' },
+];
+// 禁止的 Hostname 关键词
+const FORBIDDEN_HOSTNAMES = [
+    'localhost',
+    'localhost.localdomain',
+    'metadata.google.internal', // GCP 元数据服务
+    'metadata.google', // GCP 元数据
+    'kubernetes.default.svc', // Kubernetes
+    'kubernetes.default', // Kubernetes
+    'etcd-client.kube-system', // Kubernetes etcd
+    'etcd.kube-system', // Kubernetes etcd
+];
+/**
+ * 将 IP 字符串转换为数字数组（支持 IPv4 和 IPv6）
+ */
+function ipToNumberArray(ip) {
+    if (ip.includes(':')) {
+        // IPv6
+        const parts = ip.split(':');
+        return parts.map(part => {
+            if (part === '')
+                return 0;
+            return parseInt(part, 16);
+        });
+    }
+    else {
+        // IPv4
+        return ip.split('.').map(part => parseInt(part, 10));
+    }
+}
+/**
+ * 比较两个 IP 地址（支持 IPv4 和 IPv6）
+ * 返回负数表示 a < b，正数表示 a > b，0 表示相等
+ */
+function compareIps(a, b) {
+    const aArr = ipToNumberArray(a);
+    const bArr = ipToNumberArray(b);
+    const maxLen = Math.max(aArr.length, bArr.length);
+    for (let i = 0; i < maxLen; i++) {
+        const aVal = aArr[i] || 0;
+        const bVal = bArr[i] || 0;
+        if (aVal !== bVal) {
+            return aVal - bVal;
+        }
+    }
+    return 0;
+}
+/**
+ * 检查 IP 是否在指定范围内
+ */
+function isIpInRange(ip, start, end) {
+    return compareIps(ip, start) >= 0 && compareIps(ip, end) <= 0;
+}
+/**
+ * 检测是否为内网 IP
+ *
+ * @param urlString - 要检查的 URL
+ * @returns true 表示是内网 IP
+ */
+/**
+ * 验证 IPv4 地址是否合法（每个八位组在 0-255 之间）
+ */
+function isValidIPv4(ip) {
+    const parts = ip.split('.');
+    if (parts.length !== 4)
+        return false;
+    return parts.every(part => {
+        const num = parseInt(part, 10);
+        return !isNaN(num) && num >= 0 && num <= 255 && String(num) === part;
+    });
+}
+/**
+ * 验证 IPv6 地址是否合法
+ */
+function isValidIPv6(ip) {
+    // 简单验证：检查是否为有效的 IPv6 格式
+    if (ip === '::1' || ip === '::')
+        return true;
+    const parts = ip.split(':');
+    // IPv6 应该最多有 8 个部分
+    if (parts.length > 8)
+        return false;
+    return parts.every(part => {
+        if (part === '')
+            return true;
+        // 每个部分应该是 0-4 位十六进制
+        return /^[0-9a-fA-F]{1,4}$/.test(part);
+    });
+}
+function isInternalUrl(urlString) {
+    if (!urlString)
+        return false;
+    try {
+        const url = new URL(urlString);
+        const hostname = url.hostname.toLowerCase();
+        // 检查禁止的 hostname 关键词
+        for (const forbidden of FORBIDDEN_HOSTNAMES) {
+            if (hostname === forbidden || hostname.endsWith('.' + forbidden)) {
+                return true;
+            }
+        }
+        // 检查是否为纯 IP 地址
+        const ipPattern = /^(\d{1,3}\.){3}\d{1,3}$/;
+        const ipv6Pattern = /^([0-9a-fA-F]{1,4}:){2,7}[0-9a-fA-F]{1,4}$|^::1$|^::$/;
+        if (ipPattern.test(hostname)) {
+            // 验证 IPv4 是否合法
+            if (!isValidIPv4(hostname)) {
+                // 无效的 IP 地址，拒绝访问
+                return true;
+            }
+            // IPv4
+            for (const range of INTERNAL_IP_RANGES) {
+                if (range.start.includes('.')) { // IPv4 range
+                    if (isIpInRange(hostname, range.start, range.end)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        else if (ipv6Pattern.test(hostname) || hostname.includes(':')) {
+            // 验证 IPv6 是否合法
+            if (!isValidIPv6(hostname)) {
+                // 无效的 IP 地址，拒绝访问
+                return true;
+            }
+            // IPv6
+            for (const range of INTERNAL_IP_RANGES) {
+                if (range.start.includes(':')) { // IPv6 range
+                    if (isIpInRange(hostname, range.start, range.end)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * URL 白名单/黑名单验证
+ *
+ * @param urlString - 要检查的 URL
+ * @param whitelist - 白名单域名列表
+ * @param blacklist - 黑名单域名列表
+ * @returns true 表示允许访问
+ */
+function isAllowedUrl(urlString, whitelist, blacklist) {
+    if (!urlString)
+        return false;
+    try {
+        const url = new URL(urlString);
+        const hostname = url.hostname.toLowerCase();
+        // 先检查黑名单
+        if (blacklist && blacklist.length > 0) {
+            for (const blocked of blacklist) {
+                const blockedLower = blocked.toLowerCase();
+                if (hostname === blockedLower || hostname.endsWith('.' + blockedLower)) {
+                    return false;
+                }
+            }
+        }
+        // 如果有白名单，检查是否在白名单中
+        if (whitelist && whitelist.length > 0) {
+            for (const allowed of whitelist) {
+                const allowedLower = allowed.toLowerCase();
+                if (hostname === allowedLower || hostname.endsWith('.' + allowedLower)) {
+                    return true;
+                }
+            }
+            // 不在白名单中，拒绝访问
+            return false;
+        }
+        // 没有白名单，默认允许（但还需要通过内网检查）
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 综合 URL 验证
+ * 检查协议、内网 IP、白名单/黑名单
+ *
+ * @param urlString - 要检查的 URL
+ * @param options - 验证选项
+ * @returns 验证结果对象
+ */
+function validateUrl(urlString, options = {}) {
+    // 安全检查默认不启用
+    if (options.enabled !== true) {
+        return { valid: true };
+    }
+    if (!urlString) {
+        return { valid: false, error: 'URL 不能为空' };
+    }
+    try {
+        const url = new URL(urlString);
+        // 协议检查
+        const protocol = url.protocol.toLowerCase();
+        if (protocol !== 'http:' && protocol !== 'https:') {
+            if (!options.allowOtherProtocols) {
+                return { valid: false, error: `不支持的协议: ${protocol}` };
+            }
+        }
+        // HTTP/HTTPS 显式禁用检查
+        if (protocol === 'http:' && options.allowHttp === false) {
+            return { valid: false, error: 'HTTP 协议已被禁用' };
+        }
+        if (protocol === 'https:' && options.allowHttps === false) {
+            return { valid: false, error: 'HTTPS 协议已被禁用' };
+        }
+        // 内网 IP 检查（除非明确允许）
+        if (options.allowInternalAccess !== true && isInternalUrl(urlString)) {
+            return { valid: false, error: '不允许访问内网 IP 地址' };
+        }
+        // 白名单/黑名单检查
+        if (!isAllowedUrl(urlString, options.whitelist, options.blacklist)) {
+            return { valid: false, error: 'URL 不在允许列表中或被列入黑名单' };
+        }
+        return { valid: true };
+    }
+    catch (error) {
+        return { valid: false, error: `URL 解析失败: ${error.message}` };
+    }
+}
+/**
+ * 验证并抛出异常的便捷函数
+ *
+ * @param urlString - 要检查的 URL
+ * @param options - 验证选项
+ * @throws SecurityError 当验证失败时
+ */
+function validateUrlOrThrow(urlString, options = {}) {
+    const result = validateUrl(urlString, options);
+    if (!result.valid) {
+        throw new SecurityError(result.error);
+    }
+}
+/**
+ * 从配置中获取安全验证选项
+ *
+ * @param config - 插件配置对象
+ * @returns 安全验证选项
+ */
+function getSecurityOptions(config) {
+    return {
+        whitelist: config.security?.whitelist,
+        blacklist: config.security?.blacklist,
+        allowHttp: config.security?.allowHttp !== false,
+        allowHttps: config.security?.allowHttps !== false,
+        allowInternalAccess: config.security?.allowInternalAccess === true,
+        enabled: config.security?.enabled === true,
+    };
+}
+/**
+ * 创建带有 URL 验证的 HTTP 函数包装器
+ *
+ * @param httpFunction - 原始的 HTTP 函数
+ * @param config - 配置对象（用于获取白名单/黑名单）
+ * @returns 包装后的 HTTP 函数
+ */
+function createSafeHttpFunction(httpFunction, config) {
+    const securityOptions = getSecurityOptions(config);
+    return async (url, ...args) => {
+        // 验证 URL
+        validateUrlOrThrow(url, securityOptions);
+        return httpFunction(url, ...args);
+    };
+}

package/lib/utils/structured-logger.d.ts

@@ -1,6 +1,9 @@
 /**
- * 结构化日志系统
- * 提供统一的日志格式，支持 JSON 输出和性能监控
+ * 观测辅助日志包装层。
+ *
+ * 注意：当前插件主流程日志入口是 `src/utils/logger.ts` 中的
+ * `debug / debugInfo / debugError / createDebugWithContext`。
+ * 这里保留为可选的观测与兼容包装，不应作为新业务代码的首选入口。
  */
 import { Config } from '../types';
 /**
@@ -62,7 +65,8 @@ export declare class PerformanceTimer {
     };
 }
 /**
- * 结构化日志记录器类
+ * 结构化日志记录器类。
+ * 内部仍然回落到主日志入口，避免形成第二条日志主线。
  */
 export declare class StructuredLogger {
     private config;

package/lib/utils/structured-logger.js

@@ -1,7 +1,10 @@
 "use strict";
 /**
- * 结构化日志系统
- * 提供统一的日志格式，支持 JSON 输出和性能监控
+ * 观测辅助日志包装层。
+ *
+ * 注意：当前插件主流程日志入口是 `src/utils/logger.ts` 中的
+ * `debug / debugInfo / debugError / createDebugWithContext`。
+ * 这里保留为可选的观测与兼容包装，不应作为新业务代码的首选入口。
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StructuredLogger = exports.PerformanceTimer = exports.LogLevel = void 0;
@@ -12,9 +15,7 @@ exports.logDetails = logDetails;
 exports.logError = logError;
 exports.createTimer = createTimer;
 exports.logPerformance = logPerformance;
-const koishi_1 = require("koishi");
-const types_1 = require("../types");
-const logger = new koishi_1.Logger('rss-owl');
+const logger_1 = require("./logger");
 /**
  * 日志级别枚举
  */
@@ -60,7 +61,8 @@ class PerformanceTimer {
 }
 exports.PerformanceTimer = PerformanceTimer;
 /**
- * 结构化日志记录器类
+ * 结构化日志记录器类。
+ * 内部仍然回落到主日志入口，避免形成第二条日志主线。
  */
 class StructuredLogger {
     config;
@@ -73,11 +75,7 @@ class StructuredLogger {
      * 判断是否应该记录日志
      */
     shouldLog(level) {
-        const typeLevel = types_1.debugLevel.findIndex(i => i === level);
-        if (typeLevel < 1)
-            return false;
-        const configLevel = types_1.debugLevel.findIndex(i => i === this.config.debug);
-        return typeLevel <= configLevel;
+        return (0, logger_1.shouldLog)(this.config, level);
     }
     /**
      * 格式化日志条目
@@ -86,38 +84,41 @@ class StructuredLogger {
         if (this.enableJsonOutput) {
             return JSON.stringify(entry);
         }
-        // 文本格式
-        const parts = [
+        const header = [
             `[${entry.timestamp}]`,
             `[${entry.level.toUpperCase()}]`,
             entry.module ? `[${entry.module}]` : '',
             entry.message
         ].filter(Boolean).join(' ');
-        // 添加性能数据
+        const lines = [header];
+        if (entry.context && Object.keys(entry.context).length > 0) {
+            const contextStr = Object.entries(entry.context)
+                .map(([key, value]) => `${key}=${value}`)
+                .join(', ');
+            lines.push(`↳ context: ${contextStr}`);
+        }
+        if (entry.data && Object.keys(entry.data).length > 0) {
+            const dataStr = Object.entries(entry.data)
+                .map(([key, value]) => `${key}=${typeof value === 'object' ? JSON.stringify(value) : value}`)
+                .join(', ');
+            lines.push(`↳ data: ${dataStr}`);
+        }
         if (entry.performance) {
             const perfParts = [];
             if (entry.performance.duration) {
-                perfParts.push(`⏱️ ${entry.performance.duration}ms`);
+                perfParts.push(`duration=${entry.performance.duration}ms`);
             }
             if (entry.performance.memory) {
-                perfParts.push(`💾 ${entry.performance.memory.toFixed(2)}MB`);
+                perfParts.push(`memory=${entry.performance.memory.toFixed(2)}MB`);
             }
             if (perfParts.length > 0) {
-                return parts + '\n' + perfParts.join(' | ');
+                lines.push(`↳ performance: ${perfParts.join(', ')}`);
             }
         }
-        // 添加上下文数据
-        if (entry.context && Object.keys(entry.context).length > 0) {
-            const contextStr = Object.entries(entry.context)
-                .map(([key, value]) => `${key}=${value}`)
-                .join(', ');
-            return parts + `\n📍 ${contextStr}`;
-        }
-        // 添加错误信息
         if (entry.error) {
-            return parts + `\n❌ ${entry.error.name}: ${entry.error.message}`;
+            lines.push(`↳ error: ${entry.error.name}: ${entry.error.message}`);
         }
-        return parts;
+        return lines.join('\n');
     }
     /**
      * 记录日志
@@ -127,18 +128,7 @@ class StructuredLogger {
             return;
         }
         const formattedMessage = this.formatEntry(entry);
-        // 根据级别选择输出方式
-        switch (entry.level) {
-            case LogLevel.ERROR:
-                logger.error(formattedMessage);
-                break;
-            case LogLevel.INFO:
-            case LogLevel.DETAILS:
-                logger.info(formattedMessage);
-                break;
-            case LogLevel.DISABLE:
-                break;
-        }
+        (0, logger_1.debug)(this.config, formattedMessage, '', entry.level);
     }
     /**
      * 记录普通信息

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@anyul/koishi-plugin-rss",
   "description": "Koishi RSS订阅器，支持多种RSS源、图片渲染、AI摘要等高级功能",
-  "version": "5.2.2",
+  "version": "5.2.4",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "author": "Anyuluo <anyul@email.com>",
@@ -36,6 +36,7 @@
     "axios": "^1.13.2",
     "cheerio": "^1.1.2",
     "https-proxy-agent": "^7.0.6",
+    "isomorphic-dompurify": "^2.14.0",
     "koishi": "^4.18.10",
     "koishi-plugin-puppeteer": "^3.9.0",
     "marked": "^4.3.0",