| 1 | // Package realip haalt het adres van de client achter een reverse proxy vandaan. |
| 2 | // X-Forwarded-For en X-Real-IP tellen alleen als de directe verbinding |
| 3 | // van een adres op de vertrouwenslijst komt. Een client die zelf een |
| 4 | // kop meestuurt, kan zijn adres daarmee niet vervalsen. |
| 5 | package realip |
| 6 | |
| 7 | import ( |
| 8 | "fmt" |
| 9 | "net" |
| 10 | "net/http" |
| 11 | "strings" |
| 12 | ) |
| 13 | |
| 14 | // Set is een lijst IP-adressen en CIDR-blokken. |
| 15 | type Set struct { |
| 16 | nets []*net.IPNet |
| 17 | } |
| 18 | |
| 19 | // Parse leest IP-adressen en CIDR-blokken. Een lege lijst vertrouwt niemand. |
| 20 | func Parse(entries []string) (*Set, error) { |
| 21 | s := &Set{} |
| 22 | for _, e := range entries { |
| 23 | e = strings.TrimSpace(e) |
| 24 | if e == "" { |
| 25 | continue |
| 26 | } |
| 27 | if strings.Contains(e, "/") { |
| 28 | _, n, err := net.ParseCIDR(e) |
| 29 | if err != nil { |
| 30 | return nil, fmt.Errorf("trusted_proxies: %q is geen CIDR", e) |
| 31 | } |
| 32 | s.nets = append(s.nets, n) |
| 33 | continue |
| 34 | } |
| 35 | ip := net.ParseIP(e) |
| 36 | if ip == nil { |
| 37 | return nil, fmt.Errorf("trusted_proxies: %q is geen IP-adres of CIDR", e) |
| 38 | } |
| 39 | bits := 32 |
| 40 | if ip.To4() == nil { |
| 41 | bits = 128 |
| 42 | } |
| 43 | s.nets = append(s.nets, &net.IPNet{IP: ip, Mask: net.CIDRMask(bits, bits)}) |
| 44 | } |
| 45 | return s, nil |
| 46 | } |
| 47 | |
| 48 | // Contains meldt of ip op de lijst staat. |
| 49 | func (s *Set) Contains(ip net.IP) bool { |
| 50 | if s == nil || ip == nil { |
| 51 | return false |
| 52 | } |
| 53 | for _, n := range s.nets { |
| 54 | if n.Contains(ip) { |
| 55 | return true |
| 56 | } |
| 57 | } |
| 58 | return false |
| 59 | } |
| 60 | |
| 61 | // ClientIP kiest het clientadres. |
| 62 | // remoteAddr is host:poort van de TCP-verbinding. xff is X-Forwarded-For, |
| 63 | // xReal is X-Real-IP. In de keten is het clientadres de rechtse hop die |
| 64 | // zelf geen vertrouwde proxy is. Zijn alle hops vertrouwd, dan blijft |
| 65 | // het adres van de directe verbinding staan. |
| 66 | func ClientIP(remoteAddr, xff, xReal string, trusted *Set) string { |
| 67 | peer, _, err := net.SplitHostPort(remoteAddr) |
| 68 | if err != nil { |
| 69 | peer = remoteAddr |
| 70 | } |
| 71 | peerIP := net.ParseIP(peer) |
| 72 | if trusted == nil || peerIP == nil || !trusted.Contains(peerIP) { |
| 73 | return peer |
| 74 | } |
| 75 | if ip := rightmostUntrusted(xff, trusted); ip != nil { |
| 76 | return ip.String() |
| 77 | } |
| 78 | if ip := parseToken(xReal); ip != nil && !trusted.Contains(ip) { |
| 79 | return ip.String() |
| 80 | } |
| 81 | return peer |
| 82 | } |
| 83 | |
| 84 | func rightmostUntrusted(xff string, trusted *Set) net.IP { |
| 85 | if strings.TrimSpace(xff) == "" { |
| 86 | return nil |
| 87 | } |
| 88 | parts := strings.Split(xff, ",") |
| 89 | for i := len(parts) - 1; i >= 0; i-- { |
| 90 | ip := parseToken(parts[i]) |
| 91 | if ip == nil { |
| 92 | continue |
| 93 | } |
| 94 | if !trusted.Contains(ip) { |
| 95 | return ip |
| 96 | } |
| 97 | } |
| 98 | return nil |
| 99 | } |
| 100 | |
| 101 | func parseToken(s string) net.IP { |
| 102 | s = strings.TrimSpace(s) |
| 103 | s = strings.Trim(s, `"`) |
| 104 | if s == "" { |
| 105 | return nil |
| 106 | } |
| 107 | if h, _, err := net.SplitHostPort(s); err == nil { |
| 108 | s = h |
| 109 | } |
| 110 | s = strings.Trim(s, "[]") |
| 111 | return net.ParseIP(s) |
| 112 | } |
| 113 | |
| 114 | // FromRequest leest de koppen van r. |
| 115 | func FromRequest(r *http.Request, trusted *Set) string { |
| 116 | xff := strings.Join(r.Header.Values("X-Forwarded-For"), ", ") |
| 117 | return ClientIP(r.RemoteAddr, xff, r.Header.Get("X-Real-IP"), trusted) |
| 118 | } |
| 119 | |
| 120 | // Apply zet r.RemoteAddr op het clientadres. De poort blijft alleen staan |
| 121 | // als het adres niet uit een proxykop komt; die poort is anders van de proxy. |
| 122 | func Apply(r *http.Request, trusted *Set) { |
| 123 | ip := FromRequest(r, trusted) |
| 124 | host, port, err := net.SplitHostPort(r.RemoteAddr) |
| 125 | if err != nil || port == "" { |
| 126 | r.RemoteAddr = net.JoinHostPort(ip, "0") |
| 127 | return |
| 128 | } |
| 129 | if parsed, got := net.ParseIP(host), net.ParseIP(ip); parsed == nil || got == nil || !parsed.Equal(got) { |
| 130 | port = "0" |
| 131 | } |
| 132 | r.RemoteAddr = net.JoinHostPort(ip, port) |
| 133 | } |