BlueGit

timfa bluegit

Files

bluegit / internal / auth / entra_hardening_test.go

entra_hardening_test.go

entra_hardening_test.go 8.3 KiB Download Raw
1package auth
2
3import (
4 "context"
5 "crypto/hmac"
6 "crypto/rand"
7 "crypto/rsa"
8 "crypto/sha256"
9 "encoding/base64"
10 "encoding/json"
11 "net/http"
12 "net/http/httptest"
13 "strings"
14 "testing"
15 "time"
16)
17
18func TestPKCEChallengeRFC7636(t *testing.T) {
19 got := PKCEChallenge("dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk")
20 if got != "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM" {
21 t.Fatal(got)
22 }
23}
24
25type tokenHarness struct {
26 client *Entra
27 key *rsa.PrivateKey
28 kid string
29 nonce string
30 verifier string
31 close func()
32}
33
34func newTokenHarness(t *testing.T) *tokenHarness {
35 t.Helper()
36 key, err := rsa.GenerateKey(rand.Reader, 2048)
37 if err != nil {
38 t.Fatal(err)
39 }
40 kid := "test-key-1"
41 tenant := "00000000-0000-0000-0000-000000000099"
42 clientID := "11111111-1111-1111-1111-111111111199"
43 oid := "22222222-2222-2222-2222-222222222299"
44 nonce := "nonce-abc"
45 verifier, err := NewPKCEVerifier()
46 if err != nil {
47 t.Fatal(err)
48 }
49 mux := http.NewServeMux()
50 srv := httptest.NewServer(mux)
51 issuer := srv.URL
52 mux.HandleFunc("/.well-known/openid-configuration", func(w http.ResponseWriter, r *http.Request) {
53 _ = json.NewEncoder(w).Encode(map[string]string{
54 "issuer": issuer,
55 "authorization_endpoint": issuer + "/authorize",
56 "token_endpoint": issuer + "/token",
57 "jwks_uri": issuer + "/jwks",
58 })
59 })
60 mux.HandleFunc("/jwks", func(w http.ResponseWriter, r *http.Request) {
61 _ = json.NewEncoder(w).Encode(map[string]any{"keys": []map[string]string{testJWK(key, kid)}})
62 })
63 mux.HandleFunc("/token", func(w http.ResponseWriter, r *http.Request) {
64 _ = r.ParseForm()
65 if r.Form.Get("code_verifier") != verifier {
66 http.Error(w, `{"error":"invalid_grant"}`, http.StatusBadRequest)
67 return
68 }
69 tok, err := signIDToken(key, kid, validTokenClaims(issuer, nonce, tenant, clientID, oid))
70 if err != nil {
71 http.Error(w, err.Error(), 500)
72 return
73 }
74 _ = json.NewEncoder(w).Encode(map[string]any{"access_token": "entra-access", "id_token": tok, "expires_in": 3600})
75 })
76 client := NewEntra(issuer, tenant, clientID, "client-secret-placeholder", "BlueGitAccountClient/0.1")
77 client.HTTP = srv.Client()
78 return &tokenHarness{client: client, key: key, kid: kid, nonce: nonce, verifier: verifier, close: srv.Close}
79}
80
81func validTokenClaims(issuer, nonce, tenant, clientID, oid string) map[string]any {
82 now := time.Now()
83 return map[string]any{
84 "iss": issuer, "aud": clientID, "exp": now.Add(time.Hour).Unix(),
85 "iat": now.Unix(), "nbf": now.Add(-time.Minute).Unix(),
86 "nonce": nonce, "oid": oid, "sub": oid, "tid": tenant,
87 "preferred_username": "ada@contoso.example",
88 }
89}
90
91func signIDTokenAlg(alg, kid string, claims map[string]any, signer func(signing string) (string, error)) (string, error) {
92 hdr, err := json.Marshal(map[string]string{"alg": alg, "typ": "JWT", "kid": kid})
93 if err != nil {
94 return "", err
95 }
96 payload, err := json.Marshal(claims)
97 if err != nil {
98 return "", err
99 }
100 h := base64.RawURLEncoding.EncodeToString(hdr)
101 p := base64.RawURLEncoding.EncodeToString(payload)
102 signing := h + "." + p
103 if signer == nil {
104 return signing + ".", nil
105 }
106 sig, err := signer(signing)
107 if err != nil {
108 return "", err
109 }
110 return signing + "." + sig, nil
111}
112
113func TestEntraRequiresPKCE(t *testing.T) {
114 h := newTokenHarness(t)
115 defer h.close()
116 if _, err := h.client.Exchange(context.Background(), "good-code", "https://cb", h.nonce, ""); err == nil || !strings.Contains(err.Error(), "PKCE") {
117 t.Fatalf("lege verifier: %v", err)
118 }
119 if _, err := h.client.Exchange(context.Background(), "good-code", "https://cb", h.nonce, "andere-verifier"); err == nil {
120 t.Fatal("verkeerde verifier moest falen")
121 }
122 if _, err := h.client.Exchange(context.Background(), "good-code", "https://cb", h.nonce, h.verifier); err != nil {
123 t.Fatal(err)
124 }
125}
126
127func TestEntraRejectsForeignEndpointHost(t *testing.T) {
128 mux := http.NewServeMux()
129 srv := httptest.NewServer(mux)
130 defer srv.Close()
131 mux.HandleFunc("/.well-known/openid-configuration", func(w http.ResponseWriter, r *http.Request) {
132 _ = json.NewEncoder(w).Encode(map[string]string{
133 "issuer": srv.URL,
134 "authorization_endpoint": srv.URL + "/authorize",
135 "token_endpoint": srv.URL + "/token",
136 "jwks_uri": "https://evil.example/jwks",
137 })
138 })
139 client := NewEntra(srv.URL, "t", "c", "s", "")
140 client.HTTP = srv.Client()
141 err := client.ensureDiscovery(context.Background())
142 if err == nil || !strings.Contains(err.Error(), "host") {
143 t.Fatalf("vreemde jwks-host moest falen, kreeg %v", err)
144 }
145}
146
147func TestEntraIDTokenChecks(t *testing.T) {
148 h := newTokenHarness(t)
149 defer h.close()
150 if err := h.client.ensureDiscovery(context.Background()); err != nil {
151 t.Fatal(err)
152 }
153 tenant := h.client.TenantID
154 clientID := h.client.ClientID
155 oid := "22222222-2222-2222-2222-222222222299"
156 issuer := h.client.Issuer
157 nonce := h.nonce
158
159 mustOK := func(t *testing.T, claims map[string]any) {
160 t.Helper()
161 tok, err := signIDToken(h.key, h.kid, claims)
162 if err != nil {
163 t.Fatal(err)
164 }
165 if _, err := h.client.verifyIDToken(context.Background(), tok, nonce); err != nil {
166 t.Fatal(err)
167 }
168 }
169 mustErr := func(t *testing.T, tok, sub string) {
170 t.Helper()
171 _, err := h.client.verifyIDToken(context.Background(), tok, nonce)
172 if err == nil || (sub != "" && !strings.Contains(err.Error(), sub)) {
173 t.Fatalf("verwacht %q, kreeg %v", sub, err)
174 }
175 }
176
177 t.Run("ok", func(t *testing.T) { mustOK(t, validTokenClaims(issuer, nonce, tenant, clientID, oid)) })
178
179 t.Run("verlopen", func(t *testing.T) {
180 c := validTokenClaims(issuer, nonce, tenant, clientID, oid)
181 c["exp"] = time.Now().Add(-2 * time.Minute).Unix()
182 tok, err := signIDToken(h.key, h.kid, c)
183 if err != nil {
184 t.Fatal(err)
185 }
186 mustErr(t, tok, "verlopen")
187 })
188 t.Run("geen exp", func(t *testing.T) {
189 c := validTokenClaims(issuer, nonce, tenant, clientID, oid)
190 delete(c, "exp")
191 tok, err := signIDToken(h.key, h.kid, c)
192 if err != nil {
193 t.Fatal(err)
194 }
195 mustErr(t, tok, "exp")
196 })
197 t.Run("klokverschuiving exp", func(t *testing.T) {
198 c := validTokenClaims(issuer, nonce, tenant, clientID, oid)
199 c["exp"] = time.Now().Add(-30 * time.Second).Unix()
200 mustOK(t, c)
201 })
202 t.Run("geen tid", func(t *testing.T) {
203 c := validTokenClaims(issuer, nonce, tenant, clientID, oid)
204 delete(c, "tid")
205 tok, err := signIDToken(h.key, h.kid, c)
206 if err != nil {
207 t.Fatal(err)
208 }
209 mustErr(t, tok, "tenant")
210 })
211 t.Run("verkeerde tid", func(t *testing.T) {
212 c := validTokenClaims(issuer, nonce, tenant, clientID, oid)
213 c["tid"] = "andere-tenant"
214 tok, err := signIDToken(h.key, h.kid, c)
215 if err != nil {
216 t.Fatal(err)
217 }
218 mustErr(t, tok, "tenant")
219 })
220 t.Run("tid hoofdletters", func(t *testing.T) {
221 c := validTokenClaims(issuer, nonce, tenant, clientID, oid)
222 c["tid"] = strings.ToUpper(tenant)
223 mustOK(t, c)
224 })
225 t.Run("verkeerde issuer", func(t *testing.T) {
226 c := validTokenClaims("https://evil.example/t/v2.0", nonce, tenant, clientID, oid)
227 tok, err := signIDToken(h.key, h.kid, c)
228 if err != nil {
229 t.Fatal(err)
230 }
231 mustErr(t, tok, "issuer")
232 })
233 t.Run("slechte handtekening", func(t *testing.T) {
234 tok, err := signIDToken(h.key, h.kid, validTokenClaims(issuer, nonce, tenant, clientID, oid))
235 if err != nil {
236 t.Fatal(err)
237 }
238 tok = tok[:len(tok)-4] + "AAAA"
239 mustErr(t, tok, "handtekening")
240 })
241 t.Run("alg none", func(t *testing.T) {
242 tok, err := signIDTokenAlg("none", h.kid, validTokenClaims(issuer, nonce, tenant, clientID, oid), nil)
243 if err != nil {
244 t.Fatal(err)
245 }
246 mustErr(t, tok, "algorithme")
247 })
248 t.Run("alg HS256", func(t *testing.T) {
249 tok, err := signIDTokenAlg("HS256", h.kid, validTokenClaims(issuer, nonce, tenant, clientID, oid), func(signing string) (string, error) {
250 mac := hmac.New(sha256.New, []byte("geheim"))
251 _, _ = mac.Write([]byte(signing))
252 return base64.RawURLEncoding.EncodeToString(mac.Sum(nil)), nil
253 })
254 if err != nil {
255 t.Fatal(err)
256 }
257 mustErr(t, tok, "algorithme")
258 })
259 t.Run("nbf toekomst", func(t *testing.T) {
260 c := validTokenClaims(issuer, nonce, tenant, clientID, oid)
261 c["nbf"] = time.Now().Add(2 * time.Minute).Unix()
262 tok, err := signIDToken(h.key, h.kid, c)
263 if err != nil {
264 t.Fatal(err)
265 }
266 mustErr(t, tok, "geldig")
267 })
268 t.Run("iat toekomst", func(t *testing.T) {
269 c := validTokenClaims(issuer, nonce, tenant, clientID, oid)
270 c["iat"] = time.Now().Add(2 * time.Minute).Unix()
271 tok, err := signIDToken(h.key, h.kid, c)
272 if err != nil {
273 t.Fatal(err)
274 }
275 mustErr(t, tok, "iat")
276 })
277}