chore: clean .gitignore cache

2026-01-26 19:22:05 +00:00
parent e5f0fec5db
commit f64e3feef8
1448 changed files with 468101 additions and 0 deletions
--- a/docs/plans/url_test_security_fixes.md
+++ b/docs/plans/url_test_security_fixes.md
@@ -0,0 +1,369 @@
+# URL Test Security Fixes
+
+## Critical Security Updates Required
+
+### 1. DNS Rebinding Protection
+
+**Problem**: Current plan validates IPs after DNS lookup but makes HTTP request using hostname, allowing TOCTOU attack.
+
+**Solution**: Make HTTP request directly to validated IP address:
+
+```go
+func TestURLConnectivity(rawURL string) (bool, float64, error) {
+    parsed, err := url.Parse(rawURL)
+    if err != nil {
+        return false, 0, fmt.Errorf("invalid URL: %w", err)
+    }
+
+    host := parsed.Hostname()
+    port := parsed.Port()
+    if port == "" {
+        port = map[string]string{"https": "443", "http": "80"}[parsed.Scheme]
+    }
+
+    // Enforce HTTPS for security
+    if parsed.Scheme != "https" {
+        return false, 0, fmt.Errorf("HTTPS required")
+    }
+
+    // Validate port
+    allowedPorts := map[string]bool{"443": true, "8443": true}
+    if !allowedPorts[port] {
+        return false, 0, fmt.Errorf("port %s not allowed", port)
+    }
+
+    // Block metadata hostnames explicitly
+    forbiddenHosts := []string{
+        "metadata.google.internal", "metadata.goog", "metadata",
+        "169.254.169.254", "localhost",
+    }
+    for _, forbidden := range forbiddenHosts {
+        if strings.EqualFold(host, forbidden) {
+            return false, 0, fmt.Errorf("blocked hostname")
+        }
+    }
+
+    // DNS resolution with timeout
+    ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+    defer cancel()
+
+    ips, err := net.DefaultResolver.LookupIPAddr(ctx, host)
+    if err != nil {
+        return false, 0, fmt.Errorf("DNS failed: %w", err)
+    }
+    if len(ips) == 0 {
+        return false, 0, fmt.Errorf("no IPs found")
+    }
+
+    // SSRF protection: block private IPs
+    for _, ip := range ips {
+        if isPrivateIP(ip.IP) {
+            return false, 0, fmt.Errorf("private IP blocked: %s", ip.IP)
+        }
+    }
+
+    // Use first validated IP for request
+    validatedIP := ips[0].IP.String()
+
+    // Construct URL using validated IP
+    var targetURL string
+    if port != "" {
+        targetURL = fmt.Sprintf("%s://%s:%s%s", parsed.Scheme, validatedIP, port, parsed.Path)
+    } else {
+        targetURL = fmt.Sprintf("%s://%s%s", parsed.Scheme, validatedIP, parsed.Path)
+    }
+
+    // HTTP request with redirect validation
+    client := &http.Client{
+        Timeout: 5 * time.Second,
+        CheckRedirect: func(req *http.Request, via []*http.Request) error {
+            if len(via) >= 2 {
+                return fmt.Errorf("too many redirects")
+            }
+
+            // Validate redirect target
+            redirectHost := req.URL.Hostname()
+            redirectIPs, err := net.DefaultResolver.LookupIPAddr(ctx, redirectHost)
+            if err != nil {
+                return fmt.Errorf("redirect DNS failed: %w", err)
+            }
+            if len(redirectIPs) == 0 {
+                return fmt.Errorf("redirect DNS returned no IPs")
+            }
+
+            // Check redirect target IPs
+            for _, ip := range redirectIPs {
+                if isPrivateIP(ip.IP) {
+                    return fmt.Errorf("redirect to private IP blocked: %s", ip.IP)
+                }
+            }
+            return nil
+        },
+    }
+
+    start := time.Now()
+    req, err := http.NewRequestWithContext(ctx, http.MethodHead, targetURL, nil)
+    if err != nil {
+        return false, 0, fmt.Errorf("request creation failed: %w", err)
+    }
+
+    // Set Host header to original hostname for SNI/vhost routing
+    req.Host = parsed.Host
+    req.Header.Set("User-Agent", "Charon-Health-Check/1.0")
+
+    resp, err := client.Do(req)
+    latency := time.Since(start).Seconds() * 1000
+
+    if err != nil {
+        return false, 0, fmt.Errorf("connection failed: %w", err)
+    }
+    defer resp.Body.Close()
+
+    if resp.StatusCode >= 200 && resp.StatusCode < 400 {
+        return true, latency, nil
+    }
+
+    return false, latency, fmt.Errorf("status %d", resp.StatusCode)
+}
+```
+
+### 2. Complete IP Blocklist
+
+```go
+func isPrivateIP(ip net.IP) bool {
+    // Check special addresses
+    if ip.IsLoopback() || ip.IsLinkLocalUnicast() ||
+       ip.IsLinkLocalMulticast() || ip.IsMulticast() {
+        return true
+    }
+
+    // Check if it's IPv4 or IPv6
+    if ip.To4() != nil {
+        // IPv4 private ranges
+        privateBlocks := []string{
+            "0.0.0.0/8",          // Current network
+            "10.0.0.0/8",         // Private
+            "100.64.0.0/10",      // Shared address space (CGNAT)
+            "127.0.0.0/8",        // Loopback
+            "169.254.0.0/16",     // Link-local / Cloud metadata
+            "172.16.0.0/12",      // Private
+            "192.0.0.0/24",       // IETF protocol assignments
+            "192.0.2.0/24",       // TEST-NET-1
+            "192.168.0.0/16",     // Private
+            "198.18.0.0/15",      // Benchmarking
+            "198.51.100.0/24",    // TEST-NET-2
+            "203.0.113.0/24",     // TEST-NET-3
+            "224.0.0.0/4",        // Multicast
+            "240.0.0.0/4",        // Reserved
+            "255.255.255.255/32", // Broadcast
+        }
+
+        for _, block := range privateBlocks {
+            _, subnet, _ := net.ParseCIDR(block)
+            if subnet.Contains(ip) {
+                return true
+            }
+        }
+    } else {
+        // IPv6 private ranges
+        privateBlocks := []string{
+            "::1/128",       // Loopback
+            "::/128",        // Unspecified
+            "::ffff:0:0/96", // IPv4-mapped
+            "fe80::/10",     // Link-local
+            "fc00::/7",      // Unique local
+            "ff00::/8",      // Multicast
+        }
+
+        for _, block := range privateBlocks {
+            _, subnet, _ := net.ParseCIDR(block)
+            if subnet.Contains(ip) {
+                return true
+            }
+        }
+    }
+
+    return false
+}
+```
+
+### 3. Rate Limiting Implementation
+
+**Option A: Using golang.org/x/time/rate**
+
+```go
+import (
+    "golang.org/x/time/rate"
+    "sync"
+)
+
+var (
+    urlTestLimiters = make(map[string]*rate.Limiter)
+    limitersMutex   sync.RWMutex
+)
+
+func getUserLimiter(userID string) *rate.Limiter {
+    limitersMutex.Lock()
+    defer limitersMutex.Unlock()
+
+    limiter, exists := urlTestLimiters[userID]
+    if !exists {
+        // 5 requests per minute
+        limiter = rate.NewLimiter(rate.Every(12*time.Second), 5)
+        urlTestLimiters[userID] = limiter
+    }
+    return limiter
+}
+
+// In handler:
+func (h *SettingsHandler) TestPublicURL(c *gin.Context) {
+    userID, _ := c.Get("user_id") // Assuming auth middleware sets this
+    limiter := getUserLimiter(userID.(string))
+
+    if !limiter.Allow() {
+        c.JSON(http.StatusTooManyRequests, gin.H{
+            "error": "Rate limit exceeded. Try again later.",
+        })
+        return
+    }
+
+    // ... rest of handler
+}
+```
+
+**Option B: Middleware approach**
+
+Create `backend/internal/middleware/rate_limit.go`:
+
+```go
+package middleware
+
+import (
+    "net/http"
+    "sync"
+    "time"
+
+    "github.com/gin-gonic/gin"
+    "golang.org/x/time/rate"
+)
+
+type RateLimiter struct {
+    limiters map[string]*rate.Limiter
+    mu       sync.RWMutex
+    rate     rate.Limit
+    burst    int
+}
+
+func NewRateLimiter(rps float64, burst int) *RateLimiter {
+    return &RateLimiter{
+        limiters: make(map[string]*rate.Limiter),
+        rate:     rate.Limit(rps),
+        burst:    burst,
+    }
+}
+
+func (rl *RateLimiter) getLimiter(key string) *rate.Limiter {
+    rl.mu.Lock()
+    defer rl.mu.Unlock()
+
+    limiter, exists := rl.limiters[key]
+    if !exists {
+        limiter = rate.NewLimiter(rl.rate, rl.burst)
+        rl.limiters[key] = limiter
+    }
+    return limiter
+}
+
+func (rl *RateLimiter) Limit() gin.HandlerFunc {
+    return func(c *gin.Context) {
+        userID, exists := c.Get("user_id")
+        if !exists {
+            c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{
+                "error": "Authentication required",
+            })
+            return
+        }
+
+        limiter := rl.getLimiter(userID.(string))
+        if !limiter.Allow() {
+            c.AbortWithStatusJSON(http.StatusTooManyRequests, gin.H{
+                "error": "Rate limit exceeded. Maximum 5 tests per minute.",
+            })
+            return
+        }
+
+        c.Next()
+    }
+}
+```
+
+Usage in routes:
+
+```go
+urlTestLimiter := middleware.NewRateLimiter(5.0/60.0, 5) // 5 per minute
+protected.POST("/settings/test-url",
+    urlTestLimiter.Limit(),
+    settingsHandler.TestPublicURL)
+```
+
+### 4. Integration Test for DNS Rebinding
+
+```go
+// backend/internal/utils/url_test_test.go
+
+func TestTestURLConnectivity_DNSRebinding(t *testing.T) {
+    // This test verifies that we make HTTP request to resolved IP,
+    // not the hostname, preventing DNS rebinding attacks
+
+    // Create test server that only responds to direct IP requests
+    ts := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+        // Verify request was made to IP, not hostname
+        if r.Host != r.RemoteAddr {
+            t.Errorf("Expected request to IP address, got Host: %s", r.Host)
+        }
+        w.WriteHeader(http.StatusOK)
+    }))
+    defer ts.Close()
+
+    // Extract IP from test server URL
+    parsedURL, _ := url.Parse(ts.URL)
+    serverIP := parsedURL.Hostname()
+
+    // Test that we can connect using IP directly
+    reachable, _, err := TestURLConnectivity(fmt.Sprintf("https://%s", serverIP))
+    if err != nil || !reachable {
+        t.Errorf("Failed to connect to test server: %v", err)
+    }
+}
+```
+
+## Summary of Changes
+
+### Security Fixes
+
+1. ✅ DNS rebinding protection: HTTP request uses validated IP
+2. ✅ Redirect validation: Check redirect targets for private IPs
+3. ✅ Rate limiting: 5 requests per minute per user
+4. ✅ Complete IP blocklist: All RFC reserved ranges
+5. ✅ Hostname blocklist: Cloud metadata endpoints
+6. ✅ HTTPS enforcement: Require secure connections
+7. ✅ Port restrictions: Only 443, 8443 allowed
+
+### Implementation Notes
+
+- Uses `req.Host` header for SNI/vhost routing while making request to IP
+- Validates redirect targets before following
+- Comprehensive IPv4 and IPv6 private range blocking
+- Per-user rate limiting with token bucket algorithm
+- Integration test verifies DNS rebinding protection
+
+### Testing Checklist
+
+- [ ] Test public HTTPS URL → Success
+- [ ] Test HTTP URL → Rejected (HTTPS required)
+- [ ] Test private IP → Blocked
+- [ ] Test metadata endpoint → Blocked by hostname
+- [ ] Test redirect to private IP → Blocked
+- [ ] Test rate limit → 429 after 5 requests
+- [ ] Test non-standard port → Rejected
+- [ ] Test DNS rebinding scenario → Protected