// Package realip haalt het adres van de client achter een reverse proxy vandaan. // X-Forwarded-For en X-Real-IP tellen alleen als de directe verbinding // van een adres op de vertrouwenslijst komt. Een client die zelf een // kop meestuurt, kan zijn adres daarmee niet vervalsen. package realip import ( "fmt" "net" "net/http" "strings" ) // Set is een lijst IP-adressen en CIDR-blokken. type Set struct { nets []*net.IPNet } // Parse leest IP-adressen en CIDR-blokken. Een lege lijst vertrouwt niemand. func Parse(entries []string) (*Set, error) { s := &Set{} for _, e := range entries { e = strings.TrimSpace(e) if e == "" { continue } if strings.Contains(e, "/") { _, n, err := net.ParseCIDR(e) if err != nil { return nil, fmt.Errorf("trusted_proxies: %q is geen CIDR", e) } s.nets = append(s.nets, n) continue } ip := net.ParseIP(e) if ip == nil { return nil, fmt.Errorf("trusted_proxies: %q is geen IP-adres of CIDR", e) } bits := 32 if ip.To4() == nil { bits = 128 } s.nets = append(s.nets, &net.IPNet{IP: ip, Mask: net.CIDRMask(bits, bits)}) } return s, nil } // Contains meldt of ip op de lijst staat. func (s *Set) Contains(ip net.IP) bool { if s == nil || ip == nil { return false } for _, n := range s.nets { if n.Contains(ip) { return true } } return false } // ClientIP kiest het clientadres. // remoteAddr is host:poort van de TCP-verbinding. xff is X-Forwarded-For, // xReal is X-Real-IP. In de keten is het clientadres de rechtse hop die // zelf geen vertrouwde proxy is. Zijn alle hops vertrouwd, dan blijft // het adres van de directe verbinding staan. func ClientIP(remoteAddr, xff, xReal string, trusted *Set) string { peer, _, err := net.SplitHostPort(remoteAddr) if err != nil { peer = remoteAddr } peerIP := net.ParseIP(peer) if trusted == nil || peerIP == nil || !trusted.Contains(peerIP) { return peer } if ip := rightmostUntrusted(xff, trusted); ip != nil { return ip.String() } if ip := parseToken(xReal); ip != nil && !trusted.Contains(ip) { return ip.String() } return peer } func rightmostUntrusted(xff string, trusted *Set) net.IP { if strings.TrimSpace(xff) == "" { return nil } parts := strings.Split(xff, ",") for i := len(parts) - 1; i >= 0; i-- { ip := parseToken(parts[i]) if ip == nil { continue } if !trusted.Contains(ip) { return ip } } return nil } func parseToken(s string) net.IP { s = strings.TrimSpace(s) s = strings.Trim(s, `"`) if s == "" { return nil } if h, _, err := net.SplitHostPort(s); err == nil { s = h } s = strings.Trim(s, "[]") return net.ParseIP(s) } // FromRequest leest de koppen van r. func FromRequest(r *http.Request, trusted *Set) string { xff := strings.Join(r.Header.Values("X-Forwarded-For"), ", ") return ClientIP(r.RemoteAddr, xff, r.Header.Get("X-Real-IP"), trusted) } // Apply zet r.RemoteAddr op het clientadres. De poort blijft alleen staan // als het adres niet uit een proxykop komt; die poort is anders van de proxy. func Apply(r *http.Request, trusted *Set) { ip := FromRequest(r, trusted) host, port, err := net.SplitHostPort(r.RemoteAddr) if err != nil || port == "" { r.RemoteAddr = net.JoinHostPort(ip, "0") return } if parsed, got := net.ParseIP(host), net.ParseIP(ip); parsed == nil || got == nil || !parsed.Equal(got) { port = "0" } r.RemoteAddr = net.JoinHostPort(ip, port) }