@anyul/koishi-plugin-rss 5.2.1 → 5.2.3

package/lib/utils/sanitizer.js

@@ -0,0 +1,227 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeHtml = sanitizeHtml;
+exports.sanitizeToText = sanitizeToText;
+exports.sanitizeImageUrls = sanitizeImageUrls;
+exports.sanitizeLinks = sanitizeLinks;
+exports.createSanitizer = createSanitizer;
+const isomorphic_dompurify_1 = __importDefault(require("isomorphic-dompurify"));
+const cheerio = __importStar(require("cheerio"));
+/**
+ * 允许的 HTML 标签列表
+ */
+const ALLOWED_TAGS = [
+    // 基础标签
+    'p', 'br', 'hr',
+    // 文本格式化
+    'b', 'i', 'u', 'strong', 'em', 's', 'strike', 'del', 'sub', 'sup',
+    // 标题
+    'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
+    // 链接和媒体
+    'a', 'img', 'video', 'audio', 'source', 'track',
+    // 列表
+    'ul', 'ol', 'li',
+    // 容器
+    'div', 'span', 'section', 'article', 'header', 'footer', 'nav', 'main',
+    'aside', 'figure', 'figcaption',
+    // 引用和代码
+    'blockquote', 'pre', 'code', 'details', 'summary',
+    // 表格
+    'table', 'thead', 'tbody', 'tr', 'th', 'td', 'caption',
+    // 语义化标签
+    'time', 'mark'
+];
+/**
+ * 允许的 HTML 属性列表
+ */
+const ALLOWED_ATTR = [
+    // 全局属性
+    'class', 'style', 'id', 'title', 'lang', 'dir',
+    // 链接属性
+    'href', 'target', 'rel',
+    // 媒体属性
+    'src', 'alt', 'width', 'height', 'poster', 'controls', 'autoplay', 'loop', 'muted', 'preload',
+    // 表格属性
+    'colspan', 'rowspan',
+    // time 标签属性
+    'datetime',
+    // details 标签属性
+    'open'
+];
+/**
+ * 配置 DOMPurify
+ */
+const DOMPURIFY_CONFIG = {
+    ALLOWED_TAGS,
+    ALLOWED_ATTR,
+    ALLOW_DATA_ATTR: false, // 禁止 data-* 属性
+    ALLOWED_URI_REGEXP: /^(?:(?:https?):|[^a-z]|[a-z+.-]+(?:[^a-z+.:-]|$))/i,
+    ADD_ATTR: ['target'], // 允许 target 属性
+    FORBID_TAGS: ['script', 'style', 'iframe', 'form', 'input', 'button', 'object', 'embed'],
+    FORBID_ATTR: [
+        // 事件处理器
+        'onclick', 'oncontextmenu', 'ondblclick', 'onmousedown', 'onmouseenter',
+        'onmouseleave', 'onmousemove', 'onmouseover', 'onmouseout', 'onmouseup',
+        'onkeydown', 'onkeypress', 'onkeyup', 'onabort', 'onbeforeunload',
+        'onerror', 'onhashchange', 'onload', 'onpageshow', 'onpagehide',
+        'onresize', 'onscroll', 'onunload', 'onblur', 'onchange', 'onfocus',
+        'oninput', 'oninvalid', 'onreset', 'onsearch', 'onselect', 'onsubmit',
+        // JavaScript URL
+        'javascript:', 'vbscript:', 'data:',
+        // expr 表达式
+        'expr', 'xpression'
+    ]
+};
+/**
+ * 清理 HTML 内容，移除潜在恶意代码
+ *
+ * @param html - 要清理的 HTML 字符串
+ * @param config - 可选的额外配置
+ * @returns 清理后的 HTML 字符串
+ */
+function sanitizeHtml(html, config) {
+    if (!html)
+        return '';
+    // 合并配置
+    const mergeConfig = {
+        ...DOMPURIFY_CONFIG,
+        ...config
+    };
+    return isomorphic_dompurify_1.default.sanitize(html, mergeConfig);
+}
+/**
+ * 清理并返回纯文本（用于需要提取文本的场景）
+ *
+ * @param html - 要清理的 HTML 字符串
+ * @returns 清理后的纯文本
+ */
+function sanitizeToText(html) {
+    if (!html)
+        return '';
+    // 先清理 HTML
+    const cleanHtml = sanitizeHtml(html);
+    // 使用 cheerio 提取纯文本
+    const $ = cheerio.load(cleanHtml);
+    return $.text();
+}
+/**
+ * 清理 HTML 中的图片 URL
+ *
+ * @param html - 包含图片的 HTML 字符串
+ * @returns 清理后的 HTML（图片 URL 已验证）
+ */
+function sanitizeImageUrls(html) {
+    if (!html)
+        return '';
+    // 使用 DOMPurify 清理，但只允许 img 标签
+    const imgOnlyConfig = {
+        ...DOMPURIFY_CONFIG,
+        ALLOWED_TAGS: ['img'],
+        ALLOWED_ATTR: ['src', 'alt', 'width', 'height', 'style', 'class', 'title']
+    };
+    return isomorphic_dompurify_1.default.sanitize(html, imgOnlyConfig);
+}
+/**
+ * 清理链接（a 标签）
+ *
+ * @param html - 包含链接的 HTML 字符串
+ * @returns 清理后的 HTML（链接已安全化）
+ */
+function sanitizeLinks(html) {
+    if (!html)
+        return '';
+    // 使用 DOMPurify 清理，但只允许 a 标签
+    const linkOnlyConfig = {
+        ...DOMPURIFY_CONFIG,
+        ALLOWED_TAGS: ['a'],
+        ALLOWED_ATTR: ['href', 'target', 'rel', 'class', 'title']
+    };
+    // 添加链接安全化：添加 rel="noopener noreferrer"
+    let cleanHtml = isomorphic_dompurify_1.default.sanitize(html, linkOnlyConfig);
+    // 添加安全属性
+    cleanHtml = cleanHtml.replace(/<a(\s+href=)/gi, '<a target="_blank" rel="noopener noreferrer"$1');
+    return cleanHtml;
+}
+/**
+ * 创建带有 HTML 清理功能的模板内容处理函数
+ *
+ * @param config - 配置对象
+ * @returns 清理函数
+ */
+function createSanitizer(config) {
+    const enabled = config.security?.sanitizeHtml !== false;
+    return {
+        /**
+         * 清理 HTML 内容
+         */
+        sanitize: (html) => {
+            if (!enabled)
+                return html;
+            return sanitizeHtml(html);
+        },
+        /**
+         * 清理并返回纯文本
+         */
+        sanitizeToText: (html) => {
+            if (!enabled)
+                return html;
+            return sanitizeToText(html);
+        },
+        /**
+         * 清理图片
+         */
+        sanitizeImages: (html) => {
+            if (!enabled)
+                return html;
+            return sanitizeImageUrls(html);
+        },
+        /**
+         * 清理链接
+         */
+        sanitizeLinks: (html) => {
+            if (!enabled)
+                return html;
+            return sanitizeLinks(html);
+        },
+        /**
+         * 检查是否启用清理
+         */
+        isEnabled: () => enabled
+    };
+}

