BlueGit

timfa bluegit

Files

bluegit / internal / auth / oidc_jwt.go

oidc_jwt.go

oidc_jwt.go 4.2 KiB Download Raw
1package auth
2
3import (
4 "context"
5 "crypto"
6 "crypto/rsa"
7 "crypto/sha256"
8 "encoding/base64"
9 "encoding/binary"
10 "encoding/json"
11 "fmt"
12 "io"
13 "math/big"
14 "net/http"
15 "strings"
16 "sync"
17 "time"
18)
19
20type jwtHeader struct {
21 Alg string `json:"alg"`
22 Kid string `json:"kid"`
23 Typ string `json:"typ"`
24}
25
26// jsonAudience accepteert "aud" als string of als array.
27type jsonAudience []string
28
29func (a *jsonAudience) UnmarshalJSON(b []byte) error {
30 var one string
31 if err := json.Unmarshal(b, &one); err == nil {
32 *a = []string{one}
33 return nil
34 }
35 var many []string
36 if err := json.Unmarshal(b, &many); err != nil {
37 return err
38 }
39 *a = many
40 return nil
41}
42
43func (a jsonAudience) includes(want string) bool {
44 for _, v := range a {
45 if v == want {
46 return true
47 }
48 }
49 return false
50}
51
52func parseJWT(raw string) (jwtHeader, []byte, error) {
53 parts := strings.Split(raw, ".")
54 if len(parts) != 3 {
55 return jwtHeader{}, nil, fmt.Errorf("auth: ongeldig jwt")
56 }
57 hb, err := b64url(parts[0])
58 if err != nil {
59 return jwtHeader{}, nil, fmt.Errorf("auth: jwt-header: %w", err)
60 }
61 var hdr jwtHeader
62 if err := json.Unmarshal(hb, &hdr); err != nil {
63 return jwtHeader{}, nil, fmt.Errorf("auth: jwt-header: %w", err)
64 }
65 pb, err := b64url(parts[1])
66 if err != nil {
67 return jwtHeader{}, nil, fmt.Errorf("auth: jwt-payload: %w", err)
68 }
69 return hdr, pb, nil
70}
71
72func verifyRS256(raw string, key any) error {
73 pub, ok := key.(*rsa.PublicKey)
74 if !ok || pub == nil {
75 return fmt.Errorf("auth: geen rsa-sleutel")
76 }
77 parts := strings.Split(raw, ".")
78 if len(parts) != 3 {
79 return fmt.Errorf("auth: ongeldig jwt")
80 }
81 sig, err := b64url(parts[2])
82 if err != nil {
83 return fmt.Errorf("auth: jwt-handtekening: %w", err)
84 }
85 sum := sha256.Sum256([]byte(parts[0] + "." + parts[1]))
86 if err := rsa.VerifyPKCS1v15(pub, crypto.SHA256, sum[:], sig); err != nil {
87 return fmt.Errorf("auth: jwt-handtekening ongeldig")
88 }
89 return nil
90}
91
92func b64url(s string) ([]byte, error) {
93 return base64.RawURLEncoding.DecodeString(s)
94}
95
96type jwksCache struct {
97 mu sync.Mutex
98 fetched time.Time
99 keys map[string]*rsa.PublicKey
100 uri string
101}
102
103func (c *jwksCache) key(ctx context.Context, httpc *http.Client, uri, kid string) (*rsa.PublicKey, error) {
104 c.mu.Lock()
105 if k := c.keys[kid]; k != nil && c.uri == uri && time.Since(c.fetched) < time.Hour {
106 c.mu.Unlock()
107 return k, nil
108 }
109 c.mu.Unlock()
110 if err := c.refresh(ctx, httpc, uri); err != nil {
111 return nil, err
112 }
113 c.mu.Lock()
114 defer c.mu.Unlock()
115 k := c.keys[kid]
116 if k == nil {
117 return nil, fmt.Errorf("auth: jwks-sleutel %q ontbreekt", kid)
118 }
119 return k, nil
120}
121
122func (c *jwksCache) refresh(ctx context.Context, httpc *http.Client, uri string) error {
123 req, err := http.NewRequestWithContext(ctx, http.MethodGet, uri, nil)
124 if err != nil {
125 return err
126 }
127 res, err := httpc.Do(req)
128 if err != nil {
129 return fmt.Errorf("auth: jwks: %w", err)
130 }
131 defer res.Body.Close()
132 raw, err := io.ReadAll(io.LimitReader(res.Body, 1<<20))
133 if err != nil {
134 return err
135 }
136 if res.StatusCode >= 400 {
137 return fmt.Errorf("auth: jwks %s", res.Status)
138 }
139 var doc struct {
140 Keys []jwk `json:"keys"`
141 }
142 if err := json.Unmarshal(raw, &doc); err != nil {
143 return fmt.Errorf("auth: jwks: %w", err)
144 }
145 keys := make(map[string]*rsa.PublicKey, len(doc.Keys))
146 for _, k := range doc.Keys {
147 if k.Kty != "RSA" || k.Kid == "" || k.N == "" || k.E == "" {
148 continue
149 }
150 pub, err := k.rsaPublic()
151 if err != nil {
152 continue
153 }
154 keys[k.Kid] = pub
155 }
156 if len(keys) == 0 {
157 return fmt.Errorf("auth: jwks zonder bruikbare sleutels")
158 }
159 c.mu.Lock()
160 c.keys = keys
161 c.uri = uri
162 c.fetched = time.Now()
163 c.mu.Unlock()
164 return nil
165}
166
167type jwk struct {
168 Kty string `json:"kty"`
169 Kid string `json:"kid"`
170 N string `json:"n"`
171 E string `json:"e"`
172 Use string `json:"use"`
173 Alg string `json:"alg"`
174}
175
176func (k jwk) rsaPublic() (*rsa.PublicKey, error) {
177 nb, err := b64url(k.N)
178 if err != nil {
179 return nil, err
180 }
181 eb, err := b64url(k.E)
182 if err != nil {
183 return nil, err
184 }
185 var e int
186 if len(eb) < 8 {
187 pad := make([]byte, 8-len(eb))
188 eb = append(pad, eb...)
189 }
190 e = int(binary.BigEndian.Uint64(eb[len(eb)-8:]))
191 if e <= 0 {
192 return nil, fmt.Errorf("ongeldige exponent")
193 }
194 return &rsa.PublicKey{N: new(big.Int).SetBytes(nb), E: e}, nil
195}