BlueGit

timfa bluegit

auth: Microsoft Entra OIDC-login met JWKS, nonce en stabiele auth_id

Extend/logout degraderen lokaal; eerste gebruiker blijft installatiebeheerder.

Co-authored-by: Cursor <cursoragent@cursor.com>

timfa Tim Falken · pushed by timfa

Authored 2026-11-12 · 5 days ago

Hash
bbaba0d392e895ecaf8d53df1f184a56bd74e5df
Parent
788b8cb0
8 files changed +786 −17
cmd/bluegit/main.go +5 −2
@@ -92,10 +92,13 @@ func serve(args []string) error {
92 92 dataPath := resolveStorage(cfg, log)
93 93 var provider auth.Provider
94 94 dev := cfg.Auth.Mode == "dev"
95 if dev {
95 switch cfg.Auth.Mode {
96 case "dev":
96 97 provider = auth.Dev{Username: cfg.Auth.DevUser, AuthID: cfg.Auth.DevAuthID}
97 98 log.Warn("auth.mode dev staat aan; doe dit niet op git.timfalken.com")
98 } else {
99 case "entra":
100 provider = auth.NewEntra(cfg.EntraIssuer(), cfg.Auth.TenantID, cfg.Auth.ClientID, cfg.Auth.ClientSecret, cfg.Auth.UserAgent)
101 default:
99 102 provider = auth.NewTimFalken(cfg.Auth.BaseURL, cfg.Auth.ClientID, cfg.Auth.ClientSecret, cfg.Auth.UserAgent)
100 103 }
101 104 ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
@@ -92,10 +92,13 @@ func serve(args []string) error {
92 dataPath := resolveStorage(cfg, log)
92 dataPath := resolveStorage(cfg, log)
93 var provider auth.Provider
93 var provider auth.Provider
94 dev := cfg.Auth.Mode == "dev"
94 dev := cfg.Auth.Mode == "dev"
95 if dev {
95 switch cfg.Auth.Mode {
96 case "dev":
96 provider = auth.Dev{Username: cfg.Auth.DevUser, AuthID: cfg.Auth.DevAuthID}
97 provider = auth.Dev{Username: cfg.Auth.DevUser, AuthID: cfg.Auth.DevAuthID}
97 log.Warn("auth.mode dev staat aan; doe dit niet op git.timfalken.com")
98 log.Warn("auth.mode dev staat aan; doe dit niet op git.timfalken.com")
98 } else {
99 case "entra":
100 provider = auth.NewEntra(cfg.EntraIssuer(), cfg.Auth.TenantID, cfg.Auth.ClientID, cfg.Auth.ClientSecret, cfg.Auth.UserAgent)
101 default:
99 provider = auth.NewTimFalken(cfg.Auth.BaseURL, cfg.Auth.ClientID, cfg.Auth.ClientSecret, cfg.Auth.UserAgent)
102 provider = auth.NewTimFalken(cfg.Auth.BaseURL, cfg.Auth.ClientID, cfg.Auth.ClientSecret, cfg.Auth.UserAgent)
100 }
103 }
101 ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
104 ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
internal/auth/auth.go +11 −8
@@ -1,7 +1,7 @@
1 // Package auth praat met auth.timfalken.com.
2 // De site gebruikt de authorization-code-flow: het domein is de client_id,
3 // de code wordt server-side gewisseld, en /api/me levert id en gebruikersnaam.
4 // E-mail komt nooit mee. Er is geen lokaal wachtwoord.
1 // Package auth praat met de gekozen identity provider.
2 // Standaard is dat auth.timfalken.com (authorization-code-flow); optioneel
3 // Microsoft Entra ID (OIDC). E-mail komt nooit in het BlueGit-usermodel.
4 // Er is geen lokaal wachtwoord.
5 5 package auth
6 6
7 7 import (
@@ -27,9 +27,10 @@ type Identity struct {
27 27 }
28 28
29 29 // Provider is de auth-server, of een testvervanger.
30 // nonce is verplicht voor OIDC (Entra); TimFalken en Dev negeren hem.
30 31 type Provider interface {
31 AuthorizeURL(state, redirectURI string) string
32 Exchange(ctx context.Context, code, redirectURI string) (Identity, error)
32 AuthorizeURL(state, nonce, redirectURI string) string
33 Exchange(ctx context.Context, code, redirectURI, nonce string) (Identity, error)
33 34 Extend(ctx context.Context, accessToken string) (expiresIn int, err error)
34 35 Logout(ctx context.Context, accessToken string) error
35 36 }
@@ -55,17 +56,19 @@ func NewTimFalken(baseURL, clientID, secret, userAgent string) *TimFalken {
55 56 }
56 57
57 58 // AuthorizeURL stuurt de browser naar de toestemmingspagina.
58 func (t *TimFalken) AuthorizeURL(state, redirectURI string) string {
59 func (t *TimFalken) AuthorizeURL(state, nonce, redirectURI string) string {
59 60 q := url.Values{}
60 61 q.Set("client_id", t.ClientID)
61 62 q.Set("redirect_uri", redirectURI)
62 63 q.Set("response_type", "code")
63 64 q.Set("state", state)
65 _ = nonce
64 66 return t.BaseURL + "/oauth/authorize?" + q.Encode()
65 67 }
66 68
67 69 // Exchange wisselt de eenmalige code om voor een bearer-token.
68 func (t *TimFalken) Exchange(ctx context.Context, code, redirectURI string) (Identity, error) {
70 func (t *TimFalken) Exchange(ctx context.Context, code, redirectURI, nonce string) (Identity, error) {
71 _ = nonce
69 72 form := url.Values{}
70 73 form.Set("grant_type", "authorization_code")
71 74 form.Set("code", code)
@@ -1,7 +1,7 @@
1// Package auth praat met auth.timfalken.com.
1// Package auth praat met de gekozen identity provider.
2// De site gebruikt de authorization-code-flow: het domein is de client_id,
2// Standaard is dat auth.timfalken.com (authorization-code-flow); optioneel
3// de code wordt server-side gewisseld, en /api/me levert id en gebruikersnaam.
3// Microsoft Entra ID (OIDC). E-mail komt nooit in het BlueGit-usermodel.
4// E-mail komt nooit mee. Er is geen lokaal wachtwoord.
4// Er is geen lokaal wachtwoord.
5package auth
5package auth
6
6
7import (
7import (
@@ -27,9 +27,10 @@ type Identity struct {
27}
27}
28
28
29// Provider is de auth-server, of een testvervanger.
29// Provider is de auth-server, of een testvervanger.
30// nonce is verplicht voor OIDC (Entra); TimFalken en Dev negeren hem.
30type Provider interface {
31type Provider interface {
31 AuthorizeURL(state, redirectURI string) string
32 AuthorizeURL(state, nonce, redirectURI string) string
32 Exchange(ctx context.Context, code, redirectURI string) (Identity, error)
33 Exchange(ctx context.Context, code, redirectURI, nonce string) (Identity, error)
33 Extend(ctx context.Context, accessToken string) (expiresIn int, err error)
34 Extend(ctx context.Context, accessToken string) (expiresIn int, err error)
34 Logout(ctx context.Context, accessToken string) error
35 Logout(ctx context.Context, accessToken string) error
35}
36}
@@ -55,17 +56,19 @@ func NewTimFalken(baseURL, clientID, secret, userAgent string) *TimFalken {
55}
56}
56
57
57// AuthorizeURL stuurt de browser naar de toestemmingspagina.
58// AuthorizeURL stuurt de browser naar de toestemmingspagina.
58func (t *TimFalken) AuthorizeURL(state, redirectURI string) string {
59func (t *TimFalken) AuthorizeURL(state, nonce, redirectURI string) string {
59 q := url.Values{}
60 q := url.Values{}
60 q.Set("client_id", t.ClientID)
61 q.Set("client_id", t.ClientID)
61 q.Set("redirect_uri", redirectURI)
62 q.Set("redirect_uri", redirectURI)
62 q.Set("response_type", "code")
63 q.Set("response_type", "code")
63 q.Set("state", state)
64 q.Set("state", state)
65 _ = nonce
64 return t.BaseURL + "/oauth/authorize?" + q.Encode()
66 return t.BaseURL + "/oauth/authorize?" + q.Encode()
65}
67}
66
68
67// Exchange wisselt de eenmalige code om voor een bearer-token.
69// Exchange wisselt de eenmalige code om voor een bearer-token.
68func (t *TimFalken) Exchange(ctx context.Context, code, redirectURI string) (Identity, error) {
70func (t *TimFalken) Exchange(ctx context.Context, code, redirectURI, nonce string) (Identity, error) {
71 _ = nonce
69 form := url.Values{}
72 form := url.Values{}
70 form.Set("grant_type", "authorization_code")
73 form.Set("grant_type", "authorization_code")
71 form.Set("code", code)
74 form.Set("code", code)
internal/auth/auth_test.go +2 −2
@@ -31,7 +31,7 @@ func TestExchangeUsesAuthorizationCode(t *testing.T) {
31 31 }))
32 32 defer srv.Close()
33 33 client := NewTimFalken(srv.URL, "git.timfalken.com", "geheim", "BlueGitAccountClient/0.1")
34 id, err := client.Exchange(context.Background(), "code-1", "https://git.timfalken.com/auth/callback")
34 id, err := client.Exchange(context.Background(), "code-1", "https://git.timfalken.com/auth/callback", "")
35 35 if err != nil {
36 36 t.Fatal(err)
37 37 }
@@ -44,7 +44,7 @@ func TestExchangeUsesAuthorizationCode(t *testing.T) {
44 44 if gotAgent != "BlueGitAccountClient/0.1" || gotAccept != "application/json" {
45 45 t.Fatalf("headers %s %s", gotAgent, gotAccept)
46 46 }
47 url := client.AuthorizeURL("state-1", "https://git.timfalken.com/auth/callback")
47 url := client.AuthorizeURL("state-1", "nonce-1", "https://git.timfalken.com/auth/callback")
48 48 if !strings.Contains(url, "/oauth/authorize?") || !strings.Contains(url, "state=state-1") {
49 49 t.Fatal(url)
50 50 }
@@ -31,7 +31,7 @@ func TestExchangeUsesAuthorizationCode(t *testing.T) {
31 }))
31 }))
32 defer srv.Close()
32 defer srv.Close()
33 client := NewTimFalken(srv.URL, "git.timfalken.com", "geheim", "BlueGitAccountClient/0.1")
33 client := NewTimFalken(srv.URL, "git.timfalken.com", "geheim", "BlueGitAccountClient/0.1")
34 id, err := client.Exchange(context.Background(), "code-1", "https://git.timfalken.com/auth/callback")
34 id, err := client.Exchange(context.Background(), "code-1", "https://git.timfalken.com/auth/callback", "")
35 if err != nil {
35 if err != nil {
36 t.Fatal(err)
36 t.Fatal(err)
37 }
37 }
@@ -44,7 +44,7 @@ func TestExchangeUsesAuthorizationCode(t *testing.T) {
44 if gotAgent != "BlueGitAccountClient/0.1" || gotAccept != "application/json" {
44 if gotAgent != "BlueGitAccountClient/0.1" || gotAccept != "application/json" {
45 t.Fatalf("headers %s %s", gotAgent, gotAccept)
45 t.Fatalf("headers %s %s", gotAgent, gotAccept)
46 }
46 }
47 url := client.AuthorizeURL("state-1", "https://git.timfalken.com/auth/callback")
47 url := client.AuthorizeURL("state-1", "nonce-1", "https://git.timfalken.com/auth/callback")
48 if !strings.Contains(url, "/oauth/authorize?") || !strings.Contains(url, "state=state-1") {
48 if !strings.Contains(url, "/oauth/authorize?") || !strings.Contains(url, "state=state-1") {
49 t.Fatal(url)
49 t.Fatal(url)
50 }
50 }
internal/auth/dev.go +2 −2
@@ -13,10 +13,10 @@ type Dev struct {
13 13 }
14 14
15 15 // AuthorizeURL komt in de dev-modus niet voor: /login maakt meteen een sessie.
16 func (d Dev) AuthorizeURL(state, redirectURI string) string { return "/login" }
16 func (d Dev) AuthorizeURL(state, nonce, redirectURI string) string { return "/login" }
17 17
18 18 // Exchange bestaat zodat de interface klopt. Dev-login gebruikt hem niet.
19 func (d Dev) Exchange(ctx context.Context, code, redirectURI string) (Identity, error) {
19 func (d Dev) Exchange(ctx context.Context, code, redirectURI, nonce string) (Identity, error) {
20 20 if code != "dev" {
21 21 return Identity{}, fmt.Errorf("dev-auth accepteert alleen de lokale code")
22 22 }
@@ -13,10 +13,10 @@ type Dev struct {
13}
13}
14
14
15// AuthorizeURL komt in de dev-modus niet voor: /login maakt meteen een sessie.
15// AuthorizeURL komt in de dev-modus niet voor: /login maakt meteen een sessie.
16func (d Dev) AuthorizeURL(state, redirectURI string) string { return "/login" }
16func (d Dev) AuthorizeURL(state, nonce, redirectURI string) string { return "/login" }
17
17
18// Exchange bestaat zodat de interface klopt. Dev-login gebruikt hem niet.
18// Exchange bestaat zodat de interface klopt. Dev-login gebruikt hem niet.
19func (d Dev) Exchange(ctx context.Context, code, redirectURI string) (Identity, error) {
19func (d Dev) Exchange(ctx context.Context, code, redirectURI, nonce string) (Identity, error) {
20 if code != "dev" {
20 if code != "dev" {
21 return Identity{}, fmt.Errorf("dev-auth accepteert alleen de lokale code")
21 return Identity{}, fmt.Errorf("dev-auth accepteert alleen de lokale code")
22 }
22 }
internal/auth/entra.go added +358 −0
@@ -0,0 +1,358 @@
1 package auth
2
3 import (
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 // Entra is Microsoft Entra ID (OIDC, één tenant).
19 // Extend en Logout doen niets op afstand: Entra kent die TimFalken-API's niet.
20 type Entra struct {
21 Issuer string
22 TenantID string
23 ClientID string
24 Secret string
25 UserAgent string
26 HTTP *http.Client
27
28 mu sync.Mutex
29 authz string
30 token string
31 jwks *jwksCache
32 jwksURI string
33 }
34
35 // NewEntra maakt een OIDC-client. issuer is zonder slash aan het eind
36 // (standaard https://login.microsoftonline.com/{tenant}/v2.0).
37 func NewEntra(issuer, tenantID, clientID, secret, userAgent string) *Entra {
38 return &Entra{
39 Issuer: strings.TrimRight(issuer, "/"),
40 TenantID: tenantID,
41 ClientID: clientID,
42 Secret: secret,
43 UserAgent: userAgent,
44 HTTP: &http.Client{Timeout: 15 * time.Second},
45 jwks: &jwksCache{},
46 }
47 }
48
49 // AuthorizeURL stuurt de browser naar Entra met openid-profile en nonce.
50 func (e *Entra) AuthorizeURL(state, nonce, redirectURI string) string {
51 authz, err := e.authorizeEndpoint(context.Background())
52 if err != nil {
53 // Zonder discovery: vaste Entra-URL zodat /login niet paniceert.
54 authz = strings.TrimSuffix(e.Issuer, "/v2.0") + "/oauth2/v2.0/authorize"
55 }
56 q := url.Values{}
57 q.Set("client_id", e.ClientID)
58 q.Set("redirect_uri", redirectURI)
59 q.Set("response_type", "code")
60 q.Set("response_mode", "query")
61 q.Set("scope", "openid profile")
62 q.Set("state", state)
63 q.Set("nonce", nonce)
64 return authz + "?" + q.Encode()
65 }
66
67 // Exchange wisselt de code om, valideert het ID-token (JWKS, iss, aud, exp, nonce)
68 // en mapt oid/tid naar een BlueGit-identity.
69 func (e *Entra) Exchange(ctx context.Context, code, redirectURI, nonce string) (Identity, error) {
70 if nonce == "" {
71 return Identity{}, fmt.Errorf("auth: nonce ontbreekt")
72 }
73 tokenURL, err := e.tokenEndpoint(ctx)
74 if err != nil {
75 return Identity{}, err
76 }
77 form := url.Values{}
78 form.Set("grant_type", "authorization_code")
79 form.Set("code", code)
80 form.Set("redirect_uri", redirectURI)
81 form.Set("client_id", e.ClientID)
82 form.Set("client_secret", e.Secret)
83 form.Set("scope", "openid profile")
84 req, err := http.NewRequestWithContext(ctx, http.MethodPost, tokenURL, strings.NewReader(form.Encode()))
85 if err != nil {
86 return Identity{}, err
87 }
88 req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
89 req.Header.Set("Accept", "application/json")
90 if e.UserAgent != "" {
91 req.Header.Set("User-Agent", e.UserAgent)
92 }
93 var body struct {
94 AccessToken string `json:"access_token"`
95 IDToken string `json:"id_token"`
96 ExpiresIn int `json:"expires_in"`
97 Error string `json:"error"`
98 ErrorDesc string `json:"error_description"`
99 }
100 if err := e.doJSON(req, &body); err != nil {
101 return Identity{}, err
102 }
103 if body.Error != "" || body.IDToken == "" {
104 msg := body.Error
105 if body.ErrorDesc != "" {
106 msg = body.ErrorDesc
107 }
108 if msg == "" {
109 msg = "lege tokenrespons"
110 }
111 return Identity{}, fmt.Errorf("auth: %s", msg)
112 }
113 claims, err := e.verifyIDToken(ctx, body.IDToken, nonce)
114 if err != nil {
115 return Identity{}, err
116 }
117 oid := claims.OID
118 if oid == "" {
119 oid = claims.Sub
120 }
121 if oid == "" {
122 return Identity{}, fmt.Errorf("auth: id_token zonder oid/sub")
123 }
124 if claims.TID != "" && !strings.EqualFold(claims.TID, e.TenantID) {
125 return Identity{}, fmt.Errorf("auth: onverwachte tenant")
126 }
127 username, err := entraUsername(claims.PreferredUsername, claims.Email, claims.Name, oid)
128 if err != nil {
129 return Identity{}, err
130 }
131 return Identity{
132 AuthID: StableAuthID(e.TenantID, oid),
133 Username: username,
134 AvatarURL: "", // Entra levert geen avatar-URL zonder Graph-foto-API.
135 IsAdmin: false,
136 AccessToken: body.AccessToken,
137 ExpiresIn: 86400, // BlueGit-sessie; Entra's access_token is korter.
138 }, nil
139 }
140
141 // Extend verlengt alleen lokaal: Entra heeft geen /api/session/extend.
142 func (e *Entra) Extend(ctx context.Context, accessToken string) (int, error) {
143 return 86400, nil
144 }
145
146 // Logout doet niets op afstand; BlueGit wist de lokale sessie zelf.
147 func (e *Entra) Logout(ctx context.Context, accessToken string) error {
148 return nil
149 }
150
151 type idClaims struct {
152 Iss string `json:"iss"`
153 Aud jsonAudience `json:"aud"`
154 Exp int64 `json:"exp"`
155 Nbf int64 `json:"nbf"`
156 Nonce string `json:"nonce"`
157 OID string `json:"oid"`
158 Sub string `json:"sub"`
159 TID string `json:"tid"`
160 PreferredUsername string `json:"preferred_username"`
161 Email string `json:"email"`
162 Name string `json:"name"`
163 }
164
165 func (e *Entra) verifyIDToken(ctx context.Context, raw, nonce string) (idClaims, error) {
166 hdr, payload, err := parseJWT(raw)
167 if err != nil {
168 return idClaims{}, err
169 }
170 var claims idClaims
171 if err := json.Unmarshal(payload, &claims); err != nil {
172 return idClaims{}, fmt.Errorf("auth: id_token claims: %w", err)
173 }
174 if claims.Iss != e.Issuer {
175 return idClaims{}, fmt.Errorf("auth: ongeldige issuer")
176 }
177 if !claims.Aud.includes(e.ClientID) {
178 return idClaims{}, fmt.Errorf("auth: ongeldige audience")
179 }
180 now := time.Now().Unix()
181 if claims.Exp > 0 && now >= claims.Exp {
182 return idClaims{}, fmt.Errorf("auth: id_token verlopen")
183 }
184 if claims.Nbf > 0 && now < claims.Nbf-60 {
185 return idClaims{}, fmt.Errorf("auth: id_token nog niet geldig")
186 }
187 if claims.Nonce == "" || claims.Nonce != nonce {
188 return idClaims{}, fmt.Errorf("auth: ongeldige nonce")
189 }
190 if hdr.Alg != "RS256" {
191 return idClaims{}, fmt.Errorf("auth: onverwacht jwt-algorithme %q", hdr.Alg)
192 }
193 key, err := e.signingKey(ctx, hdr.Kid)
194 if err != nil {
195 return idClaims{}, err
196 }
197 if err := verifyRS256(raw, key); err != nil {
198 return idClaims{}, err
199 }
200 return claims, nil
201 }
202
203 func (e *Entra) signingKey(ctx context.Context, kid string) (any, error) {
204 if err := e.ensureDiscovery(ctx); err != nil {
205 return nil, err
206 }
207 return e.jwks.key(ctx, e.HTTP, e.jwksURI, kid)
208 }
209
210 func (e *Entra) authorizeEndpoint(ctx context.Context) (string, error) {
211 if err := e.ensureDiscovery(ctx); err != nil {
212 return "", err
213 }
214 e.mu.Lock()
215 defer e.mu.Unlock()
216 return e.authz, nil
217 }
218
219 func (e *Entra) tokenEndpoint(ctx context.Context) (string, error) {
220 if err := e.ensureDiscovery(ctx); err != nil {
221 return "", err
222 }
223 e.mu.Lock()
224 defer e.mu.Unlock()
225 return e.token, nil
226 }
227
228 func (e *Entra) ensureDiscovery(ctx context.Context) error {
229 e.mu.Lock()
230 if e.authz != "" && e.token != "" && e.jwksURI != "" {
231 e.mu.Unlock()
232 return nil
233 }
234 e.mu.Unlock()
235
236 req, err := http.NewRequestWithContext(ctx, http.MethodGet, e.Issuer+"/.well-known/openid-configuration", nil)
237 if err != nil {
238 return err
239 }
240 if e.UserAgent != "" {
241 req.Header.Set("User-Agent", e.UserAgent)
242 }
243 var doc struct {
244 AuthorizationEndpoint string `json:"authorization_endpoint"`
245 TokenEndpoint string `json:"token_endpoint"`
246 JWKSURI string `json:"jwks_uri"`
247 Issuer string `json:"issuer"`
248 }
249 if err := e.doJSON(req, &doc); err != nil {
250 return fmt.Errorf("auth: oidc discovery: %w", err)
251 }
252 if doc.AuthorizationEndpoint == "" || doc.TokenEndpoint == "" || doc.JWKSURI == "" {
253 return fmt.Errorf("auth: onvolledige oidc discovery")
254 }
255 if doc.Issuer != "" && doc.Issuer != e.Issuer {
256 return fmt.Errorf("auth: discovery-issuer wijkt af")
257 }
258 e.mu.Lock()
259 e.authz = doc.AuthorizationEndpoint
260 e.token = doc.TokenEndpoint
261 e.jwksURI = doc.JWKSURI
262 e.mu.Unlock()
263 return nil
264 }
265
266 func (e *Entra) doJSON(req *http.Request, dest any) error {
267 res, err := e.HTTP.Do(req)
268 if err != nil {
269 return fmt.Errorf("auth: %w", err)
270 }
271 defer res.Body.Close()
272 raw, err := io.ReadAll(io.LimitReader(res.Body, 1<<20))
273 if err != nil {
274 return err
275 }
276 if res.StatusCode >= 400 {
277 var env struct {
278 Error string `json:"error"`
279 ErrorDesc string `json:"error_description"`
280 }
281 _ = json.Unmarshal(raw, &env)
282 msg := env.ErrorDesc
283 if msg == "" {
284 msg = env.Error
285 }
286 if msg == "" {
287 msg = res.Status
288 }
289 return fmt.Errorf("auth: %s", msg)
290 }
291 if dest == nil {
292 return nil
293 }
294 if err := json.Unmarshal(raw, dest); err != nil {
295 return fmt.Errorf("auth-antwoord: %w", err)
296 }
297 return nil
298 }
299
300 // StableAuthID maakt een positieve int64 uit tenant + object-id.
301 // Collisie is theoretisch mogelijk; bij een botsing krijgt de tweede gebruiker
302 // dezelfde auth_id (upsert op bestaande rij).
303 func StableAuthID(tenantID, objectID string) int64 {
304 sum := sha256.Sum256([]byte(tenantID + "\x00" + objectID))
305 var n uint64
306 for i := 0; i < 8; i++ {
307 n = n<<8 | uint64(sum[i])
308 }
309 n &^= 1 << 63
310 if n == 0 {
311 n = 1
312 }
313 return int64(n)
314 }
315
316 // entraUsername maakt een BlueGit-gebruikersnaam uit Entra-claims.
317 func entraUsername(preferred, email, display, oid string) (string, error) {
318 raw := strings.TrimSpace(preferred)
319 if raw == "" {
320 raw = strings.TrimSpace(email)
321 }
322 if i := strings.IndexByte(raw, '@'); i > 0 {
323 raw = raw[:i]
324 }
325 if raw == "" {
326 raw = strings.TrimSpace(display)
327 }
328 s := sanitizeUsername(raw)
329 if s == "" || names.ValidUsername(s) != nil {
330 sum := sha256.Sum256([]byte(oid))
331 s = fmt.Sprintf("u%x", sum[:4])
332 }
333 if err := names.ValidUsername(s); err != nil {
334 return "", fmt.Errorf("auth: geen bruikbare gebruikersnaam")
335 }
336 return s, nil
337 }
338
339 func sanitizeUsername(raw string) string {
340 s := strings.ToLower(strings.TrimSpace(raw))
341 var b strings.Builder
342 for _, r := range s {
343 switch {
344 case r >= 'a' && r <= 'z', r >= '0' && r <= '9', r == '_', r == '-':
345 b.WriteRune(r)
346 case r == '.' || r == ' ':
347 b.WriteByte('-')
348 }
349 }
350 out := strings.Trim(b.String(), "-_")
351 for strings.Contains(out, "--") {
352 out = strings.ReplaceAll(out, "--", "-")
353 }
354 if len(out) > 63 {
355 out = strings.Trim(out[:63], "-_")
356 }
357 return out
358 }
@@ -0,0 +1,358 @@
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// Entra is Microsoft Entra ID (OIDC, één tenant).
19// Extend en Logout doen niets op afstand: Entra kent die TimFalken-API's niet.
20type Entra struct {
21 Issuer string
22 TenantID string
23 ClientID string
24 Secret string
25 UserAgent string
26 HTTP *http.Client
27
28 mu sync.Mutex
29 authz string
30 token string
31 jwks *jwksCache
32 jwksURI string
33}
34
35// NewEntra maakt een OIDC-client. issuer is zonder slash aan het eind
36// (standaard https://login.microsoftonline.com/{tenant}/v2.0).
37func NewEntra(issuer, tenantID, clientID, secret, userAgent string) *Entra {
38 return &Entra{
39 Issuer: strings.TrimRight(issuer, "/"),
40 TenantID: tenantID,
41 ClientID: clientID,
42 Secret: secret,
43 UserAgent: userAgent,
44 HTTP: &http.Client{Timeout: 15 * time.Second},
45 jwks: &jwksCache{},
46 }
47}
48
49// AuthorizeURL stuurt de browser naar Entra met openid-profile en nonce.
50func (e *Entra) AuthorizeURL(state, nonce, redirectURI string) string {
51 authz, err := e.authorizeEndpoint(context.Background())
52 if err != nil {
53 // Zonder discovery: vaste Entra-URL zodat /login niet paniceert.
54 authz = strings.TrimSuffix(e.Issuer, "/v2.0") + "/oauth2/v2.0/authorize"
55 }
56 q := url.Values{}
57 q.Set("client_id", e.ClientID)
58 q.Set("redirect_uri", redirectURI)
59 q.Set("response_type", "code")
60 q.Set("response_mode", "query")
61 q.Set("scope", "openid profile")
62 q.Set("state", state)
63 q.Set("nonce", nonce)
64 return authz + "?" + q.Encode()
65}
66
67// Exchange wisselt de code om, valideert het ID-token (JWKS, iss, aud, exp, nonce)
68// en mapt oid/tid naar een BlueGit-identity.
69func (e *Entra) Exchange(ctx context.Context, code, redirectURI, nonce string) (Identity, error) {
70 if nonce == "" {
71 return Identity{}, fmt.Errorf("auth: nonce ontbreekt")
72 }
73 tokenURL, err := e.tokenEndpoint(ctx)
74 if err != nil {
75 return Identity{}, err
76 }
77 form := url.Values{}
78 form.Set("grant_type", "authorization_code")
79 form.Set("code", code)
80 form.Set("redirect_uri", redirectURI)
81 form.Set("client_id", e.ClientID)
82 form.Set("client_secret", e.Secret)
83 form.Set("scope", "openid profile")
84 req, err := http.NewRequestWithContext(ctx, http.MethodPost, tokenURL, strings.NewReader(form.Encode()))
85 if err != nil {
86 return Identity{}, err
87 }
88 req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
89 req.Header.Set("Accept", "application/json")
90 if e.UserAgent != "" {
91 req.Header.Set("User-Agent", e.UserAgent)
92 }
93 var body struct {
94 AccessToken string `json:"access_token"`
95 IDToken string `json:"id_token"`
96 ExpiresIn int `json:"expires_in"`
97 Error string `json:"error"`
98 ErrorDesc string `json:"error_description"`
99 }
100 if err := e.doJSON(req, &body); err != nil {
101 return Identity{}, err
102 }
103 if body.Error != "" || body.IDToken == "" {
104 msg := body.Error
105 if body.ErrorDesc != "" {
106 msg = body.ErrorDesc
107 }
108 if msg == "" {
109 msg = "lege tokenrespons"
110 }
111 return Identity{}, fmt.Errorf("auth: %s", msg)
112 }
113 claims, err := e.verifyIDToken(ctx, body.IDToken, nonce)
114 if err != nil {
115 return Identity{}, err
116 }
117 oid := claims.OID
118 if oid == "" {
119 oid = claims.Sub
120 }
121 if oid == "" {
122 return Identity{}, fmt.Errorf("auth: id_token zonder oid/sub")
123 }
124 if claims.TID != "" && !strings.EqualFold(claims.TID, e.TenantID) {
125 return Identity{}, fmt.Errorf("auth: onverwachte tenant")
126 }
127 username, err := entraUsername(claims.PreferredUsername, claims.Email, claims.Name, oid)
128 if err != nil {
129 return Identity{}, err
130 }
131 return Identity{
132 AuthID: StableAuthID(e.TenantID, oid),
133 Username: username,
134 AvatarURL: "", // Entra levert geen avatar-URL zonder Graph-foto-API.
135 IsAdmin: false,
136 AccessToken: body.AccessToken,
137 ExpiresIn: 86400, // BlueGit-sessie; Entra's access_token is korter.
138 }, nil
139}
140
141// Extend verlengt alleen lokaal: Entra heeft geen /api/session/extend.
142func (e *Entra) Extend(ctx context.Context, accessToken string) (int, error) {
143 return 86400, nil
144}
145
146// Logout doet niets op afstand; BlueGit wist de lokale sessie zelf.
147func (e *Entra) Logout(ctx context.Context, accessToken string) error {
148 return nil
149}
150
151type idClaims struct {
152 Iss string `json:"iss"`
153 Aud jsonAudience `json:"aud"`
154 Exp int64 `json:"exp"`
155 Nbf int64 `json:"nbf"`
156 Nonce string `json:"nonce"`
157 OID string `json:"oid"`
158 Sub string `json:"sub"`
159 TID string `json:"tid"`
160 PreferredUsername string `json:"preferred_username"`
161 Email string `json:"email"`
162 Name string `json:"name"`
163}
164
165func (e *Entra) verifyIDToken(ctx context.Context, raw, nonce string) (idClaims, error) {
166 hdr, payload, err := parseJWT(raw)
167 if err != nil {
168 return idClaims{}, err
169 }
170 var claims idClaims
171 if err := json.Unmarshal(payload, &claims); err != nil {
172 return idClaims{}, fmt.Errorf("auth: id_token claims: %w", err)
173 }
174 if claims.Iss != e.Issuer {
175 return idClaims{}, fmt.Errorf("auth: ongeldige issuer")
176 }
177 if !claims.Aud.includes(e.ClientID) {
178 return idClaims{}, fmt.Errorf("auth: ongeldige audience")
179 }
180 now := time.Now().Unix()
181 if claims.Exp > 0 && now >= claims.Exp {
182 return idClaims{}, fmt.Errorf("auth: id_token verlopen")
183 }
184 if claims.Nbf > 0 && now < claims.Nbf-60 {
185 return idClaims{}, fmt.Errorf("auth: id_token nog niet geldig")
186 }
187 if claims.Nonce == "" || claims.Nonce != nonce {
188 return idClaims{}, fmt.Errorf("auth: ongeldige nonce")
189 }
190 if hdr.Alg != "RS256" {
191 return idClaims{}, fmt.Errorf("auth: onverwacht jwt-algorithme %q", hdr.Alg)
192 }
193 key, err := e.signingKey(ctx, hdr.Kid)
194 if err != nil {
195 return idClaims{}, err
196 }
197 if err := verifyRS256(raw, key); err != nil {
198 return idClaims{}, err
199 }
200 return claims, nil
201}
202
203func (e *Entra) signingKey(ctx context.Context, kid string) (any, error) {
204 if err := e.ensureDiscovery(ctx); err != nil {
205 return nil, err
206 }
207 return e.jwks.key(ctx, e.HTTP, e.jwksURI, kid)
208}
209
210func (e *Entra) authorizeEndpoint(ctx context.Context) (string, error) {
211 if err := e.ensureDiscovery(ctx); err != nil {
212 return "", err
213 }
214 e.mu.Lock()
215 defer e.mu.Unlock()
216 return e.authz, nil
217}
218
219func (e *Entra) tokenEndpoint(ctx context.Context) (string, error) {
220 if err := e.ensureDiscovery(ctx); err != nil {
221 return "", err
222 }
223 e.mu.Lock()
224 defer e.mu.Unlock()
225 return e.token, nil
226}
227
228func (e *Entra) ensureDiscovery(ctx context.Context) error {
229 e.mu.Lock()
230 if e.authz != "" && e.token != "" && e.jwksURI != "" {
231 e.mu.Unlock()
232 return nil
233 }
234 e.mu.Unlock()
235
236 req, err := http.NewRequestWithContext(ctx, http.MethodGet, e.Issuer+"/.well-known/openid-configuration", nil)
237 if err != nil {
238 return err
239 }
240 if e.UserAgent != "" {
241 req.Header.Set("User-Agent", e.UserAgent)
242 }
243 var doc struct {
244 AuthorizationEndpoint string `json:"authorization_endpoint"`
245 TokenEndpoint string `json:"token_endpoint"`
246 JWKSURI string `json:"jwks_uri"`
247 Issuer string `json:"issuer"`
248 }
249 if err := e.doJSON(req, &doc); err != nil {
250 return fmt.Errorf("auth: oidc discovery: %w", err)
251 }
252 if doc.AuthorizationEndpoint == "" || doc.TokenEndpoint == "" || doc.JWKSURI == "" {
253 return fmt.Errorf("auth: onvolledige oidc discovery")
254 }
255 if doc.Issuer != "" && doc.Issuer != e.Issuer {
256 return fmt.Errorf("auth: discovery-issuer wijkt af")
257 }
258 e.mu.Lock()
259 e.authz = doc.AuthorizationEndpoint
260 e.token = doc.TokenEndpoint
261 e.jwksURI = doc.JWKSURI
262 e.mu.Unlock()
263 return nil
264}
265
266func (e *Entra) doJSON(req *http.Request, dest any) error {
267 res, err := e.HTTP.Do(req)
268 if err != nil {
269 return fmt.Errorf("auth: %w", err)
270 }
271 defer res.Body.Close()
272 raw, err := io.ReadAll(io.LimitReader(res.Body, 1<<20))
273 if err != nil {
274 return err
275 }
276 if res.StatusCode >= 400 {
277 var env struct {
278 Error string `json:"error"`
279 ErrorDesc string `json:"error_description"`
280 }
281 _ = json.Unmarshal(raw, &env)
282 msg := env.ErrorDesc
283 if msg == "" {
284 msg = env.Error
285 }
286 if msg == "" {
287 msg = res.Status
288 }
289 return fmt.Errorf("auth: %s", msg)
290 }
291 if dest == nil {
292 return nil
293 }
294 if err := json.Unmarshal(raw, dest); err != nil {
295 return fmt.Errorf("auth-antwoord: %w", err)
296 }
297 return nil
298}
299
300// StableAuthID maakt een positieve int64 uit tenant + object-id.
301// Collisie is theoretisch mogelijk; bij een botsing krijgt de tweede gebruiker
302// dezelfde auth_id (upsert op bestaande rij).
303func StableAuthID(tenantID, objectID string) int64 {
304 sum := sha256.Sum256([]byte(tenantID + "\x00" + objectID))
305 var n uint64
306 for i := 0; i < 8; i++ {
307 n = n<<8 | uint64(sum[i])
308 }
309 n &^= 1 << 63
310 if n == 0 {
311 n = 1
312 }
313 return int64(n)
314}
315
316// entraUsername maakt een BlueGit-gebruikersnaam uit Entra-claims.
317func entraUsername(preferred, email, display, oid string) (string, error) {
318 raw := strings.TrimSpace(preferred)
319 if raw == "" {
320 raw = strings.TrimSpace(email)
321 }
322 if i := strings.IndexByte(raw, '@'); i > 0 {
323 raw = raw[:i]
324 }
325 if raw == "" {
326 raw = strings.TrimSpace(display)
327 }
328 s := sanitizeUsername(raw)
329 if s == "" || names.ValidUsername(s) != nil {
330 sum := sha256.Sum256([]byte(oid))
331 s = fmt.Sprintf("u%x", sum[:4])
332 }
333 if err := names.ValidUsername(s); err != nil {
334 return "", fmt.Errorf("auth: geen bruikbare gebruikersnaam")
335 }
336 return s, nil
337}
338
339func sanitizeUsername(raw string) string {
340 s := strings.ToLower(strings.TrimSpace(raw))
341 var b strings.Builder
342 for _, r := range s {
343 switch {
344 case r >= 'a' && r <= 'z', r >= '0' && r <= '9', r == '_', r == '-':
345 b.WriteRune(r)
346 case r == '.' || r == ' ':
347 b.WriteByte('-')
348 }
349 }
350 out := strings.Trim(b.String(), "-_")
351 for strings.Contains(out, "--") {
352 out = strings.ReplaceAll(out, "--", "-")
353 }
354 if len(out) > 63 {
355 out = strings.Trim(out[:63], "-_")
356 }
357 return out
358}
internal/auth/entra_test.go added +195 −0
@@ -0,0 +1,195 @@
1 package auth
2
3 import (
4 "context"
5 "crypto"
6 "crypto/rand"
7 "crypto/rsa"
8 "crypto/sha256"
9 "encoding/base64"
10 "encoding/binary"
11 "encoding/json"
12 "net/http"
13 "net/http/httptest"
14 "strings"
15 "testing"
16 "time"
17 )
18
19 func TestStableAuthID(t *testing.T) {
20 a := StableAuthID("tenant-a", "oid-1")
21 b := StableAuthID("tenant-a", "oid-1")
22 c := StableAuthID("tenant-a", "oid-2")
23 if a <= 0 || a != b || a == c {
24 t.Fatalf("%d %d %d", a, b, c)
25 }
26 }
27
28 func TestEntraUsername(t *testing.T) {
29 u, err := entraUsername("Ada.Lovelace@contoso.example", "", "", "oid")
30 if err != nil || u != "ada-lovelace" {
31 t.Fatalf("%q %v", u, err)
32 }
33 u, err = entraUsername("", "", "!!!", "deadbeef-oid")
34 if err != nil || !strings.HasPrefix(u, "u") {
35 t.Fatalf("%q %v", u, err)
36 }
37 }
38
39 func TestEntraExchangeWithFakeOIDC(t *testing.T) {
40 key, err := rsa.GenerateKey(rand.Reader, 2048)
41 if err != nil {
42 t.Fatal(err)
43 }
44 kid := "test-key-1"
45 tenant := "00000000-0000-0000-0000-000000000099"
46 clientID := "11111111-1111-1111-1111-111111111199"
47 oid := "22222222-2222-2222-2222-222222222299"
48 nonce := "nonce-abc"
49
50 var issuer string
51 mux := http.NewServeMux()
52 srv := httptest.NewServer(mux)
53 defer srv.Close()
54 issuer = srv.URL
55
56 mux.HandleFunc("/.well-known/openid-configuration", func(w http.ResponseWriter, r *http.Request) {
57 _ = json.NewEncoder(w).Encode(map[string]string{
58 "issuer": issuer,
59 "authorization_endpoint": issuer + "/authorize",
60 "token_endpoint": issuer + "/token",
61 "jwks_uri": issuer + "/jwks",
62 })
63 })
64 mux.HandleFunc("/jwks", func(w http.ResponseWriter, r *http.Request) {
65 _ = json.NewEncoder(w).Encode(map[string]any{"keys": []map[string]string{testJWK(key, kid)}})
66 })
67 mux.HandleFunc("/token", func(w http.ResponseWriter, r *http.Request) {
68 if err := r.ParseForm(); err != nil {
69 t.Error(err)
70 }
71 if r.Form.Get("code") != "good-code" || r.Form.Get("client_id") != clientID {
72 http.Error(w, `{"error":"invalid_grant"}`, http.StatusBadRequest)
73 return
74 }
75 idTok, err := signIDToken(key, kid, map[string]any{
76 "iss": issuer,
77 "aud": clientID,
78 "exp": time.Now().Add(time.Hour).Unix(),
79 "nbf": time.Now().Add(-time.Minute).Unix(),
80 "nonce": nonce,
81 "oid": oid,
82 "sub": oid,
83 "tid": tenant,
84 "preferred_username": "ada@contoso.example",
85 "name": "Ada Lovelace",
86 })
87 if err != nil {
88 t.Error(err)
89 http.Error(w, err.Error(), 500)
90 return
91 }
92 _ = json.NewEncoder(w).Encode(map[string]any{
93 "access_token": "entra-access",
94 "id_token": idTok,
95 "expires_in": 3600,
96 "token_type": "Bearer",
97 })
98 })
99
100 client := NewEntra(issuer, tenant, clientID, "client-secret-placeholder", "BlueGitAccountClient/0.1")
101 client.HTTP = srv.Client()
102
103 url := client.AuthorizeURL("state-1", nonce, "https://git.example.test/auth/callback")
104 if !strings.Contains(url, "/authorize?") || !strings.Contains(url, "nonce="+nonce) || !strings.Contains(url, "scope=openid+profile") {
105 t.Fatal(url)
106 }
107
108 id, err := client.Exchange(context.Background(), "good-code", "https://git.example.test/auth/callback", nonce)
109 if err != nil {
110 t.Fatal(err)
111 }
112 if id.AuthID != StableAuthID(tenant, oid) || id.Username != "ada" || id.AccessToken != "entra-access" {
113 t.Fatalf("%+v", id)
114 }
115 if id.IsAdmin || id.AvatarURL != "" || id.ExpiresIn != 86400 {
116 t.Fatalf("degradatie verwacht: %+v", id)
117 }
118 sec, err := client.Extend(context.Background(), id.AccessToken)
119 if err != nil || sec != 86400 {
120 t.Fatalf("extend %d %v", sec, err)
121 }
122 if err := client.Logout(context.Background(), id.AccessToken); err != nil {
123 t.Fatal(err)
124 }
125 if _, err := client.Exchange(context.Background(), "good-code", "https://git.example.test/auth/callback", "andere"); err == nil {
126 t.Fatal("verwacht nonce-fout")
127 }
128 }
129
130 func TestEntraRejectsBadAudience(t *testing.T) {
131 key, err := rsa.GenerateKey(rand.Reader, 2048)
132 if err != nil {
133 t.Fatal(err)
134 }
135 kid := "k1"
136 mux := http.NewServeMux()
137 srv := httptest.NewServer(mux)
138 defer srv.Close()
139 issuer := srv.URL
140 mux.HandleFunc("/.well-known/openid-configuration", func(w http.ResponseWriter, r *http.Request) {
141 _ = json.NewEncoder(w).Encode(map[string]string{
142 "issuer": issuer, "authorization_endpoint": issuer + "/a",
143 "token_endpoint": issuer + "/token", "jwks_uri": issuer + "/jwks",
144 })
145 })
146 mux.HandleFunc("/jwks", func(w http.ResponseWriter, r *http.Request) {
147 _ = json.NewEncoder(w).Encode(map[string]any{"keys": []map[string]string{testJWK(key, kid)}})
148 })
149 mux.HandleFunc("/token", func(w http.ResponseWriter, r *http.Request) {
150 tok, _ := signIDToken(key, kid, map[string]any{
151 "iss": issuer, "aud": "andere-app", "exp": time.Now().Add(time.Hour).Unix(),
152 "nonce": "n", "oid": "o", "sub": "o", "tid": "t",
153 })
154 _ = json.NewEncoder(w).Encode(map[string]any{"access_token": "x", "id_token": tok})
155 })
156 client := NewEntra(issuer, "t", "mijn-app", "geheim", "")
157 client.HTTP = srv.Client()
158 _, err = client.Exchange(context.Background(), "c", "https://cb", "n")
159 if err == nil || !strings.Contains(err.Error(), "audience") {
160 t.Fatalf("verwacht audience-fout, kreeg %v", err)
161 }
162 }
163
164 func testJWK(key *rsa.PrivateKey, kid string) map[string]string {
165 n := base64.RawURLEncoding.EncodeToString(key.N.Bytes())
166 eb := make([]byte, 8)
167 binary.BigEndian.PutUint64(eb, uint64(key.E))
168 for len(eb) > 1 && eb[0] == 0 {
169 eb = eb[1:]
170 }
171 return map[string]string{
172 "kty": "RSA", "kid": kid, "use": "sig", "alg": "RS256",
173 "n": n, "e": base64.RawURLEncoding.EncodeToString(eb),
174 }
175 }
176
177 func signIDToken(key *rsa.PrivateKey, kid string, claims map[string]any) (string, error) {
178 hdr, err := json.Marshal(map[string]string{"alg": "RS256", "typ": "JWT", "kid": kid})
179 if err != nil {
180 return "", err
181 }
182 payload, err := json.Marshal(claims)
183 if err != nil {
184 return "", err
185 }
186 h := base64.RawURLEncoding.EncodeToString(hdr)
187 p := base64.RawURLEncoding.EncodeToString(payload)
188 signing := h + "." + p
189 sum := sha256.Sum256([]byte(signing))
190 sig, err := rsa.SignPKCS1v15(rand.Reader, key, crypto.SHA256, sum[:])
191 if err != nil {
192 return "", err
193 }
194 return signing + "." + base64.RawURLEncoding.EncodeToString(sig), nil
195 }
@@ -0,0 +1,195 @@
1package auth
2
3import (
4 "context"
5 "crypto"
6 "crypto/rand"
7 "crypto/rsa"
8 "crypto/sha256"
9 "encoding/base64"
10 "encoding/binary"
11 "encoding/json"
12 "net/http"
13 "net/http/httptest"
14 "strings"
15 "testing"
16 "time"
17)
18
19func TestStableAuthID(t *testing.T) {
20 a := StableAuthID("tenant-a", "oid-1")
21 b := StableAuthID("tenant-a", "oid-1")
22 c := StableAuthID("tenant-a", "oid-2")
23 if a <= 0 || a != b || a == c {
24 t.Fatalf("%d %d %d", a, b, c)
25 }
26}
27
28func TestEntraUsername(t *testing.T) {
29 u, err := entraUsername("Ada.Lovelace@contoso.example", "", "", "oid")
30 if err != nil || u != "ada-lovelace" {
31 t.Fatalf("%q %v", u, err)
32 }
33 u, err = entraUsername("", "", "!!!", "deadbeef-oid")
34 if err != nil || !strings.HasPrefix(u, "u") {
35 t.Fatalf("%q %v", u, err)
36 }
37}
38
39func TestEntraExchangeWithFakeOIDC(t *testing.T) {
40 key, err := rsa.GenerateKey(rand.Reader, 2048)
41 if err != nil {
42 t.Fatal(err)
43 }
44 kid := "test-key-1"
45 tenant := "00000000-0000-0000-0000-000000000099"
46 clientID := "11111111-1111-1111-1111-111111111199"
47 oid := "22222222-2222-2222-2222-222222222299"
48 nonce := "nonce-abc"
49
50 var issuer string
51 mux := http.NewServeMux()
52 srv := httptest.NewServer(mux)
53 defer srv.Close()
54 issuer = srv.URL
55
56 mux.HandleFunc("/.well-known/openid-configuration", func(w http.ResponseWriter, r *http.Request) {
57 _ = json.NewEncoder(w).Encode(map[string]string{
58 "issuer": issuer,
59 "authorization_endpoint": issuer + "/authorize",
60 "token_endpoint": issuer + "/token",
61 "jwks_uri": issuer + "/jwks",
62 })
63 })
64 mux.HandleFunc("/jwks", func(w http.ResponseWriter, r *http.Request) {
65 _ = json.NewEncoder(w).Encode(map[string]any{"keys": []map[string]string{testJWK(key, kid)}})
66 })
67 mux.HandleFunc("/token", func(w http.ResponseWriter, r *http.Request) {
68 if err := r.ParseForm(); err != nil {
69 t.Error(err)
70 }
71 if r.Form.Get("code") != "good-code" || r.Form.Get("client_id") != clientID {
72 http.Error(w, `{"error":"invalid_grant"}`, http.StatusBadRequest)
73 return
74 }
75 idTok, err := signIDToken(key, kid, map[string]any{
76 "iss": issuer,
77 "aud": clientID,
78 "exp": time.Now().Add(time.Hour).Unix(),
79 "nbf": time.Now().Add(-time.Minute).Unix(),
80 "nonce": nonce,
81 "oid": oid,
82 "sub": oid,
83 "tid": tenant,
84 "preferred_username": "ada@contoso.example",
85 "name": "Ada Lovelace",
86 })
87 if err != nil {
88 t.Error(err)
89 http.Error(w, err.Error(), 500)
90 return
91 }
92 _ = json.NewEncoder(w).Encode(map[string]any{
93 "access_token": "entra-access",
94 "id_token": idTok,
95 "expires_in": 3600,
96 "token_type": "Bearer",
97 })
98 })
99
100 client := NewEntra(issuer, tenant, clientID, "client-secret-placeholder", "BlueGitAccountClient/0.1")
101 client.HTTP = srv.Client()
102
103 url := client.AuthorizeURL("state-1", nonce, "https://git.example.test/auth/callback")
104 if !strings.Contains(url, "/authorize?") || !strings.Contains(url, "nonce="+nonce) || !strings.Contains(url, "scope=openid+profile") {
105 t.Fatal(url)
106 }
107
108 id, err := client.Exchange(context.Background(), "good-code", "https://git.example.test/auth/callback", nonce)
109 if err != nil {
110 t.Fatal(err)
111 }
112 if id.AuthID != StableAuthID(tenant, oid) || id.Username != "ada" || id.AccessToken != "entra-access" {
113 t.Fatalf("%+v", id)
114 }
115 if id.IsAdmin || id.AvatarURL != "" || id.ExpiresIn != 86400 {
116 t.Fatalf("degradatie verwacht: %+v", id)
117 }
118 sec, err := client.Extend(context.Background(), id.AccessToken)
119 if err != nil || sec != 86400 {
120 t.Fatalf("extend %d %v", sec, err)
121 }
122 if err := client.Logout(context.Background(), id.AccessToken); err != nil {
123 t.Fatal(err)
124 }
125 if _, err := client.Exchange(context.Background(), "good-code", "https://git.example.test/auth/callback", "andere"); err == nil {
126 t.Fatal("verwacht nonce-fout")
127 }
128}
129
130func TestEntraRejectsBadAudience(t *testing.T) {
131 key, err := rsa.GenerateKey(rand.Reader, 2048)
132 if err != nil {
133 t.Fatal(err)
134 }
135 kid := "k1"
136 mux := http.NewServeMux()
137 srv := httptest.NewServer(mux)
138 defer srv.Close()
139 issuer := srv.URL
140 mux.HandleFunc("/.well-known/openid-configuration", func(w http.ResponseWriter, r *http.Request) {
141 _ = json.NewEncoder(w).Encode(map[string]string{
142 "issuer": issuer, "authorization_endpoint": issuer + "/a",
143 "token_endpoint": issuer + "/token", "jwks_uri": issuer + "/jwks",
144 })
145 })
146 mux.HandleFunc("/jwks", func(w http.ResponseWriter, r *http.Request) {
147 _ = json.NewEncoder(w).Encode(map[string]any{"keys": []map[string]string{testJWK(key, kid)}})
148 })
149 mux.HandleFunc("/token", func(w http.ResponseWriter, r *http.Request) {
150 tok, _ := signIDToken(key, kid, map[string]any{
151 "iss": issuer, "aud": "andere-app", "exp": time.Now().Add(time.Hour).Unix(),
152 "nonce": "n", "oid": "o", "sub": "o", "tid": "t",
153 })
154 _ = json.NewEncoder(w).Encode(map[string]any{"access_token": "x", "id_token": tok})
155 })
156 client := NewEntra(issuer, "t", "mijn-app", "geheim", "")
157 client.HTTP = srv.Client()
158 _, err = client.Exchange(context.Background(), "c", "https://cb", "n")
159 if err == nil || !strings.Contains(err.Error(), "audience") {
160 t.Fatalf("verwacht audience-fout, kreeg %v", err)
161 }
162}
163
164func testJWK(key *rsa.PrivateKey, kid string) map[string]string {
165 n := base64.RawURLEncoding.EncodeToString(key.N.Bytes())
166 eb := make([]byte, 8)
167 binary.BigEndian.PutUint64(eb, uint64(key.E))
168 for len(eb) > 1 && eb[0] == 0 {
169 eb = eb[1:]
170 }
171 return map[string]string{
172 "kty": "RSA", "kid": kid, "use": "sig", "alg": "RS256",
173 "n": n, "e": base64.RawURLEncoding.EncodeToString(eb),
174 }
175}
176
177func signIDToken(key *rsa.PrivateKey, kid string, claims map[string]any) (string, error) {
178 hdr, err := json.Marshal(map[string]string{"alg": "RS256", "typ": "JWT", "kid": kid})
179 if err != nil {
180 return "", err
181 }
182 payload, err := json.Marshal(claims)
183 if err != nil {
184 return "", err
185 }
186 h := base64.RawURLEncoding.EncodeToString(hdr)
187 p := base64.RawURLEncoding.EncodeToString(payload)
188 signing := h + "." + p
189 sum := sha256.Sum256([]byte(signing))
190 sig, err := rsa.SignPKCS1v15(rand.Reader, key, crypto.SHA256, sum[:])
191 if err != nil {
192 return "", err
193 }
194 return signing + "." + base64.RawURLEncoding.EncodeToString(sig), nil
195}
internal/auth/oidc_jwt.go added +195 −0
@@ -0,0 +1,195 @@
1 package auth
2
3 import (
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
20 type 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.
27 type jsonAudience []string
28
29 func (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
43 func (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
52 func 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
72 func 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
92 func b64url(s string) ([]byte, error) {
93 return base64.RawURLEncoding.DecodeString(s)
94 }
95
96 type jwksCache struct {
97 mu sync.Mutex
98 fetched time.Time
99 keys map[string]*rsa.PublicKey
100 uri string
101 }
102
103 func (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
122 func (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
167 type 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
176 func (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 }
@@ -0,0 +1,195 @@
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}
internal/server/auth_handlers.go +18 −3
@@ -16,7 +16,7 @@ func (s *Server) login(w http.ResponseWriter, r *http.Request) {
16 16 return
17 17 }
18 18 if s.Dev {
19 id, err := s.Auth.Exchange(r.Context(), "dev", s.Cfg.RedirectURI())
19 id, err := s.Auth.Exchange(r.Context(), "dev", s.Cfg.RedirectURI(), "")
20 20 if err != nil {
21 21 http.Error(w, err.Error(), http.StatusBadGateway)
22 22 return
@@ -29,12 +29,21 @@ func (s *Server) login(w http.ResponseWriter, r *http.Request) {
29 29 http.Error(w, s.tr(r, "err.session"), http.StatusInternalServerError)
30 30 return
31 31 }
32 nonce, err := randomState()
33 if err != nil {
34 http.Error(w, s.tr(r, "err.session"), http.StatusInternalServerError)
35 return
36 }
32 37 secure := strings.HasPrefix(s.Cfg.BaseURL, "https://")
33 38 http.SetCookie(w, &http.Cookie{
34 39 Name: "bluegit_oauth_state", Value: state, Path: "/", MaxAge: 600,
35 40 HttpOnly: true, Secure: secure, SameSite: http.SameSiteLaxMode,
36 41 })
37 http.Redirect(w, r, s.Auth.AuthorizeURL(state, s.Cfg.RedirectURI()), http.StatusFound)
42 http.SetCookie(w, &http.Cookie{
43 Name: "bluegit_oauth_nonce", Value: nonce, Path: "/", MaxAge: 600,
44 HttpOnly: true, Secure: secure, SameSite: http.SameSiteLaxMode,
45 })
46 http.Redirect(w, r, s.Auth.AuthorizeURL(state, nonce, s.Cfg.RedirectURI()), http.StatusFound)
38 47 }
39 48
40 49 func (s *Server) callback(w http.ResponseWriter, r *http.Request) {
@@ -51,8 +60,14 @@ func (s *Server) callback(w http.ResponseWriter, r *http.Request) {
51 60 http.Error(w, s.tr(r, "err.oauthState"), http.StatusBadRequest)
52 61 return
53 62 }
63 nonceCookie, err := r.Cookie("bluegit_oauth_nonce")
64 nonce := ""
65 if err == nil {
66 nonce = nonceCookie.Value
67 }
54 68 http.SetCookie(w, &http.Cookie{Name: "bluegit_oauth_state", Value: "", Path: "/", MaxAge: -1})
55 id, err := s.Auth.Exchange(r.Context(), r.URL.Query().Get("code"), s.Cfg.RedirectURI())
69 http.SetCookie(w, &http.Cookie{Name: "bluegit_oauth_nonce", Value: "", Path: "/", MaxAge: -1})
70 id, err := s.Auth.Exchange(r.Context(), r.URL.Query().Get("code"), s.Cfg.RedirectURI(), nonce)
56 71 if err != nil {
57 72 s.Log.Error("oauth", "err", err)
58 73 s.redirect(w, r, "/", "", s.tr(r, "err.oauthFail"))
@@ -16,7 +16,7 @@ func (s *Server) login(w http.ResponseWriter, r *http.Request) {
16 return
16 return
17 }
17 }
18 if s.Dev {
18 if s.Dev {
19 id, err := s.Auth.Exchange(r.Context(), "dev", s.Cfg.RedirectURI())
19 id, err := s.Auth.Exchange(r.Context(), "dev", s.Cfg.RedirectURI(), "")
20 if err != nil {
20 if err != nil {
21 http.Error(w, err.Error(), http.StatusBadGateway)
21 http.Error(w, err.Error(), http.StatusBadGateway)
22 return
22 return
@@ -29,12 +29,21 @@ func (s *Server) login(w http.ResponseWriter, r *http.Request) {
29 http.Error(w, s.tr(r, "err.session"), http.StatusInternalServerError)
29 http.Error(w, s.tr(r, "err.session"), http.StatusInternalServerError)
30 return
30 return
31 }
31 }
32 nonce, err := randomState()
33 if err != nil {
34 http.Error(w, s.tr(r, "err.session"), http.StatusInternalServerError)
35 return
36 }
32 secure := strings.HasPrefix(s.Cfg.BaseURL, "https://")
37 secure := strings.HasPrefix(s.Cfg.BaseURL, "https://")
33 http.SetCookie(w, &http.Cookie{
38 http.SetCookie(w, &http.Cookie{
34 Name: "bluegit_oauth_state", Value: state, Path: "/", MaxAge: 600,
39 Name: "bluegit_oauth_state", Value: state, Path: "/", MaxAge: 600,
35 HttpOnly: true, Secure: secure, SameSite: http.SameSiteLaxMode,
40 HttpOnly: true, Secure: secure, SameSite: http.SameSiteLaxMode,
36 })
41 })
37 http.Redirect(w, r, s.Auth.AuthorizeURL(state, s.Cfg.RedirectURI()), http.StatusFound)
42 http.SetCookie(w, &http.Cookie{
43 Name: "bluegit_oauth_nonce", Value: nonce, Path: "/", MaxAge: 600,
44 HttpOnly: true, Secure: secure, SameSite: http.SameSiteLaxMode,
45 })
46 http.Redirect(w, r, s.Auth.AuthorizeURL(state, nonce, s.Cfg.RedirectURI()), http.StatusFound)
38}
47}
39
48
40func (s *Server) callback(w http.ResponseWriter, r *http.Request) {
49func (s *Server) callback(w http.ResponseWriter, r *http.Request) {
@@ -51,8 +60,14 @@ func (s *Server) callback(w http.ResponseWriter, r *http.Request) {
51 http.Error(w, s.tr(r, "err.oauthState"), http.StatusBadRequest)
60 http.Error(w, s.tr(r, "err.oauthState"), http.StatusBadRequest)
52 return
61 return
53 }
62 }
63 nonceCookie, err := r.Cookie("bluegit_oauth_nonce")
64 nonce := ""
65 if err == nil {
66 nonce = nonceCookie.Value
67 }
54 http.SetCookie(w, &http.Cookie{Name: "bluegit_oauth_state", Value: "", Path: "/", MaxAge: -1})
68 http.SetCookie(w, &http.Cookie{Name: "bluegit_oauth_state", Value: "", Path: "/", MaxAge: -1})
55 id, err := s.Auth.Exchange(r.Context(), r.URL.Query().Get("code"), s.Cfg.RedirectURI())
69 http.SetCookie(w, &http.Cookie{Name: "bluegit_oauth_nonce", Value: "", Path: "/", MaxAge: -1})
70 id, err := s.Auth.Exchange(r.Context(), r.URL.Query().Get("code"), s.Cfg.RedirectURI(), nonce)
56 if err != nil {
71 if err != nil {
57 s.Log.Error("oauth", "err", err)
72 s.Log.Error("oauth", "err", err)
58 s.redirect(w, r, "/", "", s.tr(r, "err.oauthFail"))
73 s.redirect(w, r, "/", "", s.tr(r, "err.oauthFail"))