mm_os 3.2.9 → 3.3.0

package/middleware/security_headers/index.js

@@ -0,0 +1,487 @@
+/**
+ * 安全头与跨域保护中间件
+ * 合并了CSRF保护和CORS功能的综合安全中间件
+ */
+class Middleware {
+	/**
+	 * 构造函数
+	 */
+	constructor() {
+		this.default = {
+			// CSRF保护配置
+			csrf: {
+				// 启用CSRF保护
+				enable: true,
+				// CSRF令牌的Cookie名称
+				cookie_name: 'csrf_token',
+				// CSRF令牌的请求头名称
+				header_name: 'X-CSRF-Token',
+				// CSRF令牌的表单字段名称
+				form_field: '_csrf',
+				// CSRF令牌的过期时间(毫秒)
+				max_age: 3600000, // 1小时
+				// 忽略的HTTP方法
+				ignore_methods: ['GET', 'HEAD', 'OPTIONS'],
+				// 忽略的路径
+				ignore_paths: [],
+				// 是否生成新的令牌
+				generate_new: true,
+				// 是否验证来源
+				check_origin: true,
+				// 是否记录CSRF攻击尝试
+				log: true,
+				// 是否阻止恶意请求
+				block: true
+			},
+			// CORS配置
+			cors: {
+				// 启用CORS
+				enable: true,
+				// 允许的源
+				origin: '*',
+				// 允许的请求头
+				headers: '*',
+				// 允许的HTTP方法
+				methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS', 'HEAD'],
+				// 允许携带凭证
+				credentials: false,
+				// 预检请求的有效期(秒)
+				max_age: 3600,
+				// 暴露的响应头
+				expose_headers: []
+			},
+			// 安全头配置
+			security_headers: {
+				// 启用安全头
+				enable: true,
+				// X-Content-Type-Options
+				content_type_options: 'nosniff',
+				// X-Frame-Options
+				frame_options: 'SAMEORIGIN',
+				// X-XSS-Protection
+				xss_protection: '1; mode=block',
+				// Content-Security-Policy
+				content_security_policy: "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:",
+				// Strict-Transport-Security
+				strict_transport_security: 'max-age=31536000; includeSubDomains',
+				// Referrer-Policy
+				referrer_policy: 'strict-origin-when-cross-origin'
+			},
+			// 允许的来源域名（用于CSRF和CORS的共同配置）
+			allowed_origins: []
+		};
+	}
+
+	/**
+	 * 初始化中间件
+	 * @param {Object} config 配置项
+	 */
+	init(config) {
+		// 合并默认配置和用户配置
+		config = this._deepMerge(this.default, config);
+
+		// 如果allowed_origins有值但csrf中没有设置，则复制到csrf配置
+		if (config.allowed_origins.length > 0 && config.csrf.allowed_origins === undefined) {
+			config.csrf.allowed_origins = [...config.allowed_origins];
+		}
+
+		this.config = config;
+		return this;
+	}
+
+	/**
+	 * 执行中间件
+	 * @param {Object} ctx Koa上下文
+	 * @param {Function} next 下一个中间件
+	 */
+	async run(ctx, next) {
+		const config = this.config;
+
+		// 强制输出日志
+		console.log('SECURITY HEADERS MIDDLEWARE RUNNING');
+		console.log('Config:', JSON.stringify(config.security_headers));
+		console.log('Security headers enabled:', config.security_headers.enable);
+
+		// 设置CORS头
+		if (config.cors.enable) {
+			console.log('Setting CORS headers');
+			await this._setCorsHeaders(ctx, config.cors);
+		}
+
+		// 设置安全头
+		if (config.security_headers.enable) {
+			console.log('Preparing to set security headers');
+			this._setSecurityHeaders(ctx, config.security_headers);
+			// 验证安全头是否已设置（在Koa中应该检查response.headers）
+			console.log('Security headers after setting (response.headers):', {
+				'x-content-type-options': ctx.response.headers['x-content-type-options'],
+				'x-frame-options': ctx.response.headers['x-frame-options'],
+				'x-xss-protection': ctx.response.headers['x-xss-protection']
+			});
+		}
+
+		// 处理预检请求
+		if (ctx.method === 'OPTIONS' && config.cors.enable) {
+			ctx.status = 204;
+			return;
+		}
+
+		// CSRF保护
+		if (config.csrf.enable) {
+			// 生成CSRF令牌
+			const token = await this._generateToken(ctx);
+			console.log('CSRF token generated');
+
+			// 将令牌添加到上下文，供模板使用
+			ctx.state.csrf = token;
+
+			// 检查是否需要验证CSRF
+			if (!this._shouldSkipCsrfValidation(ctx, config.csrf)) {
+				// 验证来源
+				if (config.csrf.check_origin && !this._validateOrigin(ctx, config.csrf)) {
+					// 强制输出警告日志
+					console.warn('CSRF Origin Validation Failed:', {
+						ip: this._getClientIp(ctx),
+						path: ctx.path,
+						method: ctx.method,
+						origin: ctx.headers.origin,
+						referer: ctx.headers.referer
+					});
+
+					if (config.csrf.block) {
+						ctx.status = 403;
+						ctx.body = {
+							code: 403,
+							msg: 'Forbidden: Invalid request origin'
+						};
+						return;
+					}
+				}
+
+				// 验证CSRF令牌
+				if (!this._validateToken(ctx, config.csrf)) {
+					// 强制输出警告日志
+					console.warn('CSRF Token Validation Failed:', {
+						ip: this._getClientIp(ctx),
+						path: ctx.path,
+						method: ctx.method
+					});
+
+					if (config.csrf.block) {
+						ctx.status = 403;
+						ctx.body = {
+							code: 403,
+							msg: 'Forbidden: Invalid CSRF token'
+						};
+						return;
+					}
+				}
+
+				// 如果需要生成新令牌
+				if (config.csrf.generate_new) {
+					await this._setNewToken(ctx, config.csrf);
+					console.log('New CSRF token set');
+				}
+			}
+		}
+
+		await next();
+	}
+
+	/**
+	 * 生成CSRF令牌
+	 * @param {Object} ctx Koa上下文
+	 * @returns {String} CSRF令牌
+	 */
+	async _generateToken(ctx) {
+		const csrfConfig = this.config.csrf;
+		let token = ctx.cookies.get(csrfConfig.cookie_name);
+
+		// 如果没有令牌或需要生成新令牌，则创建一个新的
+		if (!token || csrfConfig.generate_new) {
+			await this._setNewToken(ctx, csrfConfig);
+			token = ctx.cookies.get(csrfConfig.cookie_name);
+		}
+
+		return token;
+	}
+
+	/**
+	 * 设置新的CSRF令牌
+	 * @param {Object} ctx Koa上下文
+	 * @param {Object} csrfConfig CSRF配置项
+	 */
+	async _setNewToken(ctx, csrfConfig) {
+		// 生成随机令牌
+		const token = this._createRandomToken();
+
+		// 将令牌存储到Cookie
+		ctx.cookies.set(csrfConfig.cookie_name, token, {
+			httpOnly: false, // CSRF令牌需要从前端读取，所以不能设置httpOnly
+			maxAge: csrfConfig.max_age,
+			sameSite: 'strict', // 防止跨站Cookie发送
+			secure: ctx.request.secure // 在HTTPS环境下使用secure标志
+		});
+	}
+
+	/**
+	 * 创建随机令牌
+	 * @returns {String} 随机令牌
+	 */
+	_createRandomToken() {
+		const crypto = require('crypto');
+		return crypto.randomBytes(32).toString('hex');
+	}
+
+	/**
+	 * 检查是否需要跳过CSRF验证
+	 * @param {Object} ctx Koa上下文
+	 * @param {Object} csrfConfig CSRF配置项
+	 * @returns {Boolean} 是否跳过验证
+	 */
+	_shouldSkipCsrfValidation(ctx, csrfConfig) {
+		// 检查HTTP方法是否在忽略列表中
+		if (csrfConfig.ignore_methods.includes(ctx.method)) {
+			return true;
+		}
+
+		// 检查路径是否在忽略列表中
+		for (const path of csrfConfig.ignore_paths) {
+			if (ctx.path.startsWith(path)) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	/**
+	 * 验证来源
+	 * @param {Object} ctx Koa上下文
+	 * @param {Object} csrfConfig CSRF配置项
+	 * @returns {Boolean} 验证是否通过
+	 */
+	_validateOrigin(ctx, csrfConfig) {
+		const origin = ctx.headers.origin;
+		const referer = ctx.headers.referer;
+		const allowedOrigins = csrfConfig.allowed_origins || [];
+
+		// 如果没有配置允许的来源，则默认为通过
+		if (allowedOrigins.length === 0) {
+			return true;
+		}
+
+		// 检查origin
+		if (origin) {
+			const originHost = new URL(origin).hostname;
+			for (const allowed of allowedOrigins) {
+				if (originHost === allowed || originHost.endsWith('.' + allowed)) {
+					return true;
+				}
+			}
+		}
+
+		// 检查referer
+		if (referer) {
+			const refererHost = new URL(referer).hostname;
+			for (const allowed of allowedOrigins) {
+				if (refererHost === allowed || refererHost.endsWith('.' + allowed)) {
+					return true;
+				}
+			}
+		}
+
+		return false;
+	}
+
+	/**
+	 * 验证CSRF令牌
+	 * @param {Object} ctx Koa上下文
+	 * @param {Object} csrfConfig CSRF配置项
+	 * @returns {Boolean} 验证是否通过
+	 */
+	_validateToken(ctx, csrfConfig) {
+		const token = ctx.cookies.get(csrfConfig.cookie_name);
+		if (!token) {
+			return false;
+		}
+
+		// 从请求头中获取令牌
+		const headerToken = ctx.headers[csrfConfig.header_name.toLowerCase()];
+
+		// 从请求体中获取令牌
+		let bodyToken;
+		if (ctx.request.body) {
+			bodyToken = ctx.request.body[csrfConfig.form_field];
+		}
+
+		// 从查询参数中获取令牌
+		const queryToken = ctx.query[csrfConfig.form_field];
+
+		// 验证令牌是否匹配
+		return headerToken === token || bodyToken === token || queryToken === token;
+	}
+
+	/**
+	 * 获取客户端IP
+	 * @param {Object} ctx Koa上下文
+	 * @returns {String} 客户端IP
+	 */
+	_getClientIp(ctx) {
+		return ctx.headers['x-forwarded-for'] ||
+			ctx.headers['X-Forwarded-For'] ||
+			ctx.headers['x-real-ip'] ||
+			ctx.connection.remoteAddress ||
+			ctx.socket.remoteAddress ||
+			ctx.connection.socket.remoteAddress;
+	}
+
+	/**
+	 * 设置CORS头
+	 * @param {Object} ctx Koa上下文
+	 * @param {Object} corsConfig CORS配置项
+	 */
+	async _setCorsHeaders(ctx, corsConfig) {
+		try {
+			// 设置允许的源
+			ctx.set('Access-Control-Allow-Origin', corsConfig.origin);
+
+			// 设置允许的HTTP方法
+			if (Array.isArray(corsConfig.methods) && corsConfig.methods.length > 0) {
+				ctx.set('Access-Control-Allow-Methods', corsConfig.methods.join(','));
+			}
+
+			// 设置允许的请求头
+			if (corsConfig.headers) {
+				ctx.set('Access-Control-Allow-Headers', corsConfig.headers);
+			}
+
+			// 设置是否允许携带凭证
+			if (corsConfig.credentials) {
+				ctx.set('Access-Control-Allow-Credentials', 'true');
+			}
+
+			// 设置预检请求的有效期
+			if (corsConfig.max_age) {
+				ctx.set('Access-Control-Max-Age', corsConfig.max_age.toString());
+			}
+
+			// 设置暴露的响应头
+			if (Array.isArray(corsConfig.expose_headers) && corsConfig.expose_headers.length > 0) {
+				ctx.set('Access-Control-Expose-Headers', corsConfig.expose_headers.join(','));
+			}
+		} catch (error) {
+			if ($.log) {
+				$.log.error('设置CORS头错误:', error);
+			}
+		}
+	}
+
+	/**
+	 * 设置安全头
+	 * @param {Object} ctx Koa上下文
+	 * @param {Object} securityHeadersConfig 安全头配置项
+	 */
+	_setSecurityHeaders(ctx, securityHeadersConfig) {
+		try {
+			// X-Content-Type-Options
+			if (securityHeadersConfig.content_type_options) {
+				ctx.set('X-Content-Type-Options', securityHeadersConfig.content_type_options);
+			}
+
+			// X-Frame-Options
+			if (securityHeadersConfig.frame_options) {
+				ctx.set('X-Frame-Options', securityHeadersConfig.frame_options);
+			}
+
+			// X-XSS-Protection
+			if (securityHeadersConfig.xss_protection) {
+				ctx.set('X-XSS-Protection', securityHeadersConfig.xss_protection);
+			}
+
+			// Content-Security-Policy
+			if (securityHeadersConfig.content_security_policy) {
+				ctx.set('Content-Security-Policy', securityHeadersConfig.content_security_policy);
+			}
+
+			// Strict-Transport-Security
+			if (securityHeadersConfig.strict_transport_security) {
+				ctx.set('Strict-Transport-Security', securityHeadersConfig.strict_transport_security);
+			}
+
+			// Referrer-Policy
+			if (securityHeadersConfig.referrer_policy) {
+				ctx.set('Referrer-Policy', securityHeadersConfig.referrer_policy);
+			}
+		} catch (error) {
+			if ($.log) {
+				$.log.error('设置安全头错误:', error);
+			}
+		}
+	}
+
+	/**
+	 * 深度合并对象
+	 * @param {Object} target 目标对象
+	 * @param {Object} source 源对象
+	 * @returns {Object} 合并后的对象
+	 */
+	_deepMerge(target, source) {
+		const output = {
+			...target
+		};
+
+		if (this._isObject(target) && this._isObject(source)) {
+			Object.keys(source).forEach(key => {
+				if (this._isObject(source[key])) {
+					if (!(key in target)) {
+						Object.assign(output, {
+							[key]: source[key]
+						});
+					} else {
+						output[key] = this._deepMerge(target[key], source[key]);
+					}
+				} else {
+					Object.assign(output, {
+						[key]: source[key]
+					});
+				}
+			});
+		}
+
+		return output;
+	}
+
+	/**
+	 * 检查对象是否为纯对象
+	 * @param {*} item 要检查的项
+	 * @returns {Boolean} 是否为纯对象
+	 */
+	_isObject(item) {
+		return item && typeof item === 'object' && !Array.isArray(item);
+	}
+}
+
+// 创建中间件实例
+const middleware = new Middleware();
+
+// 导出符合系统期望的函数
+exports = module.exports = function(server, config) {
+	// 初始化中间件
+	middleware.init(config);
+
+	// 注册中间件到服务器
+	server.use(middleware.run.bind(middleware));
+
+	// 记录中间件初始化信息
+	if ($.log && $.log.info) {
+		$.log.info(
+			`安全头防护中间件已加载: CSRF=${middleware.config.csrf.enable ? '已启用' : '已禁用'}, CORS=${middleware.config.cors.enable ? '已启用' : '已禁用'}`
+			);
+	}
+
+	return server;
+};
+
+// 保留原始实例，以便其他方式调用
+exports.middleware = middleware;

package/middleware/security_headers/middleware.json

@@ -0,0 +1,45 @@
+{
+  "name": "security_headers",
+  "title": "安全头与跨域保护",
+  "description": "综合安全中间件，合并了CSRF保护、CORS处理和安全头设置功能",
+  "version": "1.0",
+  "type": "web",
+  "process_type": "common_before",
+  "sort": 10,
+  "state": 1,
+  "config": {
+    "csrf": {
+      "enable": true,
+      "cookie_name": "csrf_token",
+      "header_name": "X-CSRF-Token",
+      "form_field": "_csrf",
+      "max_age": 3600000,
+      "ignore_methods": ["GET", "HEAD", "OPTIONS"],
+      "ignore_paths": ["/api/wx", "/api/wechat", "/api/alipay", "/api/baidu", "/api/tencent", "/api/qq", "/api/cloud", "/api/login", "/api/public"],
+      "generate_new": true,
+      "check_origin": true,
+      "log": true,
+      "block": true,
+      "allowed_origins": ["weixin.qq.com", "wx.qq.com", "servicewechat.com", "alipay.com", "taobao.com", "tmall.com", "baidu.com", "aliyun.com", "tencent.com", "tencentcloud.com", "qq.com"]
+    },
+    "cors": {
+      "enable": true,
+      "origin": "*",
+      "headers": "*",
+      "methods": ["GET", "POST", "PUT", "DELETE", "OPTIONS", "HEAD"],
+      "credentials": false,
+      "max_age": 3600,
+      "expose_headers": []
+    },
+    "security_headers": {
+      "enable": true,
+      "content_type_options": "nosniff",
+      "frame_options": "SAMEORIGIN",
+      "xss_protection": "1; mode=block",
+      "content_security_policy": "default-src 'self'; script-src 'self'; style-src 'self'; img-src 'self' data:; font-src 'self'; connect-src 'self'; frame-src 'none';",
+      "strict_transport_security": "max-age=31536000; includeSubDomains",
+      "referrer_policy": "strict-origin-when-cross-origin"
+    },
+    "allowed_origins": ["weixin.qq.com", "wx.qq.com", "servicewechat.com", "alipay.com", "taobao.com", "tmall.com", "baidu.com", "aliyun.com", "tencent.com", "tencentcloud.com", "qq.com"]
+  }
+}