package auth import ( "context" "crypto" "crypto/rand" "crypto/rsa" "crypto/sha256" "encoding/base64" "encoding/binary" "encoding/json" "net/http" "net/http/httptest" "strings" "testing" "time" ) func TestStableAuthID(t *testing.T) { a := StableAuthID("tenant-a", "oid-1") b := StableAuthID("tenant-a", "oid-1") c := StableAuthID("tenant-a", "oid-2") if a <= 0 || a != b || a == c { t.Fatalf("%d %d %d", a, b, c) } } func TestEntraUsername(t *testing.T) { u, err := entraUsername("Ada.Lovelace@contoso.example", "", "", "oid") if err != nil || u != "ada-lovelace" { t.Fatalf("%q %v", u, err) } u, err = entraUsername("", "", "!!!", "deadbeef-oid") if err != nil || !strings.HasPrefix(u, "u") { t.Fatalf("%q %v", u, err) } } func TestEntraExchangeWithFakeOIDC(t *testing.T) { 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) } var issuer string mux := http.NewServeMux() srv := httptest.NewServer(mux) defer srv.Close() 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) { if err := r.ParseForm(); err != nil { t.Error(err) } if r.Form.Get("code") != "good-code" || r.Form.Get("client_id") != clientID || r.Form.Get("code_verifier") != verifier { http.Error(w, `{"error":"invalid_grant"}`, http.StatusBadRequest) return } idTok, err := signIDToken(key, kid, map[string]any{ "iss": issuer, "aud": clientID, "exp": time.Now().Add(time.Hour).Unix(), "nbf": time.Now().Add(-time.Minute).Unix(), "nonce": nonce, "oid": oid, "sub": oid, "tid": tenant, "preferred_username": "ada@contoso.example", "name": "Ada Lovelace", }) if err != nil { t.Error(err) http.Error(w, err.Error(), 500) return } _ = json.NewEncoder(w).Encode(map[string]any{ "access_token": "entra-access", "id_token": idTok, "expires_in": 3600, "token_type": "Bearer", }) }) client := NewEntra(issuer, tenant, clientID, "client-secret-placeholder", "BlueGitAccountClient/0.1") client.HTTP = srv.Client() challenge := PKCEChallenge(verifier) url := client.AuthorizeURL("state-1", nonce, "https://git.example.test/auth/callback", challenge) if !strings.Contains(url, "/authorize?") || !strings.Contains(url, "nonce="+nonce) || !strings.Contains(url, "scope=openid+profile+email+User.Read") { t.Fatal(url) } if !strings.Contains(url, "code_challenge="+challenge) || !strings.Contains(url, "code_challenge_method=S256") { t.Fatal(url) } id, err := client.Exchange(context.Background(), "good-code", "https://git.example.test/auth/callback", nonce, verifier) if err != nil { t.Fatal(err) } if id.AuthID != StableAuthID(tenant, oid) || id.Username != "ada" || id.AccessToken != "entra-access" { t.Fatalf("%+v", id) } if id.IsAdmin || id.AvatarURL != "" || id.ExpiresIn != 86400 { t.Fatalf("degradatie verwacht: %+v", id) } sec, err := client.Extend(context.Background(), id.AccessToken) if err != nil || sec != 86400 { t.Fatalf("extend %d %v", sec, err) } if err := client.Logout(context.Background(), id.AccessToken); err != nil { t.Fatal(err) } if _, err := client.Exchange(context.Background(), "good-code", "https://git.example.test/auth/callback", "andere", verifier); err == nil { t.Fatal("verwacht nonce-fout") } } func TestEntraRejectsBadAudience(t *testing.T) { key, err := rsa.GenerateKey(rand.Reader, 2048) if err != nil { t.Fatal(err) } kid := "k1" mux := http.NewServeMux() srv := httptest.NewServer(mux) defer srv.Close() 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 + "/a", "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) { tok, _ := signIDToken(key, kid, map[string]any{ "iss": issuer, "aud": "andere-app", "exp": time.Now().Add(time.Hour).Unix(), "nonce": "n", "oid": "o", "sub": "o", "tid": "t", }) _ = json.NewEncoder(w).Encode(map[string]any{"access_token": "x", "id_token": tok}) }) client := NewEntra(issuer, "t", "mijn-app", "geheim", "") client.HTTP = srv.Client() _, err = client.Exchange(context.Background(), "c", "https://cb", "n", "pkce-verifier") if err == nil || !strings.Contains(err.Error(), "audience") { t.Fatalf("verwacht audience-fout, kreeg %v", err) } } func testJWK(key *rsa.PrivateKey, kid string) map[string]string { n := base64.RawURLEncoding.EncodeToString(key.N.Bytes()) eb := make([]byte, 8) binary.BigEndian.PutUint64(eb, uint64(key.E)) for len(eb) > 1 && eb[0] == 0 { eb = eb[1:] } return map[string]string{ "kty": "RSA", "kid": kid, "use": "sig", "alg": "RS256", "n": n, "e": base64.RawURLEncoding.EncodeToString(eb), } } func signIDToken(key *rsa.PrivateKey, kid string, claims map[string]any) (string, error) { hdr, err := json.Marshal(map[string]string{"alg": "RS256", "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 sum := sha256.Sum256([]byte(signing)) sig, err := rsa.SignPKCS1v15(rand.Reader, key, crypto.SHA256, sum[:]) if err != nil { return "", err } return signing + "." + base64.RawURLEncoding.EncodeToString(sig), nil }