init

app/utils/errorlog/sanitize.go

@@ -0,0 +1,182 @@
+package errorlog
+
+import (
+	"strings"
+	"unicode"
+)
+
+// sanitizeLogString 清理日志字符串，防止日志注入攻击
+// 移除或转义危险字符：
+//   - 换行符 (\n, \r) - 可能用于伪造多行日志
+//   - 制表符 (\t) - 可能用于格式化攻击
+//   - 控制字符 - 可能用于隐藏攻击痕迹
+//
+// 参数:
+//   - s: 要清理的字符串
+//   - maxLength: 最大长度限制（0 表示不限制）
+//
+// 返回:
+//   - 清理后的字符串
+func sanitizeLogString(s string, maxLength int) string {
+	if s == "" {
+		return s
+	}
+
+	// 移除控制字符和换行符
+	var builder strings.Builder
+	builder.Grow(len(s))
+
+	for _, r := range s {
+		// 允许打印字符和空格，移除控制字符
+		if unicode.IsPrint(r) || r == ' ' {
+			builder.WriteRune(r)
+		} else {
+			// 将控制字符替换为转义序列（可选，或直接移除）
+			// 这里选择移除，因为转义序列也可能被利用
+		}
+	}
+
+	result := builder.String()
+
+	// 限制长度
+	if maxLength > 0 && len(result) > maxLength {
+		result = result[:maxLength] + "...[truncated]"
+	}
+
+	return result
+}
+
+// sanitizeLogLevel 验证和清理日志级别，防止伪造
+// 只允许预定义的日志级别
+func sanitizeLogLevel(level string) string {
+	level = strings.ToLower(strings.TrimSpace(level))
+
+	// 只允许预定义的级别
+	allowedLevels := map[string]string{
+		"error":   "error",
+		"warning": "warning",
+		"warn":    "warning", // 兼容 warn
+		"info":    "info",
+		"debug":   "debug",
+	}
+
+	if validLevel, ok := allowedLevels[level]; ok {
+		return validLevel
+	}
+
+	// 如果级别无效，默认返回 error（最安全的级别）
+	return "error"
+}
+
+// sanitizeLogArgs 清理日志参数，防止注入攻击
+// 将参数转换为安全的字符串表示
+func sanitizeLogArgs(args ...any) []any {
+	if len(args) == 0 {
+		return args
+	}
+
+	sanitized := make([]any, len(args))
+	for i, arg := range args {
+		switch v := arg.(type) {
+		case string:
+			// 字符串参数：清理控制字符
+			sanitized[i] = sanitizeLogString(v, 0)
+		case []byte:
+			// 字节数组：转换为字符串后清理
+			sanitized[i] = sanitizeLogString(string(v), 0)
+		case error:
+			// 错误对象：清理错误消息
+			if v != nil {
+				sanitized[i] = sanitizeLogString(v.Error(), 0)
+			} else {
+				sanitized[i] = "<nil>"
+			}
+		default:
+			// 其他类型：保持原样（数字、布尔等通常是安全的）
+			sanitized[i] = arg
+		}
+	}
+
+	return sanitized
+}
+
+// sanitizeLogFormat 清理日志格式字符串，防止格式字符串注入
+// 移除危险的控制字符，但保留格式占位符（%v, %s 等）
+func sanitizeLogFormat(format string) string {
+	if format == "" {
+		return format
+	}
+
+	// 移除换行符和控制字符，但保留格式占位符
+	var builder strings.Builder
+	builder.Grow(len(format))
+
+	for i := 0; i < len(format); i++ {
+		r := rune(format[i])
+
+		// 允许打印字符、空格和格式占位符
+		if unicode.IsPrint(r) || r == ' ' {
+			builder.WriteRune(r)
+		} else if r == '\n' || r == '\r' || r == '\t' {
+			// 将换行符和制表符替换为空格
+			builder.WriteRune(' ')
+		}
+		// 其他控制字符直接移除
+	}
+
+	result := builder.String()
+
+	// 限制格式字符串长度（防止过长的格式字符串攻击）
+	maxFormatLength := 1000
+	if len(result) > maxFormatLength {
+		result = result[:maxFormatLength] + "...[truncated]"
+	}
+
+	return result
+}
+
+// sanitizeAttributes 清理 attributes map，防止注入攻击
+func sanitizeAttributes(attributes map[string]any) map[string]any {
+	if attributes == nil || len(attributes) == 0 {
+		return attributes
+	}
+
+	sanitized := make(map[string]any, len(attributes))
+	for key, value := range attributes {
+		// 清理 key
+		sanitizedKey := sanitizeLogString(key, 100)
+
+		// 清理 value
+		switch v := value.(type) {
+		case string:
+			sanitized[sanitizedKey] = sanitizeLogString(v, 1000)
+		case []byte:
+			sanitized[sanitizedKey] = sanitizeLogString(string(v), 1000)
+		case error:
+			if v != nil {
+				sanitized[sanitizedKey] = sanitizeLogString(v.Error(), 1000)
+			} else {
+				sanitized[sanitizedKey] = "<nil>"
+			}
+		case map[string]any:
+			// 递归清理嵌套 map
+			sanitized[sanitizedKey] = sanitizeAttributes(v)
+		case []any:
+			// 清理数组
+			sanitizedArray := make([]any, len(v))
+			for i, item := range v {
+				if str, ok := item.(string); ok {
+					sanitizedArray[i] = sanitizeLogString(str, 500)
+				} else {
+					sanitizedArray[i] = item
+				}
+			}
+			sanitized[sanitizedKey] = sanitizedArray
+		default:
+			// 其他类型（数字、布尔等）保持原样
+			sanitized[sanitizedKey] = value
+		}
+	}
+
+	return sanitized
+}