298 lines
11 KiB
Go
298 lines
11 KiB
Go
package server
|
|
|
|
import (
|
|
"net"
|
|
"net/http"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
|
|
"warpbox/lib/activity"
|
|
"warpbox/lib/alerts"
|
|
"warpbox/lib/security"
|
|
)
|
|
|
|
type adminAlertsActionRequest struct {
|
|
Action string `json:"action"`
|
|
IDs []string `json:"ids"`
|
|
}
|
|
|
|
type adminSecurityActionRequest struct {
|
|
Action string `json:"action"`
|
|
IP string `json:"ip"`
|
|
IPs []string `json:"ips"`
|
|
BanUntil string `json:"ban_until"`
|
|
}
|
|
|
|
func (app *App) reloadSecurityConfig() {
|
|
if app.securityGuard == nil {
|
|
app.securityGuard = security.NewGuard()
|
|
}
|
|
if app.config != nil {
|
|
_ = app.securityGuard.EnableBanPersistence(filepath.Join(app.config.DBDir, "bans.badger"))
|
|
}
|
|
_ = app.securityGuard.Reload(security.Config{
|
|
IPWhitelist: app.config.SecurityIPWhitelist,
|
|
AdminIPWhitelist: app.config.SecurityAdminIPWhitelist,
|
|
LoginWindowSeconds: app.config.SecurityLoginWindowSeconds,
|
|
LoginMaxAttempts: app.config.SecurityLoginMaxAttempts,
|
|
BanSeconds: app.config.SecurityBanSeconds,
|
|
ScanWindowSeconds: app.config.SecurityScanWindowSeconds,
|
|
ScanMaxAttempts: app.config.SecurityScanMaxAttempts,
|
|
UploadWindowSeconds: app.config.SecurityUploadWindowSeconds,
|
|
UploadMaxRequests: app.config.SecurityUploadMaxRequests,
|
|
UploadMaxBytes: app.config.SecurityUploadMaxBytes,
|
|
})
|
|
}
|
|
|
|
func (app *App) logActivity(kind string, severity string, message string, ctx *gin.Context, meta map[string]string) {
|
|
if app.activityStore == nil {
|
|
return
|
|
}
|
|
event := activity.Event{
|
|
Kind: kind,
|
|
Severity: severity,
|
|
Message: message,
|
|
CreatedAt: time.Now().UTC(),
|
|
Meta: meta,
|
|
}
|
|
if ctx != nil {
|
|
event.IP = app.clientIP(ctx)
|
|
event.Path = ctx.Request.URL.Path
|
|
event.Method = ctx.Request.Method
|
|
}
|
|
_ = app.activityStore.Append(event, app.config.ActivityRetentionSeconds)
|
|
}
|
|
|
|
func (app *App) createAlert(title string, severity string, group string, code string, trace string, message string, meta map[string]string) {
|
|
if app.alertStore == nil {
|
|
return
|
|
}
|
|
_ = app.alertStore.Add(alerts.Alert{
|
|
Title: title,
|
|
Severity: severity,
|
|
Group: group,
|
|
Code: code,
|
|
Trace: trace,
|
|
Message: message,
|
|
Status: alerts.StatusOpen,
|
|
Meta: meta,
|
|
})
|
|
}
|
|
|
|
func (app *App) securityMiddleware() gin.HandlerFunc {
|
|
return func(ctx *gin.Context) {
|
|
if app.securityGuard == nil {
|
|
ctx.Next()
|
|
return
|
|
}
|
|
ip := app.clientIP(ctx)
|
|
if app.securityGuard.IsWhitelisted(ip) || app.securityGuard.IsAdminWhitelisted(ip) {
|
|
ctx.Next()
|
|
return
|
|
}
|
|
if app.securityGuard.IsBanned(ip) {
|
|
app.logActivity("security.block", "high", "Blocked banned IP", ctx, nil)
|
|
ctx.AbortWithStatusJSON(http.StatusTooManyRequests, gin.H{"error": "Too many abusive requests. Try again later."})
|
|
return
|
|
}
|
|
ctx.Next()
|
|
}
|
|
}
|
|
|
|
func (app *App) handleNoRoute(ctx *gin.Context) {
|
|
if app.securityGuard == nil {
|
|
ctx.JSON(http.StatusNotFound, gin.H{"error": "Not found"})
|
|
return
|
|
}
|
|
path := strings.ToLower(ctx.Request.URL.Path)
|
|
suspicious := strings.Contains(path, "../") || strings.Contains(path, ".php") || strings.Contains(path, "wp-admin") || strings.Contains(path, ".env")
|
|
if suspicious {
|
|
ip := app.clientIP(ctx)
|
|
if !app.securityGuard.IsWhitelisted(ip) {
|
|
banned, attempts := app.securityGuard.RegisterScanAttempt(ip, app.config.SecurityScanWindowSeconds, app.config.SecurityScanMaxAttempts, app.config.SecurityBanSeconds)
|
|
app.logActivity("security.scan", "medium", "Suspicious path probe detected", ctx, map[string]string{"attempts": intToString(attempts)})
|
|
if banned {
|
|
app.createAlert("IP auto-banned after malicious path scans", "high", "security", "410", "security.scan.autoban", "Repeated malicious path scans triggered temporary ban.", map[string]string{"ip": ip, "attempts": intToString(attempts)})
|
|
app.logActivity("security.ban", "high", "IP auto-banned after scans", ctx, map[string]string{"attempts": intToString(attempts)})
|
|
}
|
|
}
|
|
}
|
|
ctx.JSON(http.StatusNotFound, gin.H{"error": "Not found"})
|
|
}
|
|
|
|
func (app *App) handleAdminActivity(ctx *gin.Context) {
|
|
if app.activityStore == nil {
|
|
ctx.HTML(http.StatusOK, "admin/activity.html", gin.H{
|
|
"AdminUsername": app.config.AdminUsername,
|
|
"AdminEmail": app.config.AdminEmail,
|
|
"ActivePage": "activity",
|
|
"Events": []activity.Event{},
|
|
})
|
|
return
|
|
}
|
|
events, err := app.activityStore.List(400, app.config.ActivityRetentionSeconds)
|
|
if err != nil {
|
|
ctx.String(http.StatusInternalServerError, "Could not load activity")
|
|
return
|
|
}
|
|
ctx.HTML(http.StatusOK, "admin/activity.html", gin.H{
|
|
"AdminUsername": app.config.AdminUsername,
|
|
"AdminEmail": app.config.AdminEmail,
|
|
"ActivePage": "activity",
|
|
"Events": events,
|
|
})
|
|
}
|
|
|
|
func (app *App) handleAdminSecurity(ctx *gin.Context) {
|
|
events := []activity.Event{}
|
|
alertsList := []alerts.Alert{}
|
|
if app.activityStore != nil {
|
|
events, _ = app.activityStore.List(300, app.config.ActivityRetentionSeconds)
|
|
}
|
|
if app.alertStore != nil {
|
|
alertsList, _ = app.alertStore.List(120)
|
|
}
|
|
bans := []security.BanEntry{}
|
|
if app.securityGuard != nil {
|
|
bans = app.securityGuard.BanList()
|
|
}
|
|
ctx.HTML(http.StatusOK, "admin/security.html", gin.H{
|
|
"AdminUsername": app.config.AdminUsername,
|
|
"AdminEmail": app.config.AdminEmail,
|
|
"ActivePage": "security",
|
|
"Events": events,
|
|
"Alerts": alertsList,
|
|
"Bans": bans,
|
|
})
|
|
}
|
|
|
|
func (app *App) handleAdminAlertsAction(ctx *gin.Context) {
|
|
if app.alertStore == nil {
|
|
ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Alert store unavailable"})
|
|
return
|
|
}
|
|
var request adminAlertsActionRequest
|
|
if err := ctx.ShouldBindJSON(&request); err != nil {
|
|
ctx.JSON(http.StatusBadRequest, gin.H{"error": "Invalid action payload"})
|
|
return
|
|
}
|
|
switch request.Action {
|
|
case "ack":
|
|
if err := app.alertStore.SetStatus(request.IDs, alerts.StatusAcked); err != nil {
|
|
ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Could not update alerts"})
|
|
return
|
|
}
|
|
case "close":
|
|
if err := app.alertStore.SetStatus(request.IDs, alerts.StatusClosed); err != nil {
|
|
ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Could not update alerts"})
|
|
return
|
|
}
|
|
case "delete":
|
|
if err := app.alertStore.Delete(request.IDs); err != nil {
|
|
ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Could not delete alerts"})
|
|
return
|
|
}
|
|
default:
|
|
ctx.JSON(http.StatusBadRequest, gin.H{"error": "Unknown action"})
|
|
return
|
|
}
|
|
app.logActivity("alerts.action", "low", "Admin changed alert state", ctx, map[string]string{"action": request.Action, "count": intToString(len(request.IDs))})
|
|
alertsList, _ := app.alertStore.List(500)
|
|
ctx.JSON(http.StatusOK, gin.H{"ok": true, "alerts": alertsList})
|
|
}
|
|
|
|
func (app *App) recordManualBanAction(ctx *gin.Context, kind string, message string, severity string, ip string, meta map[string]string, alertTitle string, alertSeverity string, code string, trace string, alertMessage string) {
|
|
metaCopy := map[string]string{"ip": ip}
|
|
for k, v := range meta {
|
|
metaCopy[k] = v
|
|
}
|
|
app.logActivity(kind, severity, message, ctx, metaCopy)
|
|
app.createAlert(alertTitle, alertSeverity, "security", code, trace, alertMessage, metaCopy)
|
|
}
|
|
|
|
func (app *App) handleAdminSecurityAction(ctx *gin.Context) {
|
|
if app.securityGuard == nil {
|
|
ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Security guard unavailable"})
|
|
return
|
|
}
|
|
var request adminSecurityActionRequest
|
|
if err := ctx.ShouldBindJSON(&request); err != nil {
|
|
ctx.JSON(http.StatusBadRequest, gin.H{"error": "Invalid action payload"})
|
|
return
|
|
}
|
|
ip := strings.TrimSpace(request.IP)
|
|
if ip != "" && net.ParseIP(ip) == nil {
|
|
ctx.JSON(http.StatusBadRequest, gin.H{"error": "Invalid IP"})
|
|
return
|
|
}
|
|
|
|
switch request.Action {
|
|
case "ban":
|
|
if ip == "" {
|
|
ctx.JSON(http.StatusBadRequest, gin.H{"error": "Missing IP"})
|
|
return
|
|
}
|
|
app.securityGuard.Ban(ip, app.config.SecurityBanSeconds)
|
|
app.recordManualBanAction(ctx, "security.manual_ban", "Admin banned IP", "high", ip, nil, "IP manually banned by admin", "medium", "420", "security.manual.ban", "Admin manually applied temporary ban.")
|
|
ctx.JSON(http.StatusOK, gin.H{"ok": true, "message": "IP banned", "bans": app.securityGuard.BanList()})
|
|
case "ban_until":
|
|
if ip == "" {
|
|
ctx.JSON(http.StatusBadRequest, gin.H{"error": "Missing IP"})
|
|
return
|
|
}
|
|
until, err := time.Parse(time.RFC3339, strings.TrimSpace(request.BanUntil))
|
|
if err != nil || until.Before(time.Now().UTC()) {
|
|
ctx.JSON(http.StatusBadRequest, gin.H{"error": "Invalid ban expiration"})
|
|
return
|
|
}
|
|
app.securityGuard.BanUntil(ip, until)
|
|
meta := map[string]string{"until": until.UTC().Format(time.RFC3339)}
|
|
app.recordManualBanAction(ctx, "security.manual_ban_until", "Admin set custom ban expiration", "high", ip, meta, "Custom IP ban applied by admin", "medium", "421", "security.manual.ban_until", "Admin set explicit ban expiration date.")
|
|
ctx.JSON(http.StatusOK, gin.H{"ok": true, "message": "IP ban expiration updated", "bans": app.securityGuard.BanList()})
|
|
case "unban":
|
|
if ip == "" {
|
|
ctx.JSON(http.StatusBadRequest, gin.H{"error": "Missing IP"})
|
|
return
|
|
}
|
|
app.securityGuard.Unban(ip)
|
|
app.recordManualBanAction(ctx, "security.manual_unban", "Admin unbanned IP", "medium", ip, nil, "IP unbanned by admin", "low", "422", "security.manual.unban", "Admin manually removed temporary ban.")
|
|
ctx.JSON(http.StatusOK, gin.H{"ok": true, "message": "IP unbanned", "bans": app.securityGuard.BanList()})
|
|
case "bulk_unban":
|
|
if len(request.IPs) == 0 {
|
|
ctx.JSON(http.StatusBadRequest, gin.H{"error": "Missing IP list"})
|
|
return
|
|
}
|
|
count := 0
|
|
for _, candidate := range request.IPs {
|
|
candidate = strings.TrimSpace(candidate)
|
|
if net.ParseIP(candidate) == nil {
|
|
continue
|
|
}
|
|
app.securityGuard.Unban(candidate)
|
|
count++
|
|
}
|
|
app.logActivity("security.manual_bulk_unban", "high", "Admin unbanned multiple IPs", ctx, map[string]string{"count": intToString(count)})
|
|
app.createAlert("Bulk IP unban by admin", "medium", "security", "423", "security.manual.bulk_unban", "Admin manually removed multiple temporary bans.", map[string]string{"count": intToString(count)})
|
|
ctx.JSON(http.StatusOK, gin.H{"ok": true, "message": "Bulk unban complete", "bans": app.securityGuard.BanList()})
|
|
case "unban_all":
|
|
current := app.securityGuard.BanList()
|
|
for _, ban := range current {
|
|
app.securityGuard.Unban(ban.IP)
|
|
}
|
|
count := len(current)
|
|
app.logActivity("security.manual_unban_all", "high", "Admin cleared all active bans", ctx, map[string]string{"count": intToString(count)})
|
|
app.createAlert("All active bans cleared by admin", "medium", "security", "424", "security.manual.unban_all", "Admin manually removed all temporary bans.", map[string]string{"count": intToString(count)})
|
|
ctx.JSON(http.StatusOK, gin.H{"ok": true, "message": "All bans cleared", "bans": app.securityGuard.BanList()})
|
|
default:
|
|
ctx.JSON(http.StatusBadRequest, gin.H{"error": "Unknown action"})
|
|
}
|
|
}
|
|
|
|
func intToString(value int) string {
|
|
return strconv.Itoa(value)
|
|
}
|