package auth import ( "context" "crypto" "crypto/rsa" "crypto/sha256" "encoding/base64" "encoding/binary" "encoding/json" "fmt" "io" "math/big" "net/http" "strings" "sync" "time" ) type jwtHeader struct { Alg string `json:"alg"` Kid string `json:"kid"` Typ string `json:"typ"` } // jsonAudience accepteert "aud" als string of als array. type jsonAudience []string func (a *jsonAudience) UnmarshalJSON(b []byte) error { var one string if err := json.Unmarshal(b, &one); err == nil { *a = []string{one} return nil } var many []string if err := json.Unmarshal(b, &many); err != nil { return err } *a = many return nil } func (a jsonAudience) includes(want string) bool { for _, v := range a { if v == want { return true } } return false } func parseJWT(raw string) (jwtHeader, []byte, error) { parts := strings.Split(raw, ".") if len(parts) != 3 { return jwtHeader{}, nil, fmt.Errorf("auth: ongeldig jwt") } hb, err := b64url(parts[0]) if err != nil { return jwtHeader{}, nil, fmt.Errorf("auth: jwt-header: %w", err) } var hdr jwtHeader if err := json.Unmarshal(hb, &hdr); err != nil { return jwtHeader{}, nil, fmt.Errorf("auth: jwt-header: %w", err) } pb, err := b64url(parts[1]) if err != nil { return jwtHeader{}, nil, fmt.Errorf("auth: jwt-payload: %w", err) } return hdr, pb, nil } func verifyRS256(raw string, key any) error { pub, ok := key.(*rsa.PublicKey) if !ok || pub == nil { return fmt.Errorf("auth: geen rsa-sleutel") } parts := strings.Split(raw, ".") if len(parts) != 3 { return fmt.Errorf("auth: ongeldig jwt") } sig, err := b64url(parts[2]) if err != nil { return fmt.Errorf("auth: jwt-handtekening: %w", err) } sum := sha256.Sum256([]byte(parts[0] + "." + parts[1])) if err := rsa.VerifyPKCS1v15(pub, crypto.SHA256, sum[:], sig); err != nil { return fmt.Errorf("auth: jwt-handtekening ongeldig") } return nil } func b64url(s string) ([]byte, error) { return base64.RawURLEncoding.DecodeString(s) } type jwksCache struct { mu sync.Mutex fetched time.Time keys map[string]*rsa.PublicKey uri string } func (c *jwksCache) key(ctx context.Context, httpc *http.Client, uri, kid string) (*rsa.PublicKey, error) { c.mu.Lock() if k := c.keys[kid]; k != nil && c.uri == uri && time.Since(c.fetched) < time.Hour { c.mu.Unlock() return k, nil } c.mu.Unlock() if err := c.refresh(ctx, httpc, uri); err != nil { return nil, err } c.mu.Lock() defer c.mu.Unlock() k := c.keys[kid] if k == nil { return nil, fmt.Errorf("auth: jwks-sleutel %q ontbreekt", kid) } return k, nil } func (c *jwksCache) refresh(ctx context.Context, httpc *http.Client, uri string) error { req, err := http.NewRequestWithContext(ctx, http.MethodGet, uri, nil) if err != nil { return err } res, err := httpc.Do(req) if err != nil { return fmt.Errorf("auth: jwks: %w", err) } defer res.Body.Close() raw, err := io.ReadAll(io.LimitReader(res.Body, 1<<20)) if err != nil { return err } if res.StatusCode >= 400 { return fmt.Errorf("auth: jwks %s", res.Status) } var doc struct { Keys []jwk `json:"keys"` } if err := json.Unmarshal(raw, &doc); err != nil { return fmt.Errorf("auth: jwks: %w", err) } keys := make(map[string]*rsa.PublicKey, len(doc.Keys)) for _, k := range doc.Keys { if k.Kty != "RSA" || k.Kid == "" || k.N == "" || k.E == "" { continue } pub, err := k.rsaPublic() if err != nil { continue } keys[k.Kid] = pub } if len(keys) == 0 { return fmt.Errorf("auth: jwks zonder bruikbare sleutels") } c.mu.Lock() c.keys = keys c.uri = uri c.fetched = time.Now() c.mu.Unlock() return nil } type jwk struct { Kty string `json:"kty"` Kid string `json:"kid"` N string `json:"n"` E string `json:"e"` Use string `json:"use"` Alg string `json:"alg"` } func (k jwk) rsaPublic() (*rsa.PublicKey, error) { nb, err := b64url(k.N) if err != nil { return nil, err } eb, err := b64url(k.E) if err != nil { return nil, err } var e int if len(eb) < 8 { pad := make([]byte, 8-len(eb)) eb = append(pad, eb...) } e = int(binary.BigEndian.Uint64(eb[len(eb)-8:])) if e <= 0 { return nil, fmt.Errorf("ongeldige exponent") } return &rsa.PublicKey{N: new(big.Int).SetBytes(nb), E: e}, nil }