BlueGit

timfa bluegit

Files

bluegit / internal / realip / realip.go

realip.go

fix: installatiebeheerder ziet andermans gegevens niet
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
77270b74 History
realip.go 3.3 KiB Download Raw
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.
5package realip
6
7import (
8 "fmt"
9 "net"
10 "net/http"
11 "strings"
12)
13
14// Set is een lijst IP-adressen en CIDR-blokken.
15type Set struct {
16 nets []*net.IPNet
17}
18
19// Parse leest IP-adressen en CIDR-blokken. Een lege lijst vertrouwt niemand.
20func 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.
49func (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.
66func 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
84func 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
101func 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.
115func 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.
122func 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}