package auth import ( "context" "crypto/hmac" "crypto/rand" "crypto/rsa" "crypto/sha256" "encoding/base64" "encoding/json" "net/http" "net/http/httptest" "strings" "testing" "time" ) func TestPKCEChallengeRFC7636(t *testing.T) { got := PKCEChallenge("dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk") if got != "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM" { t.Fatal(got) } } type tokenHarness struct { client *Entra key *rsa.PrivateKey kid string nonce string verifier string close func() } func newTokenHarness(t *testing.T) *tokenHarness { t.Helper() key, err := rsa.GenerateKey(rand.Reader, 2048) if err != nil { t.Fatal(err) } kid := "test-key-1" tenant := "00000000-0000-0000-0000-000000000099" clientID := "11111111-1111-1111-1111-111111111199" oid := "22222222-2222-2222-2222-222222222299" nonce := "nonce-abc" verifier, err := NewPKCEVerifier() if err != nil { t.Fatal(err) } mux := http.NewServeMux() srv := httptest.NewServer(mux) issuer := srv.URL mux.HandleFunc("/.well-known/openid-configuration", func(w http.ResponseWriter, r *http.Request) { _ = json.NewEncoder(w).Encode(map[string]string{ "issuer": issuer, "authorization_endpoint": issuer + "/authorize", "token_endpoint": issuer + "/token", "jwks_uri": issuer + "/jwks", }) }) mux.HandleFunc("/jwks", func(w http.ResponseWriter, r *http.Request) { _ = json.NewEncoder(w).Encode(map[string]any{"keys": []map[string]string{testJWK(key, kid)}}) }) mux.HandleFunc("/token", func(w http.ResponseWriter, r *http.Request) { _ = r.ParseForm() if r.Form.Get("code_verifier") != verifier { http.Error(w, `{"error":"invalid_grant"}`, http.StatusBadRequest) return } tok, err := signIDToken(key, kid, validTokenClaims(issuer, nonce, tenant, clientID, oid)) if err != nil { http.Error(w, err.Error(), 500) return } _ = json.NewEncoder(w).Encode(map[string]any{"access_token": "entra-access", "id_token": tok, "expires_in": 3600}) }) client := NewEntra(issuer, tenant, clientID, "client-secret-placeholder", "BlueGitAccountClient/0.1") client.HTTP = srv.Client() return &tokenHarness{client: client, key: key, kid: kid, nonce: nonce, verifier: verifier, close: srv.Close} } func validTokenClaims(issuer, nonce, tenant, clientID, oid string) map[string]any { now := time.Now() return map[string]any{ "iss": issuer, "aud": clientID, "exp": now.Add(time.Hour).Unix(), "iat": now.Unix(), "nbf": now.Add(-time.Minute).Unix(), "nonce": nonce, "oid": oid, "sub": oid, "tid": tenant, "preferred_username": "ada@contoso.example", } } func signIDTokenAlg(alg, kid string, claims map[string]any, signer func(signing string) (string, error)) (string, error) { hdr, err := json.Marshal(map[string]string{"alg": alg, "typ": "JWT", "kid": kid}) if err != nil { return "", err } payload, err := json.Marshal(claims) if err != nil { return "", err } h := base64.RawURLEncoding.EncodeToString(hdr) p := base64.RawURLEncoding.EncodeToString(payload) signing := h + "." + p if signer == nil { return signing + ".", nil } sig, err := signer(signing) if err != nil { return "", err } return signing + "." + sig, nil } func TestEntraRequiresPKCE(t *testing.T) { h := newTokenHarness(t) defer h.close() if _, err := h.client.Exchange(context.Background(), "good-code", "https://cb", h.nonce, ""); err == nil || !strings.Contains(err.Error(), "PKCE") { t.Fatalf("lege verifier: %v", err) } if _, err := h.client.Exchange(context.Background(), "good-code", "https://cb", h.nonce, "andere-verifier"); err == nil { t.Fatal("verkeerde verifier moest falen") } if _, err := h.client.Exchange(context.Background(), "good-code", "https://cb", h.nonce, h.verifier); err != nil { t.Fatal(err) } } func TestEntraRejectsForeignEndpointHost(t *testing.T) { mux := http.NewServeMux() srv := httptest.NewServer(mux) defer srv.Close() mux.HandleFunc("/.well-known/openid-configuration", func(w http.ResponseWriter, r *http.Request) { _ = json.NewEncoder(w).Encode(map[string]string{ "issuer": srv.URL, "authorization_endpoint": srv.URL + "/authorize", "token_endpoint": srv.URL + "/token", "jwks_uri": "https://evil.example/jwks", }) }) client := NewEntra(srv.URL, "t", "c", "s", "") client.HTTP = srv.Client() err := client.ensureDiscovery(context.Background()) if err == nil || !strings.Contains(err.Error(), "host") { t.Fatalf("vreemde jwks-host moest falen, kreeg %v", err) } } func TestEntraIDTokenChecks(t *testing.T) { h := newTokenHarness(t) defer h.close() if err := h.client.ensureDiscovery(context.Background()); err != nil { t.Fatal(err) } tenant := h.client.TenantID clientID := h.client.ClientID oid := "22222222-2222-2222-2222-222222222299" issuer := h.client.Issuer nonce := h.nonce mustOK := func(t *testing.T, claims map[string]any) { t.Helper() tok, err := signIDToken(h.key, h.kid, claims) if err != nil { t.Fatal(err) } if _, err := h.client.verifyIDToken(context.Background(), tok, nonce); err != nil { t.Fatal(err) } } mustErr := func(t *testing.T, tok, sub string) { t.Helper() _, err := h.client.verifyIDToken(context.Background(), tok, nonce) if err == nil || (sub != "" && !strings.Contains(err.Error(), sub)) { t.Fatalf("verwacht %q, kreeg %v", sub, err) } } t.Run("ok", func(t *testing.T) { mustOK(t, validTokenClaims(issuer, nonce, tenant, clientID, oid)) }) t.Run("verlopen", func(t *testing.T) { c := validTokenClaims(issuer, nonce, tenant, clientID, oid) c["exp"] = time.Now().Add(-2 * time.Minute).Unix() tok, err := signIDToken(h.key, h.kid, c) if err != nil { t.Fatal(err) } mustErr(t, tok, "verlopen") }) t.Run("geen exp", func(t *testing.T) { c := validTokenClaims(issuer, nonce, tenant, clientID, oid) delete(c, "exp") tok, err := signIDToken(h.key, h.kid, c) if err != nil { t.Fatal(err) } mustErr(t, tok, "exp") }) t.Run("klokverschuiving exp", func(t *testing.T) { c := validTokenClaims(issuer, nonce, tenant, clientID, oid) c["exp"] = time.Now().Add(-30 * time.Second).Unix() mustOK(t, c) }) t.Run("geen tid", func(t *testing.T) { c := validTokenClaims(issuer, nonce, tenant, clientID, oid) delete(c, "tid") tok, err := signIDToken(h.key, h.kid, c) if err != nil { t.Fatal(err) } mustErr(t, tok, "tenant") }) t.Run("verkeerde tid", func(t *testing.T) { c := validTokenClaims(issuer, nonce, tenant, clientID, oid) c["tid"] = "andere-tenant" tok, err := signIDToken(h.key, h.kid, c) if err != nil { t.Fatal(err) } mustErr(t, tok, "tenant") }) t.Run("tid hoofdletters", func(t *testing.T) { c := validTokenClaims(issuer, nonce, tenant, clientID, oid) c["tid"] = strings.ToUpper(tenant) mustOK(t, c) }) t.Run("verkeerde issuer", func(t *testing.T) { c := validTokenClaims("https://evil.example/t/v2.0", nonce, tenant, clientID, oid) tok, err := signIDToken(h.key, h.kid, c) if err != nil { t.Fatal(err) } mustErr(t, tok, "issuer") }) t.Run("slechte handtekening", func(t *testing.T) { tok, err := signIDToken(h.key, h.kid, validTokenClaims(issuer, nonce, tenant, clientID, oid)) if err != nil { t.Fatal(err) } tok = tok[:len(tok)-4] + "AAAA" mustErr(t, tok, "handtekening") }) t.Run("alg none", func(t *testing.T) { tok, err := signIDTokenAlg("none", h.kid, validTokenClaims(issuer, nonce, tenant, clientID, oid), nil) if err != nil { t.Fatal(err) } mustErr(t, tok, "algorithme") }) t.Run("alg HS256", func(t *testing.T) { tok, err := signIDTokenAlg("HS256", h.kid, validTokenClaims(issuer, nonce, tenant, clientID, oid), func(signing string) (string, error) { mac := hmac.New(sha256.New, []byte("geheim")) _, _ = mac.Write([]byte(signing)) return base64.RawURLEncoding.EncodeToString(mac.Sum(nil)), nil }) if err != nil { t.Fatal(err) } mustErr(t, tok, "algorithme") }) t.Run("nbf toekomst", func(t *testing.T) { c := validTokenClaims(issuer, nonce, tenant, clientID, oid) c["nbf"] = time.Now().Add(2 * time.Minute).Unix() tok, err := signIDToken(h.key, h.kid, c) if err != nil { t.Fatal(err) } mustErr(t, tok, "geldig") }) t.Run("iat toekomst", func(t *testing.T) { c := validTokenClaims(issuer, nonce, tenant, clientID, oid) c["iat"] = time.Now().Add(2 * time.Minute).Unix() tok, err := signIDToken(h.key, h.kid, c) if err != nil { t.Fatal(err) } mustErr(t, tok, "iat") }) }