mirror of
https://github.com/chaitin/MonkeyCode.git
synced 2026-11-22 19:39:31 +08:00
164 lines
4.1 KiB
Go
164 lines
4.1 KiB
Go
package middleware
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"io"
|
|
"log/slog"
|
|
"net/http"
|
|
|
|
"github.com/labstack/echo/v4"
|
|
|
|
"github.com/chaitin/MonkeyCode/backend/domain"
|
|
)
|
|
|
|
// responseWriter 包装 http.ResponseWriter 以捕获响应内容
|
|
type responseWriter struct {
|
|
http.ResponseWriter
|
|
body *bytes.Buffer
|
|
}
|
|
|
|
func (w *responseWriter) Write(data []byte) (int, error) {
|
|
w.body.Write(data)
|
|
return w.ResponseWriter.Write(data)
|
|
}
|
|
|
|
// AuditMiddleware 审计中间件
|
|
type AuditMiddleware struct {
|
|
logger *slog.Logger
|
|
usecase domain.AuditUsecase
|
|
userUsecase domain.UserUsecase
|
|
}
|
|
|
|
// NewAuditMiddleware 创建审计中间件
|
|
func NewAuditMiddleware(
|
|
logger *slog.Logger,
|
|
usecase domain.AuditUsecase,
|
|
userUsecase domain.UserUsecase,
|
|
) *AuditMiddleware {
|
|
return &AuditMiddleware{
|
|
logger: logger.With("module", "AuditMiddleware"),
|
|
usecase: usecase,
|
|
userUsecase: userUsecase,
|
|
}
|
|
}
|
|
|
|
// Audit 审计中间件
|
|
func (a *AuditMiddleware) Audit(operation string) echo.MiddlewareFunc {
|
|
return func(next echo.HandlerFunc) echo.HandlerFunc {
|
|
return func(c echo.Context) error {
|
|
ctx := c.Request().Context()
|
|
teamUser := GetTeamUser(c)
|
|
|
|
// 请求体
|
|
bodyBytes, err := io.ReadAll(c.Request().Body)
|
|
if err != nil {
|
|
a.logger.ErrorContext(ctx, "failed to read request body", "error", err)
|
|
return next(c)
|
|
}
|
|
c.Request().Body = io.NopCloser(bytes.NewReader(bodyBytes))
|
|
requestBody := string(bodyBytes)
|
|
|
|
// 响应体
|
|
respWriter := &responseWriter{ResponseWriter: c.Response().Writer, body: &bytes.Buffer{}}
|
|
c.Response().Writer = respWriter
|
|
|
|
err = next(c)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// 响应内容
|
|
responseBody := respWriter.body.String()
|
|
|
|
if operation == "team_user_login" {
|
|
req := &domain.TeamLoginReq{}
|
|
err = json.Unmarshal(bodyBytes, req)
|
|
if err != nil {
|
|
a.logger.ErrorContext(ctx, "failed to unmarshal login response body", "error", err)
|
|
return nil
|
|
}
|
|
users, err := a.userUsecase.GetUserByEmail(ctx, []string{req.Email})
|
|
if err != nil {
|
|
a.logger.ErrorContext(ctx, "failed to get user by email", "error", err)
|
|
return nil
|
|
}
|
|
teamUser = &domain.TeamUser{
|
|
User: &domain.User{},
|
|
}
|
|
if len(users) > 0 {
|
|
teamUser = &domain.TeamUser{
|
|
User: users[0],
|
|
Team: users[0].Team,
|
|
}
|
|
}
|
|
}
|
|
|
|
// 构建审计记录,需要检查 teamUser 和 teamUser.User 是否为 nil
|
|
audit := &domain.Audit{
|
|
SourceIP: c.RealIP(),
|
|
UserAgent: c.Request().UserAgent(),
|
|
Request: requestBody,
|
|
Response: responseBody,
|
|
Operation: operation,
|
|
User: teamUser.User,
|
|
}
|
|
reqBody, respBody, err := maskSensitiveData(operation, requestBody, responseBody)
|
|
if err != nil {
|
|
a.logger.ErrorContext(ctx, "failed to mask sensitive data", "error", err)
|
|
return nil
|
|
}
|
|
audit.Request = reqBody
|
|
audit.Response = respBody
|
|
err = a.usecase.CreateAudit(ctx, audit)
|
|
if err != nil {
|
|
a.logger.ErrorContext(ctx, "failed to create audit", "error", err)
|
|
}
|
|
return nil
|
|
}
|
|
}
|
|
}
|
|
|
|
// maskJSON 通用的 JSON 脱敏处理函数
|
|
// maskFunc 是一个函数,接收解析后的对象并对其进行脱敏处理
|
|
func maskJSON[T any](body string, maskFunc func(*T)) (string, error) {
|
|
if body == "" {
|
|
return body, nil
|
|
}
|
|
var obj T
|
|
if err := json.Unmarshal([]byte(body), &obj); err != nil {
|
|
return body, nil // 如果解析失败,返回原始内容(不报错,避免影响审计流程)
|
|
}
|
|
maskFunc(&obj)
|
|
bytes, err := json.Marshal(obj)
|
|
if err != nil {
|
|
return body, err
|
|
}
|
|
return string(bytes), nil
|
|
}
|
|
|
|
// maskSensitiveData 数据脱敏处理
|
|
func maskSensitiveData(operation, reqBody, respBody string) (string, string, error) {
|
|
var err error
|
|
|
|
switch operation {
|
|
case "team_user_login":
|
|
reqBody, err = maskJSON(reqBody, func(req *domain.TeamLoginReq) {
|
|
req.Password = "********"
|
|
})
|
|
if err != nil {
|
|
return "", "", err
|
|
}
|
|
case "change_team_user_password":
|
|
reqBody, err = maskJSON(reqBody, func(req *domain.ChangePasswordReq) {
|
|
req.CurrentPassword = "********"
|
|
req.NewPassword = "********"
|
|
})
|
|
if err != nil {
|
|
return "", "", err
|
|
}
|
|
}
|
|
|
|
return reqBody, respBody, nil
|
|
}
|