BlueGit

timfa bluegit

Files

bluegit / internal / ssrf / ssrf.go

ssrf.go

feat: webhooks weren privénetten en de beheerder kiest de datadisk
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
1ab44366 History
ssrf.go 5.9 KiB Download Raw
1// Package ssrf keurt webhook-bestemmingen.
2// Privénetwerken zijn geblokkeerd. Een naam die naar een publiek IP
3// wijst mag wel, ook als een router dat verkeer daarna terug naar huis
4// stuurt. Het IP wordt bij het verbinden vastgezet, zodat een tweede
5// DNS-antwoord niet alsnog een privéadres kan worden.
6package ssrf
7
8import (
9 "context"
10 "fmt"
11 "net"
12 "net/http"
13 "net/url"
14 "strings"
15 "time"
16)
17
18// MaxRedirects is het aantal hops dat een webhook nog volgt.
19const MaxRedirects = 3
20
21var (
22 v4Blocked []*net.IPNet
23 v6Blocked []*net.IPNet
24)
25
26func init() {
27 // RFC1918, loopback, link-local (daar zit 169.254.169.254 bij),
28 // CGNAT, unspecified, multicast en gereserveerd.
29 v4Blocked = mustCIDR(
30 "0.0.0.0/8",
31 "10.0.0.0/8",
32 "100.64.0.0/10",
33 "127.0.0.0/8",
34 "169.254.0.0/16",
35 "172.16.0.0/12",
36 "192.168.0.0/16",
37 "224.0.0.0/4",
38 "240.0.0.0/4",
39 )
40 // Loopback, ULA, link-local, het oude site-local, multicast.
41 v6Blocked = mustCIDR(
42 "::1/128",
43 "fc00::/7",
44 "fe80::/10",
45 "fec0::/10",
46 "ff00::/8",
47 )
48}
49
50func mustCIDR(cidrs ...string) []*net.IPNet {
51 var out []*net.IPNet
52 for _, c := range cidrs {
53 _, n, err := net.ParseCIDR(c)
54 if err != nil {
55 panic(err)
56 }
57 out = append(out, n)
58 }
59 return out
60}
61
62// Private meldt of ip geen publiek unicast-adres is.
63// IPv4-mapped adressen, 6to4 en NAT64 (64:ff9b::/96) worden beoordeeld
64// op het ingebedde IPv4-adres.
65func Private(ip net.IP) bool {
66 if ip == nil {
67 return true
68 }
69 if v4 := embeddedV4(ip); v4 != nil {
70 return privateV4(v4)
71 }
72 if v4 := ip.To4(); v4 != nil {
73 return privateV4(v4)
74 }
75 v6 := ip.To16()
76 if v6 == nil {
77 return true
78 }
79 if v6.Equal(net.IPv6unspecified) {
80 return true
81 }
82 for _, n := range v6Blocked {
83 if n.Contains(v6) {
84 return true
85 }
86 }
87 return false
88}
89
90func privateV4(ip net.IP) bool {
91 ip = ip.To4()
92 if ip == nil {
93 return true
94 }
95 for _, n := range v4Blocked {
96 if n.Contains(ip) {
97 return true
98 }
99 }
100 return false
101}
102
103// embeddedV4 haalt een IPv4-adres uit 6to4 (2002::/16) of NAT64 (64:ff9b::/96).
104func embeddedV4(ip net.IP) net.IP {
105 v6 := ip.To16()
106 if v6 == nil || ip.To4() != nil {
107 return nil
108 }
109 if v6[0] == 0x20 && v6[1] == 0x02 {
110 return net.IPv4(v6[2], v6[3], v6[4], v6[5]).To4()
111 }
112 if v6[0] == 0x00 && v6[1] == 0x64 && v6[2] == 0xff && v6[3] == 0x9b && allZero(v6[4:12]) {
113 return net.IPv4(v6[12], v6[13], v6[14], v6[15]).To4()
114 }
115 return nil
116}
117
118func allZero(b []byte) bool {
119 for _, c := range b {
120 if c != 0 {
121 return false
122 }
123 }
124 return true
125}
126
127// Lookup zoekt de adressen van een hostnaam. Tests vullen een eigen functie in.
128type Lookup func(ctx context.Context, host string) ([]net.IP, error)
129
130func defaultLookup(ctx context.Context, host string) ([]net.IP, error) {
131 addrs, err := net.DefaultResolver.LookupIPAddr(ctx, host)
132 if err != nil {
133 return nil, err
134 }
135 out := make([]net.IP, 0, len(addrs))
136 for _, a := range addrs {
137 out = append(out, a.IP)
138 }
139 return out, nil
140}
141
142// Pin kiest het IP waarmee verbonden wordt.
143// Een letterlijk privéadres wordt geweigerd zonder DNS. Een naam waarvan
144// minstens één adres geblokkeerd is, wordt helemaal geweigerd: anders kan
145// het tweede antwoord alsnog naar het lokale net wijzen.
146func Pin(ctx context.Context, host string, lookup Lookup) (net.IP, error) {
147 host = strings.TrimSuffix(strings.TrimSpace(host), ".")
148 if host == "" {
149 return nil, fmt.Errorf("webhook-host ontbreekt")
150 }
151 if ip := net.ParseIP(host); ip != nil {
152 if Private(ip) {
153 return nil, fmt.Errorf("%s ligt in een geblokkeerd bereik", ip)
154 }
155 return ip, nil
156 }
157 if lookup == nil {
158 lookup = defaultLookup
159 }
160 ips, err := lookup(ctx, host)
161 if err != nil {
162 return nil, fmt.Errorf("dns voor %s: %w", host, err)
163 }
164 if len(ips) == 0 {
165 return nil, fmt.Errorf("geen adres voor %s", host)
166 }
167 for _, ip := range ips {
168 if Private(ip) {
169 return nil, fmt.Errorf("%s wijst naar %s in een geblokkeerd bereik", host, ip)
170 }
171 }
172 return ips[0], nil
173}
174
175// ValidateURL keurt het schema, een userinfo en een letterlijk privéadres af.
176func ValidateURL(u *url.URL) error {
177 if u == nil || u.Hostname() == "" || u.User != nil {
178 return fmt.Errorf("webhook-URL is ongeldig")
179 }
180 if u.Scheme != "http" && u.Scheme != "https" {
181 return fmt.Errorf("webhook-URL moet http of https zijn")
182 }
183 if ip := net.ParseIP(u.Hostname()); ip != nil && Private(ip) {
184 return fmt.Errorf("%s ligt in een geblokkeerd bereik", ip)
185 }
186 return nil
187}
188
189func checkRedirect(req *http.Request, via []*http.Request) error {
190 if len(via) >= MaxRedirects {
191 return fmt.Errorf("te veel redirects")
192 }
193 if err := ValidateURL(req.URL); err != nil {
194 return err
195 }
196 if len(via) == 0 || via[0].URL == nil || sameHost(via[0].URL, req.URL) {
197 return nil
198 }
199 if req.Response != nil && (req.Response.StatusCode == http.StatusTemporaryRedirect || req.Response.StatusCode == http.StatusPermanentRedirect) {
200 return fmt.Errorf("redirect naar een andere host met de oorspronkelijke body is geweigerd")
201 }
202 for k := range req.Header {
203 if strings.EqualFold(k, "Content-Type") || strings.EqualFold(k, "User-Agent") {
204 continue
205 }
206 req.Header.Del(k)
207 }
208 return nil
209}
210
211func sameHost(a, b *url.URL) bool {
212 if a == nil || b == nil {
213 return false
214 }
215 return strings.EqualFold(a.Hostname(), b.Hostname())
216}
217
218// NewClient belt alleen publieke IP's en zet het gekozen adres vast.
219// Omgevingsproxies worden niet gebruikt.
220func NewClient(timeout time.Duration) *http.Client {
221 dialer := &net.Dialer{Timeout: 5 * time.Second, KeepAlive: 30 * time.Second}
222 transport := &http.Transport{
223 DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
224 host, port, err := net.SplitHostPort(addr)
225 if err != nil {
226 return nil, err
227 }
228 ip, err := Pin(ctx, host, nil)
229 if err != nil {
230 return nil, err
231 }
232 return dialer.DialContext(ctx, network, net.JoinHostPort(ip.String(), port))
233 },
234 TLSHandshakeTimeout: 5 * time.Second,
235 ForceAttemptHTTP2: true,
236 }
237 if timeout <= 0 {
238 timeout = 10 * time.Second
239 }
240 return &http.Client{Timeout: timeout, Transport: transport, CheckRedirect: checkRedirect}
241}