package auth import ( "context" "crypto/sha256" "encoding/json" "fmt" "io" "net/http" "net/url" "strings" "sync" "time" "gitlab.com/Timfa/bluegit/internal/names" ) // entraScope is wat de authorization-code-flow bij Entra vraagt. const entraScope = "openid profile email User.Read" // idTokenSkew is de toegestane klokverschuiving bij exp, nbf en iat. const idTokenSkew = 60 * time.Second // Entra is Microsoft Entra ID (OIDC, één tenant). // Extend en Logout doen niets op afstand: Entra kent die TimFalken-API's niet. type Entra struct { Issuer string TenantID string ClientID string Secret string UserAgent string HTTP *http.Client // GraphPhotoURL overschrijft de foto-URL van Microsoft Graph (tests). GraphPhotoURL string mu sync.Mutex authz string token string jwks *jwksCache jwksURI string } // NewEntra maakt een OIDC-client. issuer is zonder slash aan het eind // (standaard https://login.microsoftonline.com/{tenant}/v2.0). func NewEntra(issuer, tenantID, clientID, secret, userAgent string) *Entra { return &Entra{ Issuer: strings.TrimRight(issuer, "/"), TenantID: tenantID, ClientID: clientID, Secret: secret, UserAgent: userAgent, HTTP: &http.Client{Timeout: 15 * time.Second}, jwks: &jwksCache{}, } } // AuthorizeURL stuurt de browser naar Entra met openid, profile, email en User.Read, nonce en PKCE S256. func (e *Entra) AuthorizeURL(state, nonce, redirectURI, codeChallenge string) string { authz, err := e.authorizeEndpoint(context.Background()) if err != nil { // Zonder discovery: vaste Entra-URL zodat /login niet paniceert. authz = strings.TrimSuffix(e.Issuer, "/v2.0") + "/oauth2/v2.0/authorize" } q := url.Values{} q.Set("client_id", e.ClientID) q.Set("redirect_uri", redirectURI) q.Set("response_type", "code") q.Set("response_mode", "query") q.Set("scope", entraScope) q.Set("state", state) q.Set("nonce", nonce) if codeChallenge != "" { q.Set("code_challenge", codeChallenge) q.Set("code_challenge_method", "S256") } return authz + "?" + q.Encode() } // Exchange wisselt de code om, valideert het ID-token (JWKS, iss, aud, exp, tid, nonce, PKCE) // en mapt oid/tid naar een BlueGit-identity. func (e *Entra) Exchange(ctx context.Context, code, redirectURI, nonce, codeVerifier string) (Identity, error) { if nonce == "" { return Identity{}, fmt.Errorf("auth: nonce ontbreekt") } if strings.TrimSpace(codeVerifier) == "" { return Identity{}, fmt.Errorf("auth: PKCE-verifier ontbreekt") } tokenURL, err := e.tokenEndpoint(ctx) if err != nil { return Identity{}, err } form := url.Values{} form.Set("grant_type", "authorization_code") form.Set("code", code) form.Set("redirect_uri", redirectURI) form.Set("client_id", e.ClientID) form.Set("client_secret", e.Secret) form.Set("scope", entraScope) form.Set("code_verifier", codeVerifier) req, err := http.NewRequestWithContext(ctx, http.MethodPost, tokenURL, strings.NewReader(form.Encode())) if err != nil { return Identity{}, err } req.Header.Set("Content-Type", "application/x-www-form-urlencoded") req.Header.Set("Accept", "application/json") if e.UserAgent != "" { req.Header.Set("User-Agent", e.UserAgent) } var body struct { AccessToken string `json:"access_token"` IDToken string `json:"id_token"` ExpiresIn int `json:"expires_in"` Error string `json:"error"` ErrorDesc string `json:"error_description"` } if err := e.doJSON(req, &body); err != nil { return Identity{}, err } if body.Error != "" || body.IDToken == "" { msg := body.Error if body.ErrorDesc != "" { msg = body.ErrorDesc } if msg == "" { msg = "lege tokenrespons" } return Identity{}, fmt.Errorf("auth: %s", msg) } claims, err := e.verifyIDToken(ctx, body.IDToken, nonce) if err != nil { return Identity{}, err } oid := claims.OID if oid == "" { oid = claims.Sub } if oid == "" { return Identity{}, fmt.Errorf("auth: id_token zonder oid/sub") } username, err := entraUsername(claims.PreferredUsername, claims.Email, claims.Name, oid) if err != nil { return Identity{}, err } return Identity{ AuthID: StableAuthID(e.TenantID, oid), Username: username, AvatarURL: "", // Entra levert geen avatar-URL zonder Graph-foto-API. IsAdmin: false, AccessToken: body.AccessToken, ExpiresIn: 86400, // BlueGit-sessie; Entra's access_token is korter. }, nil } // Extend verlengt alleen lokaal: Entra heeft geen /api/session/extend. func (e *Entra) Extend(ctx context.Context, accessToken string) (int, error) { return 86400, nil } // Logout doet niets op afstand; BlueGit wist de lokale sessie zelf. func (e *Entra) Logout(ctx context.Context, accessToken string) error { return nil } type idClaims struct { Iss string `json:"iss"` Aud jsonAudience `json:"aud"` Exp int64 `json:"exp"` Iat int64 `json:"iat"` Nbf int64 `json:"nbf"` Nonce string `json:"nonce"` OID string `json:"oid"` Sub string `json:"sub"` TID string `json:"tid"` PreferredUsername string `json:"preferred_username"` Email string `json:"email"` Name string `json:"name"` } func (e *Entra) verifyIDToken(ctx context.Context, raw, nonce string) (idClaims, error) { hdr, payload, err := parseJWT(raw) if err != nil { return idClaims{}, err } var claims idClaims if hdr.Alg != "RS256" { return idClaims{}, fmt.Errorf("auth: onverwacht jwt-algorithme %q", hdr.Alg) } if err := json.Unmarshal(payload, &claims); err != nil { return idClaims{}, fmt.Errorf("auth: id_token claims: %w", err) } if claims.Iss != e.Issuer { return idClaims{}, fmt.Errorf("auth: ongeldige issuer") } if !claims.Aud.includes(e.ClientID) { return idClaims{}, fmt.Errorf("auth: ongeldige audience") } now := time.Now() if claims.Exp == 0 || now.Add(-idTokenSkew).Unix() >= claims.Exp { return idClaims{}, fmt.Errorf("auth: id_token verlopen of mist exp") } if claims.Nbf > 0 && now.Add(idTokenSkew).Unix() < claims.Nbf { return idClaims{}, fmt.Errorf("auth: id_token nog niet geldig") } if claims.Iat > 0 && now.Add(idTokenSkew).Unix() < claims.Iat { return idClaims{}, fmt.Errorf("auth: id_token iat ligt in de toekomst") } if claims.Nonce == "" || claims.Nonce != nonce { return idClaims{}, fmt.Errorf("auth: ongeldige nonce") } if claims.TID == "" || !strings.EqualFold(claims.TID, e.TenantID) { return idClaims{}, fmt.Errorf("auth: onverwachte tenant") } key, err := e.signingKey(ctx, hdr.Kid) if err != nil { return idClaims{}, err } if err := verifyRS256(raw, key); err != nil { return idClaims{}, err } return claims, nil } func (e *Entra) signingKey(ctx context.Context, kid string) (any, error) { if err := e.ensureDiscovery(ctx); err != nil { return nil, err } return e.jwks.key(ctx, e.HTTP, e.jwksURI, kid) } func (e *Entra) authorizeEndpoint(ctx context.Context) (string, error) { if err := e.ensureDiscovery(ctx); err != nil { return "", err } e.mu.Lock() defer e.mu.Unlock() return e.authz, nil } func (e *Entra) tokenEndpoint(ctx context.Context) (string, error) { if err := e.ensureDiscovery(ctx); err != nil { return "", err } e.mu.Lock() defer e.mu.Unlock() return e.token, nil } func (e *Entra) ensureDiscovery(ctx context.Context) error { e.mu.Lock() if e.authz != "" && e.token != "" && e.jwksURI != "" { e.mu.Unlock() return nil } e.mu.Unlock() req, err := http.NewRequestWithContext(ctx, http.MethodGet, e.Issuer+"/.well-known/openid-configuration", nil) if err != nil { return err } if e.UserAgent != "" { req.Header.Set("User-Agent", e.UserAgent) } var doc struct { AuthorizationEndpoint string `json:"authorization_endpoint"` TokenEndpoint string `json:"token_endpoint"` JWKSURI string `json:"jwks_uri"` Issuer string `json:"issuer"` } if err := e.doJSON(req, &doc); err != nil { return fmt.Errorf("auth: oidc discovery: %w", err) } if doc.AuthorizationEndpoint == "" || doc.TokenEndpoint == "" || doc.JWKSURI == "" { return fmt.Errorf("auth: onvolledige oidc discovery") } if doc.Issuer != "" && doc.Issuer != e.Issuer { return fmt.Errorf("auth: discovery-issuer wijkt af") } for _, ep := range []string{doc.AuthorizationEndpoint, doc.TokenEndpoint, doc.JWKSURI} { if err := oidcEndpointHostOK(ep, e.Issuer); err != nil { return err } } e.mu.Lock() e.authz = doc.AuthorizationEndpoint e.token = doc.TokenEndpoint e.jwksURI = doc.JWKSURI e.mu.Unlock() return nil } // oidcEndpointHostOK eist dat authorization, token en jwks op dezelfde host // staan als de issuer, en HTTPS gebruiken als de issuer HTTPS is. func oidcEndpointHostOK(endpoint, issuer string) error { eu, err := url.Parse(endpoint) if err != nil || eu.Host == "" || (eu.Scheme != "https" && eu.Scheme != "http") { return fmt.Errorf("auth: ongeldig OIDC-eindpunt %q", endpoint) } iu, err := url.Parse(issuer) if err != nil || iu.Host == "" { return fmt.Errorf("auth: ongeldige issuer %q", issuer) } if !strings.EqualFold(eu.Hostname(), iu.Hostname()) { return fmt.Errorf("auth: OIDC-eindpunt host %s past niet bij issuer-host %s", eu.Hostname(), iu.Hostname()) } if iu.Scheme == "https" && eu.Scheme != "https" { return fmt.Errorf("auth: OIDC-eindpunt moet HTTPS zijn: %s", endpoint) } return nil } func (e *Entra) doJSON(req *http.Request, dest any) error { res, err := e.HTTP.Do(req) if err != nil { return fmt.Errorf("auth: %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 { var env struct { Error string `json:"error"` ErrorDesc string `json:"error_description"` } _ = json.Unmarshal(raw, &env) msg := env.ErrorDesc if msg == "" { msg = env.Error } if msg == "" { msg = res.Status } return fmt.Errorf("auth: %s", msg) } if dest == nil { return nil } if err := json.Unmarshal(raw, dest); err != nil { return fmt.Errorf("auth-antwoord: %w", err) } return nil } // StableAuthID maakt een positieve int64 uit tenant + object-id. // Collisie is theoretisch mogelijk; bij een botsing krijgt de tweede gebruiker // dezelfde auth_id (upsert op bestaande rij). func StableAuthID(tenantID, objectID string) int64 { sum := sha256.Sum256([]byte(tenantID + "\x00" + objectID)) var n uint64 for i := 0; i < 8; i++ { n = n<<8 | uint64(sum[i]) } n &^= 1 << 63 if n == 0 { n = 1 } return int64(n) } // entraUsername maakt een BlueGit-gebruikersnaam uit Entra-claims. func entraUsername(preferred, email, display, oid string) (string, error) { raw := strings.TrimSpace(preferred) if raw == "" { raw = strings.TrimSpace(email) } if i := strings.IndexByte(raw, '@'); i > 0 { raw = raw[:i] } if raw == "" { raw = strings.TrimSpace(display) } s := sanitizeUsername(raw) if s == "" || names.ValidUsername(s) != nil { sum := sha256.Sum256([]byte(oid)) s = fmt.Sprintf("u%x", sum[:4]) } if err := names.ValidUsername(s); err != nil { return "", fmt.Errorf("auth: geen bruikbare gebruikersnaam") } return s, nil } func sanitizeUsername(raw string) string { s := strings.ToLower(strings.TrimSpace(raw)) var b strings.Builder for _, r := range s { switch { case r >= 'a' && r <= 'z', r >= '0' && r <= '9', r == '_', r == '-': b.WriteRune(r) case r == '.' || r == ' ': b.WriteByte('-') } } out := strings.Trim(b.String(), "-_") for strings.Contains(out, "--") { out = strings.ReplaceAll(out, "--", "-") } if len(out) > 63 { out = strings.Trim(out[:63], "-_") } return out }