diff --git a/internal/pkg/auth/service_account.go b/internal/pkg/auth/service_account.go index 2b5b3c2a3..a630c3598 100644 --- a/internal/pkg/auth/service_account.go +++ b/internal/pkg/auth/service_account.go @@ -107,6 +107,27 @@ func AuthenticateServiceAccount(p *print.Printer, rt http.RoundTripper, disableW authFields[IDP_TOKEN_ENDPOINT] = "" if !disableWriting { + // Clean up user credentials to avoid stale fields + if err = DeleteAuthField(USER_EMAIL); err != nil { + p.Debug(print.ErrorLevel, "failed to delete auth field %s: %v", USER_EMAIL, err) + } + + if err = DeleteAuthField(REFRESH_TOKEN); err != nil { + p.Debug(print.ErrorLevel, "failed to delete auth field %s: &v", USER_EMAIL, err) + } + + if err = DeleteAuthField(SERVICE_ACCOUNT_TOKEN); err != nil { + p.Debug(print.ErrorLevel, "failed to delete auth field %s: &v", REFRESH_TOKEN, err) + } + + if err = DeleteAuthField(SERVICE_ACCOUNT_KEY); err != nil { + p.Debug(print.ErrorLevel, "failed to delete auth field %s: &v", SERVICE_ACCOUNT_TOKEN, err) + } + + if err = DeleteAuthField(PRIVATE_KEY); err != nil { + p.Debug(print.ErrorLevel, "failed to delete auth field %s: &v", SERVICE_ACCOUNT_KEY, err) + } + err = SetAuthFlow(authFlowType) if err != nil { return "", "", fmt.Errorf("set auth flow type: %w", err) diff --git a/internal/pkg/auth/storage.go b/internal/pkg/auth/storage.go index 9f8b512e1..36d989696 100644 --- a/internal/pkg/auth/storage.go +++ b/internal/pkg/auth/storage.go @@ -106,6 +106,12 @@ func setAuthFieldWithProfile(profile string, key authFieldKey, value string) err if errFallback != nil { return fmt.Errorf("write to keyring failed (%w), try writing to encoded text file: %w", err, errFallback) } + // If writing to the text file succeeded as a fallback, clean up any stale key in the keyring + // so GetAuthField won't return outdated credentials. + _ = deleteAuthFieldInKeyring(profile, key) + } else { + // If writing to the keyring succeeded, clean up any old entry from the encoded text file. + _ = deleteAuthFieldInEncodedTextFile(profile, key) } return nil @@ -130,31 +136,34 @@ func DeleteAuthField(key authFieldKey) error { } func deleteAuthFieldWithProfile(profile string, key authFieldKey) error { + var errKeyring, errFile error + err := deleteAuthFieldInKeyring(profile, key) + if err != nil && !errors.Is(err, keyring.ErrNotFound) { + errKeyring = err + } + + err = deleteAuthFieldInEncodedTextFile(profile, key) if err != nil { - // if the key is not found, we can ignore the error - if !errors.Is(err, keyring.ErrNotFound) { - errFallback := deleteAuthFieldInEncodedTextFile(profile, key) - if errFallback != nil { - return fmt.Errorf("delete from keyring failed (%w), try deleting from encoded text file: %w", err, errFallback) - } - } + errFile = err + } + + if errKeyring != nil && errFile != nil { + return fmt.Errorf("delete from keyring: %w, delete from encoded text file: %w", errKeyring, errFile) } return nil } func deleteAuthFieldInEncodedTextFile(activeProfile string, key authFieldKey) error { - err := createEncodedTextFile(activeProfile) - if err != nil { - return err - } - textFileDir := config.GetProfileFolderPath(activeProfile) textFilePath := filepath.Join(textFileDir, textFileName) contentEncoded, err := os.ReadFile(textFilePath) if err != nil { + if os.IsNotExist(err) { + return nil + } return fmt.Errorf("read file: %w", err) } @@ -170,8 +179,21 @@ func deleteAuthFieldInEncodedTextFile(activeProfile string, key authFieldKey) er return fmt.Errorf("unmarshal file: %w", err) } + if _, ok := content[key]; !ok { + return nil + } + delete(content, key) + if len(content) == 0 { + err = os.Remove(textFilePath) + if err != nil && !os.IsNotExist(err) { + return fmt.Errorf("remove empty encoded text file: %w", err) + } + + return nil + } + contentBytes, err = json.Marshal(content) if err != nil { return fmt.Errorf("marshal file: %w", err) @@ -291,11 +313,6 @@ func getAuthFieldFromKeyring(activeProfile string, key authFieldKey) (string, er } func getAuthFieldFromEncodedTextFile(activeProfile string, key authFieldKey) (string, error) { - err := createEncodedTextFile(activeProfile) - if err != nil { - return "", err - } - textFileDir := config.GetProfileFolderPath(activeProfile) textFilePath := filepath.Join(textFileDir, textFileName) @@ -403,6 +420,17 @@ func GetAuthEmail() (string, error) { } func LoginUser(email, accessToken, refreshToken, sessionExpiresAtUnix string) error { + // Clean up any service account credentials that might be present + saFields := []authFieldKey{ + SERVICE_ACCOUNT_KEY, + PRIVATE_KEY, + SERVICE_ACCOUNT_TOKEN, + SERVICE_ACCOUNT_EMAIL, + } + for _, key := range saFields { + _ = DeleteAuthField(key) + } + authFields := map[authFieldKey]string{ SESSION_EXPIRES_AT_UNIX: sessionExpiresAtUnix, ACCESS_TOKEN: accessToken, @@ -419,13 +447,26 @@ func LoginUser(email, accessToken, refreshToken, sessionExpiresAtUnix string) er } func LogoutUser() error { - for _, key := range loginAuthFieldKeys { + for _, key := range authFieldKeys { err := DeleteAuthField(key) if err != nil { return fmt.Errorf("delete auth field \"%s\": %w", key, err) } } + activeProfile, err := config.GetProfile() + if err != nil { + return fmt.Errorf("get profile: %w", err) + } + + textFileDir := config.GetProfileFolderPath(activeProfile) + textFilePath := filepath.Join(textFileDir, textFileName) + + err = os.Remove(textFilePath) + if err != nil && !os.IsNotExist(err) { + return fmt.Errorf("remove auth storage file: %w", err) + } + return nil } @@ -446,5 +487,13 @@ func DeleteProfileAuth(profile string) error { } } + textFileDir := config.GetProfileFolderPath(profile) + textFilePath := filepath.Join(textFileDir, textFileName) + + err = os.Remove(textFilePath) + if err != nil && !os.IsNotExist(err) { + return fmt.Errorf("remove auth storage file: %w", err) + } + return nil } diff --git a/internal/pkg/auth/storage_test.go b/internal/pkg/auth/storage_test.go index 3aac14307..33d7a3e09 100644 --- a/internal/pkg/auth/storage_test.go +++ b/internal/pkg/auth/storage_test.go @@ -3,6 +3,7 @@ package auth import ( "fmt" "os" + "path/filepath" "testing" "time" @@ -114,6 +115,8 @@ func TestSetGetAuthField(t *testing.T) { for _, tt := range tests { t.Run(tt.description, func(t *testing.T) { + config.SetDefaultConfigFolderPath(t.TempDir()) + activeProfile, err := config.GetProfile() if err != nil { t.Errorf("get profile: %v", err) @@ -270,6 +273,7 @@ func TestSetGetAuthFieldWithProfile(t *testing.T) { for _, tt := range tests { t.Run(tt.description, func(t *testing.T) { + config.SetDefaultConfigFolderPath(t.TempDir()) // Apppend random string to profile name to avoid conflicts tt.activeProfile = makeProfileNameUnique(tt.activeProfile) @@ -431,6 +435,7 @@ func TestSetGetAuthFieldKeyring(t *testing.T) { for _, tt := range tests { t.Run(tt.description, func(t *testing.T) { + config.SetDefaultConfigFolderPath(t.TempDir()) keyring.MockInit() // Apppend random string to profile name to avoid conflicts @@ -501,6 +506,8 @@ func TestDeleteAuthField(t *testing.T) { for _, tt := range tests { t.Run(tt.description, func(t *testing.T) { + config.SetDefaultConfigFolderPath(t.TempDir()) + if !tt.keyringFails { keyring.MockInit() } else { @@ -590,6 +597,8 @@ func TestDeleteAuthFieldWithProfile(t *testing.T) { for _, tt := range tests { t.Run(tt.description, func(t *testing.T) { + config.SetDefaultConfigFolderPath(t.TempDir()) + if !tt.keyringFails { keyring.MockInit() } else { @@ -654,6 +663,7 @@ func TestDeleteAuthFieldKeyring(t *testing.T) { for _, tt := range tests { t.Run(tt.description, func(t *testing.T) { + config.SetDefaultConfigFolderPath(t.TempDir()) keyring.MockInit() // Append random string to auth field key and value to avoid conflicts @@ -740,6 +750,8 @@ func TestDeleteProfileFromKeyring(t *testing.T) { for _, tt := range tests { t.Run(tt.description, func(t *testing.T) { + config.SetDefaultConfigFolderPath(t.TempDir()) + if !tt.keyringFails { keyring.MockInit() } else { @@ -887,6 +899,7 @@ func TestSetGetAuthFieldEncodedTextFile(t *testing.T) { for _, tt := range tests { t.Run(tt.description, func(t *testing.T) { + config.SetDefaultConfigFolderPath(t.TempDir()) // Append random string to profile name to avoid conflicts tt.activeProfile = makeProfileNameUnique(tt.activeProfile) @@ -1039,6 +1052,7 @@ func TestGetProfileEmail(t *testing.T) { for _, tt := range tests { t.Run(tt.description, func(t *testing.T) { + config.SetDefaultConfigFolderPath(t.TempDir()) keyring.MockInit() // Append random string to profile name to avoid conflicts @@ -1187,6 +1201,7 @@ func TestAuthorizeDeauthorizeUserProfileAuth(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { + config.SetDefaultConfigFolderPath(t.TempDir()) keyring.MockInit() if err := LoginUser(tt.args.email, tt.args.accessToken, tt.args.refreshToken, tt.args.sessionExpiresAtUnix); (err != nil) != tt.wantErr { @@ -1228,3 +1243,290 @@ func TestAuthorizeDeauthorizeUserProfileAuth(t *testing.T) { }) } } + +func TestStaleKeychainCleanupOnFallback(t *testing.T) { + config.SetDefaultConfigFolderPath(t.TempDir()) + keyring.MockInit() + + profile, err := config.GetProfile() + if err != nil { + t.Fatalf("get profile: %v", err) + } + + oldKeyringVal := "stale_rsa_2048_key" + newFileVal := "new_rsa_4096_key" + + // 1. Initially set the old key in keyring + err = setAuthFieldInKeyring(profile, PRIVATE_KEY, oldKeyringVal) + if err != nil { + t.Fatalf("set in keyring: %v", err) + } + + // Verify keyring has it + got, err := getAuthFieldFromKeyring(profile, PRIVATE_KEY) + if err != nil || got != oldKeyringVal { + t.Fatalf("expected %s in keyring, got %s (err: %v)", oldKeyringVal, got, err) + } + + // 2. Simulate what setAuthFieldWithProfile does when keyring write fails: + // It writes to encoded text file and deletes from keyring + err = setAuthFieldInEncodedTextFile(profile, PRIVATE_KEY, newFileVal) + if err != nil { + t.Fatalf("set in text file: %v", err) + } + + err = deleteAuthFieldInKeyring(profile, PRIVATE_KEY) + if err != nil { + t.Fatalf("delete from keyring: %v", err) + } + + // 3. Now GetAuthField should return newFileVal, NOT the stale oldKeyringVal! + val, err := GetAuthField(PRIVATE_KEY) + if err != nil { + t.Fatalf("GetAuthField failed: %v", err) + } + + if val != newFileVal { + t.Errorf("GetAuthField returned stale value %q, expected %q", val, newFileVal) + } + + // Cleanup + _ = DeleteAuthField(PRIVATE_KEY) +} + +func TestFileNotCreatedOnReadOrDelete(t *testing.T) { + config.SetDefaultConfigFolderPath(t.TempDir()) + keyring.MockInit() + + profile, err := config.GetProfile() + if err != nil { + t.Fatalf("get profile: %v", err) + } + + textFilePath := filepath.Join(config.GetProfileFolderPath(profile), textFileName) + + // Ensure file doesn't exist + if _, err := os.Stat(textFilePath); !os.IsNotExist(err) { + t.Fatalf("expected file to not exist before test") + } + + nonExistingField := authFieldKey("non_existent_field_12345") + + // Call GetAuthField for a non-existent field + _, err = GetAuthField(nonExistingField) + if err == nil { + t.Errorf("expected error from GetAuthField for non-existent field") + } + + // Verify file was NOT created + if _, err := os.Stat(textFilePath); !os.IsNotExist(err) { + t.Errorf("cli-auth-storage.txt was created on GetAuthField for non-existent field") + } + + // Call DeleteAuthField for a non-existent field + _ = DeleteAuthField(nonExistingField) + + // Verify file was still NOT created + if _, err := os.Stat(textFilePath); !os.IsNotExist(err) { + t.Errorf("cli-auth-storage.txt was created on DeleteAuthField for non-existent field") + } +} + +func TestFileRemovedWhenEmpty(t *testing.T) { + config.SetDefaultConfigFolderPath(t.TempDir()) + + profile, err := config.GetProfile() + if err != nil { + t.Fatalf("get profile: %v", err) + } + + textFilePath := filepath.Join(config.GetProfileFolderPath(profile), textFileName) + + field1 := authFieldKey("test-cleanup-field-1") + field2 := authFieldKey("test-cleanup-field-2") + + // Write two fields to text file + if err := setAuthFieldInEncodedTextFile(profile, field1, "val1"); err != nil { + t.Fatalf("failed to set field1: %v", err) + } + + if err := setAuthFieldInEncodedTextFile(profile, field2, "val2"); err != nil { + t.Fatalf("failed to set field2: %v", err) + } + + if _, err := os.Stat(textFilePath); os.IsNotExist(err) { + t.Fatalf("expected file to exist after writing fields") + } + + // Delete field1 + if err := deleteAuthFieldInEncodedTextFile(profile, field1); err != nil { + t.Fatalf("failed to delete field1: %v", err) + } + + if _, err := os.Stat(textFilePath); os.IsNotExist(err) { + t.Fatalf("expected file to still exist with field2 remaining") + } + + // Delete field2 + if err := deleteAuthFieldInEncodedTextFile(profile, field2); err != nil { + t.Fatalf("failed to delete field2: %v", err) + } + + // Now file should be removed + if _, err := os.Stat(textFilePath); !os.IsNotExist(err) { + t.Errorf("expected cli-auth-storage.txt to be removed when empty, but it still exists") + } +} + +func TestLogoutCleansUpAllCredentialsAndFile(t *testing.T) { + config.SetDefaultConfigFolderPath(t.TempDir()) + keyring.MockInit() + + profile, err := config.GetProfile() + if err != nil { + t.Fatalf("get profile: %v", err) + } + + textFilePath := filepath.Join(config.GetProfileFolderPath(profile), textFileName) + + // Set user credentials + if err := SetAuthField(USER_EMAIL, "[EMAIL_REDACTED]"); err != nil { + t.Fatalf("set user email: %v", err) + } + + if err := SetAuthField(ACCESS_TOKEN, "user-access-token"); err != nil { + t.Fatalf("set access token: %v", err) + } + + // Set service account credentials + if err := SetAuthField(SERVICE_ACCOUNT_EMAIL, "[EMAIL_REDACTED]"); err != nil { + t.Fatalf("set sa email: %v", err) + } + + if err := SetAuthField(SERVICE_ACCOUNT_KEY, `{"id":"test"}`); err != nil { + t.Fatalf("set sa key: %v", err) + } + + // Also simulate fallback text file having a field + if err := setAuthFieldInEncodedTextFile(profile, PRIVATE_KEY, "some-private-key"); err != nil { + t.Fatalf("set private key in text file: %v", err) + } + + // Ensure text file exists + if _, err := os.Stat(textFilePath); os.IsNotExist(err) { + t.Fatalf("expected text file to exist") + } + + // Perform logout + if err := LogoutUser(); err != nil { + t.Fatalf("LogoutUser() failed: %v", err) + } + + // Verify user fields are deleted + if _, err := GetAuthField(USER_EMAIL); err == nil { + t.Errorf("USER_EMAIL still exists after logout") + } + + if _, err := GetAuthField(ACCESS_TOKEN); err == nil { + t.Errorf("ACCESS_TOKEN still exists after logout") + } + + // Verify service account fields are deleted + if _, err := GetAuthField(SERVICE_ACCOUNT_EMAIL); err == nil { + t.Errorf("SERVICE_ACCOUNT_EMAIL still exists after logout") + } + + if _, err := GetAuthField(SERVICE_ACCOUNT_KEY); err == nil { + t.Errorf("SERVICE_ACCOUNT_KEY still exists after logout") + } + + if _, err := GetAuthField(PRIVATE_KEY); err == nil { + t.Errorf("PRIVATE_KEY still exists after logout") + } + + // Verify text file was removed + if _, err := os.Stat(textFilePath); !os.IsNotExist(err) { + t.Errorf("cli-auth-storage.txt was not removed after logout") + } +} + +func TestLoginUserCleansUpServiceAccountCredentials(t *testing.T) { + config.SetDefaultConfigFolderPath(t.TempDir()) + keyring.MockInit() + + // Set SA credentials + if err := SetAuthField(SERVICE_ACCOUNT_EMAIL, "[EMAIL_REDACTED]"); err != nil { + t.Fatalf("set sa email: %v", err) + } + + if err := SetAuthField(SERVICE_ACCOUNT_KEY, `{"id":"test"}`); err != nil { + t.Fatalf("set sa key: %v", err) + } + + if err := SetAuthField(PRIVATE_KEY, "private-key-data"); err != nil { + t.Fatalf("set private key: %v", err) + } + + // Now call LoginUser + if err := LoginUser("[EMAIL_REDACTED]", "user-token", "refresh-token", "1234567890"); err != nil { + t.Fatalf("LoginUser failed: %v", err) + } + + // Verify SA fields were cleaned up + if val, err := GetAuthField(SERVICE_ACCOUNT_EMAIL); err == nil && val != "" { + t.Errorf("SERVICE_ACCOUNT_EMAIL still exists after LoginUser: %s", val) + } + + if val, err := GetAuthField(SERVICE_ACCOUNT_KEY); err == nil && val != "" { + t.Errorf("SERVICE_ACCOUNT_KEY still exists after LoginUser: %s", val) + } + + if val, err := GetAuthField(PRIVATE_KEY); err == nil && val != "" { + t.Errorf("PRIVATE_KEY still exists after LoginUser: %s", val) + } + + // Verify user fields are present + if val, err := GetAuthField(USER_EMAIL); err != nil || val != "[EMAIL_REDACTED]" { + t.Errorf("expected USER_EMAIL '[EMAIL_REDACTED]', got %q (err: %v)", val, err) + } + + // Cleanup + _ = LogoutUser() +} + +func TestKeyringWriteCleansUpTextFile(t *testing.T) { + config.SetDefaultConfigFolderPath(t.TempDir()) + keyring.MockInit() + + profile, err := config.GetProfile() + if err != nil { + t.Fatalf("get profile: %v", err) + } + + key := authFieldKey("test-sync-key") + + // Simulate old value in text file + if err := setAuthFieldInEncodedTextFile(profile, key, "old-file-value"); err != nil { + t.Fatalf("set in text file: %v", err) + } + + // Now set with setAuthFieldWithProfile (which succeeds in keyring) + if err := setAuthFieldWithProfile(profile, key, "new-keyring-value"); err != nil { + t.Fatalf("setAuthFieldWithProfile failed: %v", err) + } + + // Keyring has new value + val, err := getAuthFieldFromKeyring(profile, key) + if err != nil || val != "new-keyring-value" { + t.Errorf("expected new-keyring-value in keyring, got %q (err: %v)", val, err) + } + + // Text file should no longer have the old key + _, err = getAuthFieldFromEncodedTextFile(profile, key) + if err == nil { + t.Errorf("expected key to be removed from text file when set in keyring") + } + + // Cleanup + _ = deleteAuthFieldWithProfile(profile, key) +} diff --git a/internal/pkg/config/config.go b/internal/pkg/config/config.go index cf5856032..34e5ff450 100644 --- a/internal/pkg/config/config.go +++ b/internal/pkg/config/config.go @@ -254,3 +254,8 @@ func getInitialProfileFilePath() string { return filepath.Join(configFolderPath, fmt.Sprintf("%s.%s", profileFileName, profileFileExtension)) } + +// SetDefaultConfigFolderPath overrides the default config folder path. Intended for testing. +func SetDefaultConfigFolderPath(path string) { + defaultConfigFolderPath = path +}