BlueGit

timfa bluegit

Files

bluegit / internal / auth / entra_test.go

entra_test.go

entra_test.go 6.1 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
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}