BlueGit

timfa bluegit

Files

bluegit / internal / auth / entra.go

entra.go

entra.go 11.5 KiB Download Raw
1package auth
2
3import (
4 "context"
5 "crypto/sha256"
6 "encoding/json"
7 "fmt"
8 "io"
9 "net/http"
10 "net/url"
11 "strings"
12 "sync"
13 "time"
14
15 "gitlab.com/Timfa/bluegit/internal/names"
16)
17
18// entraScope is wat de authorization-code-flow bij Entra vraagt.
19const entraScope = "openid profile email User.Read"
20
21// idTokenSkew is de toegestane klokverschuiving bij exp, nbf en iat.
22const idTokenSkew = 60 * time.Second
23
24// Entra is Microsoft Entra ID (OIDC, één tenant).
25// Extend en Logout doen niets op afstand: Entra kent die TimFalken-API's niet.
26type Entra struct {
27 Issuer string
28 TenantID string
29 ClientID string
30 Secret string
31 UserAgent string
32 HTTP *http.Client
33 // GraphPhotoURL overschrijft de foto-URL van Microsoft Graph (tests).
34 GraphPhotoURL string
35
36 mu sync.Mutex
37 authz string
38 token string
39 jwks *jwksCache
40 jwksURI string
41}
42
43// NewEntra maakt een OIDC-client. issuer is zonder slash aan het eind
44// (standaard https://login.microsoftonline.com/{tenant}/v2.0).
45func NewEntra(issuer, tenantID, clientID, secret, userAgent string) *Entra {
46 return &Entra{
47 Issuer: strings.TrimRight(issuer, "/"),
48 TenantID: tenantID,
49 ClientID: clientID,
50 Secret: secret,
51 UserAgent: userAgent,
52 HTTP: &http.Client{Timeout: 15 * time.Second},
53 jwks: &jwksCache{},
54 }
55}
56
57// AuthorizeURL stuurt de browser naar Entra met openid, profile, email en User.Read, nonce en PKCE S256.
58func (e *Entra) AuthorizeURL(state, nonce, redirectURI, codeChallenge string) string {
59 authz, err := e.authorizeEndpoint(context.Background())
60 if err != nil {
61 // Zonder discovery: vaste Entra-URL zodat /login niet paniceert.
62 authz = strings.TrimSuffix(e.Issuer, "/v2.0") + "/oauth2/v2.0/authorize"
63 }
64 q := url.Values{}
65 q.Set("client_id", e.ClientID)
66 q.Set("redirect_uri", redirectURI)
67 q.Set("response_type", "code")
68 q.Set("response_mode", "query")
69 q.Set("scope", entraScope)
70 q.Set("state", state)
71 q.Set("nonce", nonce)
72 if codeChallenge != "" {
73 q.Set("code_challenge", codeChallenge)
74 q.Set("code_challenge_method", "S256")
75 }
76 return authz + "?" + q.Encode()
77}
78
79// Exchange wisselt de code om, valideert het ID-token (JWKS, iss, aud, exp, tid, nonce, PKCE)
80// en mapt oid/tid naar een BlueGit-identity.
81func (e *Entra) Exchange(ctx context.Context, code, redirectURI, nonce, codeVerifier string) (Identity, error) {
82 if nonce == "" {
83 return Identity{}, fmt.Errorf("auth: nonce ontbreekt")
84 }
85 if strings.TrimSpace(codeVerifier) == "" {
86 return Identity{}, fmt.Errorf("auth: PKCE-verifier ontbreekt")
87 }
88 tokenURL, err := e.tokenEndpoint(ctx)
89 if err != nil {
90 return Identity{}, err
91 }
92 form := url.Values{}
93 form.Set("grant_type", "authorization_code")
94 form.Set("code", code)
95 form.Set("redirect_uri", redirectURI)
96 form.Set("client_id", e.ClientID)
97 form.Set("client_secret", e.Secret)
98 form.Set("scope", entraScope)
99 form.Set("code_verifier", codeVerifier)
100 req, err := http.NewRequestWithContext(ctx, http.MethodPost, tokenURL, strings.NewReader(form.Encode()))
101 if err != nil {
102 return Identity{}, err
103 }
104 req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
105 req.Header.Set("Accept", "application/json")
106 if e.UserAgent != "" {
107 req.Header.Set("User-Agent", e.UserAgent)
108 }
109 var body struct {
110 AccessToken string `json:"access_token"`
111 IDToken string `json:"id_token"`
112 ExpiresIn int `json:"expires_in"`
113 Error string `json:"error"`
114 ErrorDesc string `json:"error_description"`
115 }
116 if err := e.doJSON(req, &body); err != nil {
117 return Identity{}, err
118 }
119 if body.Error != "" || body.IDToken == "" {
120 msg := body.Error
121 if body.ErrorDesc != "" {
122 msg = body.ErrorDesc
123 }
124 if msg == "" {
125 msg = "lege tokenrespons"
126 }
127 return Identity{}, fmt.Errorf("auth: %s", msg)
128 }
129 claims, err := e.verifyIDToken(ctx, body.IDToken, nonce)
130 if err != nil {
131 return Identity{}, err
132 }
133 oid := claims.OID
134 if oid == "" {
135 oid = claims.Sub
136 }
137 if oid == "" {
138 return Identity{}, fmt.Errorf("auth: id_token zonder oid/sub")
139 }
140 username, err := entraUsername(claims.PreferredUsername, claims.Email, claims.Name, oid)
141 if err != nil {
142 return Identity{}, err
143 }
144 return Identity{
145 AuthID: StableAuthID(e.TenantID, oid),
146 Username: username,
147 AvatarURL: "", // Entra levert geen avatar-URL zonder Graph-foto-API.
148 IsAdmin: false,
149 AccessToken: body.AccessToken,
150 ExpiresIn: 86400, // BlueGit-sessie; Entra's access_token is korter.
151 }, nil
152}
153
154// Extend verlengt alleen lokaal: Entra heeft geen /api/session/extend.
155func (e *Entra) Extend(ctx context.Context, accessToken string) (int, error) {
156 return 86400, nil
157}
158
159// Logout doet niets op afstand; BlueGit wist de lokale sessie zelf.
160func (e *Entra) Logout(ctx context.Context, accessToken string) error {
161 return nil
162}
163
164type idClaims struct {
165 Iss string `json:"iss"`
166 Aud jsonAudience `json:"aud"`
167 Exp int64 `json:"exp"`
168 Iat int64 `json:"iat"`
169 Nbf int64 `json:"nbf"`
170 Nonce string `json:"nonce"`
171 OID string `json:"oid"`
172 Sub string `json:"sub"`
173 TID string `json:"tid"`
174 PreferredUsername string `json:"preferred_username"`
175 Email string `json:"email"`
176 Name string `json:"name"`
177}
178
179func (e *Entra) verifyIDToken(ctx context.Context, raw, nonce string) (idClaims, error) {
180 hdr, payload, err := parseJWT(raw)
181 if err != nil {
182 return idClaims{}, err
183 }
184 var claims idClaims
185 if hdr.Alg != "RS256" {
186 return idClaims{}, fmt.Errorf("auth: onverwacht jwt-algorithme %q", hdr.Alg)
187 }
188 if err := json.Unmarshal(payload, &claims); err != nil {
189 return idClaims{}, fmt.Errorf("auth: id_token claims: %w", err)
190 }
191 if claims.Iss != e.Issuer {
192 return idClaims{}, fmt.Errorf("auth: ongeldige issuer")
193 }
194 if !claims.Aud.includes(e.ClientID) {
195 return idClaims{}, fmt.Errorf("auth: ongeldige audience")
196 }
197 now := time.Now()
198 if claims.Exp == 0 || now.Add(-idTokenSkew).Unix() >= claims.Exp {
199 return idClaims{}, fmt.Errorf("auth: id_token verlopen of mist exp")
200 }
201 if claims.Nbf > 0 && now.Add(idTokenSkew).Unix() < claims.Nbf {
202 return idClaims{}, fmt.Errorf("auth: id_token nog niet geldig")
203 }
204 if claims.Iat > 0 && now.Add(idTokenSkew).Unix() < claims.Iat {
205 return idClaims{}, fmt.Errorf("auth: id_token iat ligt in de toekomst")
206 }
207 if claims.Nonce == "" || claims.Nonce != nonce {
208 return idClaims{}, fmt.Errorf("auth: ongeldige nonce")
209 }
210 if claims.TID == "" || !strings.EqualFold(claims.TID, e.TenantID) {
211 return idClaims{}, fmt.Errorf("auth: onverwachte tenant")
212 }
213 key, err := e.signingKey(ctx, hdr.Kid)
214 if err != nil {
215 return idClaims{}, err
216 }
217 if err := verifyRS256(raw, key); err != nil {
218 return idClaims{}, err
219 }
220 return claims, nil
221}
222
223func (e *Entra) signingKey(ctx context.Context, kid string) (any, error) {
224 if err := e.ensureDiscovery(ctx); err != nil {
225 return nil, err
226 }
227 return e.jwks.key(ctx, e.HTTP, e.jwksURI, kid)
228}
229
230func (e *Entra) authorizeEndpoint(ctx context.Context) (string, error) {
231 if err := e.ensureDiscovery(ctx); err != nil {
232 return "", err
233 }
234 e.mu.Lock()
235 defer e.mu.Unlock()
236 return e.authz, nil
237}
238
239func (e *Entra) tokenEndpoint(ctx context.Context) (string, error) {
240 if err := e.ensureDiscovery(ctx); err != nil {
241 return "", err
242 }
243 e.mu.Lock()
244 defer e.mu.Unlock()
245 return e.token, nil
246}
247
248func (e *Entra) ensureDiscovery(ctx context.Context) error {
249 e.mu.Lock()
250 if e.authz != "" && e.token != "" && e.jwksURI != "" {
251 e.mu.Unlock()
252 return nil
253 }
254 e.mu.Unlock()
255
256 req, err := http.NewRequestWithContext(ctx, http.MethodGet, e.Issuer+"/.well-known/openid-configuration", nil)
257 if err != nil {
258 return err
259 }
260 if e.UserAgent != "" {
261 req.Header.Set("User-Agent", e.UserAgent)
262 }
263 var doc struct {
264 AuthorizationEndpoint string `json:"authorization_endpoint"`
265 TokenEndpoint string `json:"token_endpoint"`
266 JWKSURI string `json:"jwks_uri"`
267 Issuer string `json:"issuer"`
268 }
269 if err := e.doJSON(req, &doc); err != nil {
270 return fmt.Errorf("auth: oidc discovery: %w", err)
271 }
272 if doc.AuthorizationEndpoint == "" || doc.TokenEndpoint == "" || doc.JWKSURI == "" {
273 return fmt.Errorf("auth: onvolledige oidc discovery")
274 }
275 if doc.Issuer != "" && doc.Issuer != e.Issuer {
276 return fmt.Errorf("auth: discovery-issuer wijkt af")
277 }
278 for _, ep := range []string{doc.AuthorizationEndpoint, doc.TokenEndpoint, doc.JWKSURI} {
279 if err := oidcEndpointHostOK(ep, e.Issuer); err != nil {
280 return err
281 }
282 }
283 e.mu.Lock()
284 e.authz = doc.AuthorizationEndpoint
285 e.token = doc.TokenEndpoint
286 e.jwksURI = doc.JWKSURI
287 e.mu.Unlock()
288 return nil
289}
290
291// oidcEndpointHostOK eist dat authorization, token en jwks op dezelfde host
292// staan als de issuer, en HTTPS gebruiken als de issuer HTTPS is.
293func oidcEndpointHostOK(endpoint, issuer string) error {
294 eu, err := url.Parse(endpoint)
295 if err != nil || eu.Host == "" || (eu.Scheme != "https" && eu.Scheme != "http") {
296 return fmt.Errorf("auth: ongeldig OIDC-eindpunt %q", endpoint)
297 }
298 iu, err := url.Parse(issuer)
299 if err != nil || iu.Host == "" {
300 return fmt.Errorf("auth: ongeldige issuer %q", issuer)
301 }
302 if !strings.EqualFold(eu.Hostname(), iu.Hostname()) {
303 return fmt.Errorf("auth: OIDC-eindpunt host %s past niet bij issuer-host %s", eu.Hostname(), iu.Hostname())
304 }
305 if iu.Scheme == "https" && eu.Scheme != "https" {
306 return fmt.Errorf("auth: OIDC-eindpunt moet HTTPS zijn: %s", endpoint)
307 }
308 return nil
309}
310
311func (e *Entra) doJSON(req *http.Request, dest any) error {
312 res, err := e.HTTP.Do(req)
313 if err != nil {
314 return fmt.Errorf("auth: %w", err)
315 }
316 defer res.Body.Close()
317 raw, err := io.ReadAll(io.LimitReader(res.Body, 1<<20))
318 if err != nil {
319 return err
320 }
321 if res.StatusCode >= 400 {
322 var env struct {
323 Error string `json:"error"`
324 ErrorDesc string `json:"error_description"`
325 }
326 _ = json.Unmarshal(raw, &env)
327 msg := env.ErrorDesc
328 if msg == "" {
329 msg = env.Error
330 }
331 if msg == "" {
332 msg = res.Status
333 }
334 return fmt.Errorf("auth: %s", msg)
335 }
336 if dest == nil {
337 return nil
338 }
339 if err := json.Unmarshal(raw, dest); err != nil {
340 return fmt.Errorf("auth-antwoord: %w", err)
341 }
342 return nil
343}
344
345// StableAuthID maakt een positieve int64 uit tenant + object-id.
346// Collisie is theoretisch mogelijk; bij een botsing krijgt de tweede gebruiker
347// dezelfde auth_id (upsert op bestaande rij).
348func StableAuthID(tenantID, objectID string) int64 {
349 sum := sha256.Sum256([]byte(tenantID + "\x00" + objectID))
350 var n uint64
351 for i := 0; i < 8; i++ {
352 n = n<<8 | uint64(sum[i])
353 }
354 n &^= 1 << 63
355 if n == 0 {
356 n = 1
357 }
358 return int64(n)
359}
360
361// entraUsername maakt een BlueGit-gebruikersnaam uit Entra-claims.
362func entraUsername(preferred, email, display, oid string) (string, error) {
363 raw := strings.TrimSpace(preferred)
364 if raw == "" {
365 raw = strings.TrimSpace(email)
366 }
367 if i := strings.IndexByte(raw, '@'); i > 0 {
368 raw = raw[:i]
369 }
370 if raw == "" {
371 raw = strings.TrimSpace(display)
372 }
373 s := sanitizeUsername(raw)
374 if s == "" || names.ValidUsername(s) != nil {
375 sum := sha256.Sum256([]byte(oid))
376 s = fmt.Sprintf("u%x", sum[:4])
377 }
378 if err := names.ValidUsername(s); err != nil {
379 return "", fmt.Errorf("auth: geen bruikbare gebruikersnaam")
380 }
381 return s, nil
382}
383
384func sanitizeUsername(raw string) string {
385 s := strings.ToLower(strings.TrimSpace(raw))
386 var b strings.Builder
387 for _, r := range s {
388 switch {
389 case r >= 'a' && r <= 'z', r >= '0' && r <= '9', r == '_', r == '-':
390 b.WriteRune(r)
391 case r == '.' || r == ' ':
392 b.WriteByte('-')
393 }
394 }
395 out := strings.Trim(b.String(), "-_")
396 for strings.Contains(out, "--") {
397 out = strings.ReplaceAll(out, "--", "-")
398 }
399 if len(out) > 63 {
400 out = strings.Trim(out[:63], "-_")
401 }
402 return out
403}