package/lib/utils/security.d.ts

@@ -0,0 +1,75 @@
+import { Config } from '../types';
+/**
+ * 安全验证错误类
+ */
+export declare class SecurityError extends Error {
+    constructor(message: string);
+}
+export declare function isInternalUrl(urlString: string): boolean;
+/**
+ * URL 白名单/黑名单验证
+ *
+ * @param urlString - 要检查的 URL
+ * @param whitelist - 白名单域名列表
+ * @param blacklist - 黑名单域名列表
+ * @returns true 表示允许访问
+ */
+export declare function isAllowedUrl(urlString: string, whitelist?: string[], blacklist?: string[]): boolean;
+/**
+ * 综合 URL 验证
+ * 检查协议、内网 IP、白名单/黑名单
+ *
+ * @param urlString - 要检查的 URL
+ * @param options - 验证选项
+ * @returns 验证结果对象
+ */
+export declare function validateUrl(urlString: string, options?: {
+    whitelist?: string[];
+    blacklist?: string[];
+    allowHttp?: boolean;
+    allowHttps?: boolean;
+    allowOtherProtocols?: boolean;
+    allowInternalAccess?: boolean;
+    enabled?: boolean;
+}): {
+    valid: boolean;
+    error?: string;
+};
+/**
+ * 验证并抛出异常的便捷函数
+ *
+ * @param urlString - 要检查的 URL
+ * @param options - 验证选项
+ * @throws SecurityError 当验证失败时
+ */
+export declare function validateUrlOrThrow(urlString: string, options?: {
+    whitelist?: string[];
+    blacklist?: string[];
+    allowHttp?: boolean;
+    allowHttps?: boolean;
+    allowOtherProtocols?: boolean;
+    allowInternalAccess?: boolean;
+    enabled?: boolean;
+}): void;
+/**
+ * 从配置中获取安全验证选项
+ *
+ * @param config - 插件配置对象
+ * @returns 安全验证选项
+ */
+export declare function getSecurityOptions(config: Config): {
+    whitelist: string[];
+    blacklist: string[];
+    allowHttp: boolean;
+    allowHttps: boolean;
+    allowInternalAccess: boolean;
+    enabled: boolean;
+};
+/**
+ * 创建带有 URL 验证的 HTTP 函数包装器
+ *
+ * @param httpFunction - 原始的 HTTP 函数
+ * @param config - 配置对象（用于获取白名单/黑名单）
+ * @returns 包装后的 HTTP 函数
+ */
+export declare function createSafeHttpFunction(httpFunction: (url: string, ...args: any[]) => Promise<any>, config: Config): (url: string, ...args: any[]) => Promise<any>;

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.js

@@ -12,9 +12,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");
 /**
  * 日志级别枚举
  */
@@ -73,11 +71,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);
     }
     /**
      * 格式化日志条目
@@ -127,18 +121,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.1",
+  "version": "5.2.3",
   "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",