BlueGit

timfa bluegit

Files

bluegit / internal / auth / entra.go

entra.go

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