BlueGit

timfa bluegit

Files

bluegit / internal / auth / entra_test.go

entra_test.go

entra_test.go 6.5 KiB Download Raw
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 verifier, err := NewPKCEVerifier()
50 if err != nil {
51 t.Fatal(err)
52 }
53
54 var issuer string
55 mux := http.NewServeMux()
56 srv := httptest.NewServer(mux)
57 defer srv.Close()
58 issuer = srv.URL
59
60 mux.HandleFunc("/.well-known/openid-configuration", func(w http.ResponseWriter, r *http.Request) {
61 _ = json.NewEncoder(w).Encode(map[string]string{
62 "issuer": issuer,
63 "authorization_endpoint": issuer + "/authorize",
64 "token_endpoint": issuer + "/token",
65 "jwks_uri": issuer + "/jwks",
66 })
67 })
68 mux.HandleFunc("/jwks", func(w http.ResponseWriter, r *http.Request) {
69 _ = json.NewEncoder(w).Encode(map[string]any{"keys": []map[string]string{testJWK(key, kid)}})
70 })
71 mux.HandleFunc("/token", func(w http.ResponseWriter, r *http.Request) {
72 if err := r.ParseForm(); err != nil {
73 t.Error(err)
74 }
75 if r.Form.Get("code") != "good-code" || r.Form.Get("client_id") != clientID || r.Form.Get("code_verifier") != verifier {
76 http.Error(w, `{"error":"invalid_grant"}`, http.StatusBadRequest)
77 return
78 }
79 idTok, err := signIDToken(key, kid, map[string]any{
80 "iss": issuer,
81 "aud": clientID,
82 "exp": time.Now().Add(time.Hour).Unix(),
83 "nbf": time.Now().Add(-time.Minute).Unix(),
84 "nonce": nonce,
85 "oid": oid,
86 "sub": oid,
87 "tid": tenant,
88 "preferred_username": "ada@contoso.example",
89 "name": "Ada Lovelace",
90 })
91 if err != nil {
92 t.Error(err)
93 http.Error(w, err.Error(), 500)
94 return
95 }
96 _ = json.NewEncoder(w).Encode(map[string]any{
97 "access_token": "entra-access",
98 "id_token": idTok,
99 "expires_in": 3600,
100 "token_type": "Bearer",
101 })
102 })
103
104 client := NewEntra(issuer, tenant, clientID, "client-secret-placeholder", "BlueGitAccountClient/0.1")
105 client.HTTP = srv.Client()
106
107 challenge := PKCEChallenge(verifier)
108 url := client.AuthorizeURL("state-1", nonce, "https://git.example.test/auth/callback", challenge)
109 if !strings.Contains(url, "/authorize?") || !strings.Contains(url, "nonce="+nonce) || !strings.Contains(url, "scope=openid+profile+email+User.Read") {
110 t.Fatal(url)
111 }
112 if !strings.Contains(url, "code_challenge="+challenge) || !strings.Contains(url, "code_challenge_method=S256") {
113 t.Fatal(url)
114 }
115
116 id, err := client.Exchange(context.Background(), "good-code", "https://git.example.test/auth/callback", nonce, verifier)
117 if err != nil {
118 t.Fatal(err)
119 }
120 if id.AuthID != StableAuthID(tenant, oid) || id.Username != "ada" || id.AccessToken != "entra-access" {
121 t.Fatalf("%+v", id)
122 }
123 if id.IsAdmin || id.AvatarURL != "" || id.ExpiresIn != 86400 {
124 t.Fatalf("degradatie verwacht: %+v", id)
125 }
126 sec, err := client.Extend(context.Background(), id.AccessToken)
127 if err != nil || sec != 86400 {
128 t.Fatalf("extend %d %v", sec, err)
129 }
130 if err := client.Logout(context.Background(), id.AccessToken); err != nil {
131 t.Fatal(err)
132 }
133 if _, err := client.Exchange(context.Background(), "good-code", "https://git.example.test/auth/callback", "andere", verifier); err == nil {
134 t.Fatal("verwacht nonce-fout")
135 }
136}
137
138func TestEntraRejectsBadAudience(t *testing.T) {
139 key, err := rsa.GenerateKey(rand.Reader, 2048)
140 if err != nil {
141 t.Fatal(err)
142 }
143 kid := "k1"
144 mux := http.NewServeMux()
145 srv := httptest.NewServer(mux)
146 defer srv.Close()
147 issuer := srv.URL
148 mux.HandleFunc("/.well-known/openid-configuration", func(w http.ResponseWriter, r *http.Request) {
149 _ = json.NewEncoder(w).Encode(map[string]string{
150 "issuer": issuer, "authorization_endpoint": issuer + "/a",
151 "token_endpoint": issuer + "/token", "jwks_uri": issuer + "/jwks",
152 })
153 })
154 mux.HandleFunc("/jwks", func(w http.ResponseWriter, r *http.Request) {
155 _ = json.NewEncoder(w).Encode(map[string]any{"keys": []map[string]string{testJWK(key, kid)}})
156 })
157 mux.HandleFunc("/token", func(w http.ResponseWriter, r *http.Request) {
158 tok, _ := signIDToken(key, kid, map[string]any{
159 "iss": issuer, "aud": "andere-app", "exp": time.Now().Add(time.Hour).Unix(),
160 "nonce": "n", "oid": "o", "sub": "o", "tid": "t",
161 })
162 _ = json.NewEncoder(w).Encode(map[string]any{"access_token": "x", "id_token": tok})
163 })
164 client := NewEntra(issuer, "t", "mijn-app", "geheim", "")
165 client.HTTP = srv.Client()
166 _, err = client.Exchange(context.Background(), "c", "https://cb", "n", "pkce-verifier")
167 if err == nil || !strings.Contains(err.Error(), "audience") {
168 t.Fatalf("verwacht audience-fout, kreeg %v", err)
169 }
170}
171
172func testJWK(key *rsa.PrivateKey, kid string) map[string]string {
173 n := base64.RawURLEncoding.EncodeToString(key.N.Bytes())
174 eb := make([]byte, 8)
175 binary.BigEndian.PutUint64(eb, uint64(key.E))
176 for len(eb) > 1 && eb[0] == 0 {
177 eb = eb[1:]
178 }
179 return map[string]string{
180 "kty": "RSA", "kid": kid, "use": "sig", "alg": "RS256",
181 "n": n, "e": base64.RawURLEncoding.EncodeToString(eb),
182 }
183}
184
185func signIDToken(key *rsa.PrivateKey, kid string, claims map[string]any) (string, error) {
186 hdr, err := json.Marshal(map[string]string{"alg": "RS256", "typ": "JWT", "kid": kid})
187 if err != nil {
188 return "", err
189 }
190 payload, err := json.Marshal(claims)
191 if err != nil {
192 return "", err
193 }
194 h := base64.RawURLEncoding.EncodeToString(hdr)
195 p := base64.RawURLEncoding.EncodeToString(payload)
196 signing := h + "." + p
197 sum := sha256.Sum256([]byte(signing))
198 sig, err := rsa.SignPKCS1v15(rand.Reader, key, crypto.SHA256, sum[:])
199 if err != nil {
200 return "", err
201 }
202 return signing + "." + base64.RawURLEncoding.EncodeToString(sig), nil
203}