Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
chore: domain restriction for email code login (#21177)
ecmadaofff15927a85d
diff --git a/backend/api/v1/auth_service.go b/backend/api/v1/auth_service.goindex 7f00daead5..da0a13885e 100644--- a/backend/api/v1/auth_service.go+++ b/backend/api/v1/auth_service.go@@ -251,7 +251,8 @@ func (s *AuthService) needResetPassword(ctx context.Context, user *store.UserMes// - Otherwise, creates a new workspace with the user as admin.func (s *AuthService) Signup(ctx context.Context, req *connect.Request[v1pb.SignupRequest]) (*connect.Response[v1pb.LoginResponse], error) {request := req.Msg- if request.Email == "" {+ email := strings.ToLower(strings.TrimSpace(request.Email))+ if email == "" {return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("email must be set"))}if request.Title == "" {@@ -260,12 +261,12 @@ func (s *AuthService) Signup(ctx context.Context, req *connect.Request[v1pb.Signif request.Password == "" {return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("password must be set"))}- if err := validateEndUserEmail(request.Email); err != nil {+ if err := validateEndUserEmail(email); err != nil {return nil, err}// Check if principal already exists.- existingUser, err := s.store.GetUserByEmail(ctx, request.Email)+ existingUser, err := s.store.GetUserByEmail(ctx, email)if err != nil {return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to find user by email"))}@@ -275,7 +276,7 @@ func (s *AuthService) Signup(ctx context.Context, req *connect.Request[v1pb.Sign// Resolve the target workspace (read-only) so we can check restrictions BEFORE// any write — otherwise a rejected signup would leave an orphan user/workspace behind.- targetWorkspaceID, _, err := s.resolveWorkspaceIDByEmail(ctx, request.Email)+ targetWorkspaceID, _, err := s.resolveWorkspaceIDByEmail(ctx, email)if err != nil {return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to resolve target workspace"))}@@ -301,7 +302,7 @@ func (s *AuthService) Signup(ctx context.Context, req *connect.Request[v1pb.Signreturn nil, err}- workspaceID, err := s.provisionWorkspaceForNewUser(ctx, request.Email)+ workspaceID, err := s.provisionWorkspaceForNewUser(ctx, email)if err != nil {return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to provision workspace"))}@@ -313,7 +314,7 @@ func (s *AuthService) Signup(ctx context.Context, req *connect.Request[v1pb.Sign// Step 2: Create the principal (global identity).user, err := s.store.CreateUser(ctx, &store.UserMessage{- Email: request.Email,+ Email: email,Name: request.Title,PasswordHash: string(passwordHash),Profile: &storepb.UserProfile{},@@ -1040,8 +1041,8 @@ func (s *AuthService) validateLoginPermissions(ctx context.Context, user *store.return connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to check user roles"))}- // Skip restrictions for workspace admins and service accounts- if isAdmin || user.Type != storepb.PrincipalType_END_USER {+ // Login restrictions only apply to end users.+ if user.Type != storepb.PrincipalType_END_USER {return nil}@@ -1063,7 +1064,7 @@ func (s *AuthService) validateLoginPermissions(ctx context.Context, user *store.}if request.GetIdpName() == "" {if request.Password != "" {- if restriction.DisallowPasswordSignin {+ if restriction.DisallowPasswordSignin && !isAdmin {return connect.NewError(connect.CodePermissionDenied, errors.Errorf("password signin is disallowed"))}}@@ -1728,6 +1729,13 @@ func (s *AuthService) SendEmailLoginCode(ctx context.Context, req *connect.Requeif err != nil {return nil, connect.NewError(connect.CodeInvalidArgument, err)}+ if workspaceID != "" {+ if err := validateEmailWithDomains(ctx, s.licenseService, s.store, workspaceID, email, false); err != nil {+ return nil, err+ }+ } else if err := validateEndUserEmail(email); err != nil {+ return nil, err+ }// Gate on AllowEmailCodeSignin — no point emailing a code the workspace won't accept.// getAccountRestriction handles all cases (including empty workspace for brand-new SaaS@@ -1937,6 +1945,13 @@ func (s *AuthService) authenticateEmailCodeLogin(ctx context.Context, request *vif err != nil {return nil, err}+ if codeRow.Workspace != "" {+ if err := validateEmailWithDomains(ctx, s.licenseService, s.store, codeRow.Workspace, email, false); err != nil {+ return nil, err+ }+ } else if err := validateEndUserEmail(email); err != nil {+ return nil, err+ }// Existing user → return. allow_email_code_signin is checked later in validateLoginPermissions// against the actually-resolved login workspace (which may not match the send-time workspace@@ -1949,11 +1964,6 @@ func (s *AuthService) authenticateEmailCodeLogin(ctx context.Context, request *vreturn user, nil}- // Unknown email → signup path. Validate email format to prevent reserved-namespace collisions.- if err := validateEndUserEmail(email); err != nil {- return nil, err- }-// Gate checks run BEFORE user creation to prevent orphan accounts.// We only consult AllowEmailCodeSignin here: DisallowSignup governs password self-service// signup (the Signup RPC), not email-code onboarding — the two paths are independent.diff --git a/backend/api/v1/auth_service_test.go b/backend/api/v1/auth_service_test.goindex 6f9b306aea..45dabfe2fe 100644--- a/backend/api/v1/auth_service_test.go+++ b/backend/api/v1/auth_service_test.go@@ -14,12 +14,16 @@ import ("github.com/bytebase/bytebase/backend/api/auth""github.com/bytebase/bytebase/backend/common""github.com/bytebase/bytebase/backend/common/testcontainer"+ "github.com/bytebase/bytebase/backend/component/config"+ "github.com/bytebase/bytebase/backend/enterprise"storepb "github.com/bytebase/bytebase/backend/generated-go/store"v1pb "github.com/bytebase/bytebase/backend/generated-go/v1""github.com/bytebase/bytebase/backend/migrator""github.com/bytebase/bytebase/backend/store")+const authTestEnterpriseLicense = "eyJhbGciOiJSUzI1NiIsImtpZCI6InYxIiwidHlwIjoiSldUIn0.eyJpbnN0YW5jZUNvdW50Ijo5OTksInRyaWFsaW5nIjpmYWxzZSwicGxhbiI6IkVOVEVSUFJJU0UiLCJvcmdOYW1lIjoiYmIiLCJhdWQiOiJiYi5saWNlbnNlIiwiZXhwIjo3OTc0OTc5MjAwLCJpYXQiOjE2NjM2Njc1NjEsImlzcyI6ImJ5dGViYXNlIiwic3ViIjoiMDAwMDEwMDAuIn0.JjYCMeAAMB9FlVeDFLdN3jvFcqtPsbEzaIm1YEDhUrfekthCbIOeX_DB2Bg2OUji3HSX5uDvG9AkK4Gtrc4gLMPI3D5mk3L-6wUKZ0L4REztS47LT4oxVhpqPQayYa9lKJB1YoHaqeMV4Z5FXeOXwuACoELznlwpT6pXo9xXm_I6QwQiO7-zD83XOTO4PRjByc-q3GKQu_64zJMIKiCW0I8a3GvrdSnO7jUuYU1KPmCuk0ZRq3I91m29LTo478BMST59HqCLj1GGuCKtR3SL_376XsZfUUM0iSAur5scg99zNGWRj-sUo05wbAadYx6V6TKaWrBUi_8_0RnJyP5gbA"+func TestExtractDomain(t *testing.T) {tests := []struct {domain string@@ -85,6 +89,196 @@ func TestPasswordResetEmailSkipsDeletedUser(t *testing.T) {))}+func TestLoginEnforcesWorkspaceDomains(t *testing.T) {+ const (+ workspaceID = "email-code-domain-test"+ secret = "test-secret"+ code = "123456"+ )++ ctx := context.Background()+ container := testcontainer.GetTestPgContainer(ctx, t)+ t.Cleanup(func() { container.Close(ctx) })+ require.NoError(t, migrator.MigrateSchema(ctx, container.GetDB()))++ pgURL := fmt.Sprintf("host=%s port=%s user=postgres password=root-password database=postgres", container.GetHost(), container.GetPort())+ stores, err := store.New(ctx, pgURL, false)+ require.NoError(t, err)+ t.Cleanup(func() { require.NoError(t, stores.Close()) })++ _, err = stores.CreateWorkspace(ctx, &store.WorkspaceMessage{+ ResourceID: workspaceID,+ Payload: &storepb.WorkspacePayload{Title: "Email code domain test"},+ }, "[email protected]")+ require.NoError(t, err)+ _, err = stores.UpsertSetting(ctx, &store.SettingMessage{+ Name: storepb.SettingName_WORKSPACE_PROFILE,+ Workspace: workspaceID,+ Value: &storepb.WorkspaceProfileSetting{+ Domains: []string{"allowed.example"},+ EnforceIdentityDomain: true,+ AllowEmailCodeSignin: true,+ PasswordRestriction: &storepb.WorkspaceProfileSetting_PasswordRestriction{MinLength: 8},+ EnableMetricCollection: true,+ DisallowSignup: false,+ DisallowPasswordSignin: true,+ },+ })+ require.NoError(t, err)+ _, err = stores.UpsertSetting(ctx, &store.SettingMessage{+ Name: storepb.SettingName_EMAIL,+ Workspace: workspaceID,+ Value: &storepb.EmailSetting{},+ })+ require.NoError(t, err)++ licenseService, err := enterprise.NewLicenseService(common.ReleaseModeDev, stores, false, "")+ require.NoError(t, err)+ require.NoError(t, licenseService.StoreLicense(ctx, workspaceID, authTestEnterpriseLicense))+ service := NewAuthService(stores, secret, licenseService, &config.Profile{}, nil)+ workspaceName := common.FormatWorkspace(workspaceID)++ allowedAdmin, err := stores.CreateUser(ctx, &store.UserMessage{+ Email: "[email protected]",+ Name: "Allowed admin",+ PasswordHash: "unused",+ Profile: &storepb.UserProfile{},+ })+ require.NoError(t, err)+ blockedAdmin, err := stores.CreateUser(ctx, &store.UserMessage{+ Email: "[email protected]",+ Name: "Blocked admin",+ PasswordHash: "unused",+ Profile: &storepb.UserProfile{},+ })+ require.NoError(t, err)+ _, err = stores.PatchWorkspaceIamPolicy(ctx, &store.PatchIamPolicyMessage{+ Workspace: workspaceID,+ Member: common.FormatUserEmail(blockedAdmin.Email),+ Roles: []string{common.FormatRole(store.WorkspaceAdminRole)},+ })+ require.NoError(t, err)++ t.Run("workspace admin", func(t *testing.T) {+ for _, test := range []struct {+ name string+ request *v1pb.LoginRequest+ }{+ {+ name: "password login enforces domains",+ request: &v1pb.LoginRequest{Email: blockedAdmin.Email, Password: "password"},+ },+ {+ name: "SSO login enforces domains",+ request: &v1pb.LoginRequest{Email: blockedAdmin.Email, IdpName: "idps/test"},+ },+ } {+ t.Run(test.name, func(t *testing.T) {+ err := service.validateLoginPermissions(ctx, blockedAdmin, workspaceID, test.request)+ require.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))+ require.ErrorContains(t, err, "does not belong to allowed domains")+ })+ }++ err := service.validateLoginPermissions(ctx, allowedAdmin, workspaceID, &v1pb.LoginRequest{+ Email: allowedAdmin.Email,+ Password: "password",+ })+ require.NoError(t, err, "workspace admins remain exempt from disallow_password_signin")+ })++ t.Run("send code", func(t *testing.T) {+ for _, email := range []string{"[email protected]", blockedAdmin.Email} {+ _, err := service.SendEmailLoginCode(ctx, connect.NewRequest(&v1pb.SendEmailLoginCodeRequest{+ Email: email,+ Workspace: &workspaceName,+ }))+ require.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))+ require.ErrorContains(t, err, "does not belong to allowed domains")++ row, err := stores.GetEmailVerificationCode(ctx, email, storepb.EmailVerificationCodePurpose_LOGIN)+ require.NoError(t, err)+ require.Nil(t, row)+ }+ })++ t.Run("authenticate existing user", func(t *testing.T) {+ const email = "[email protected]"+ _, err := stores.CreateUser(ctx, &store.UserMessage{+ Email: email,+ Name: "Existing user",+ PasswordHash: "unused",+ Profile: &storepb.UserProfile{},+ })+ require.NoError(t, err)+ _, err = stores.UpsertEmailVerificationCodeIfCooldownExpired(ctx, &store.EmailVerificationCodeMessage{+ Email: email,+ Purpose: storepb.EmailVerificationCodePurpose_LOGIN,+ CodeHash: service.hashEmailCode(code),+ ExpiresAt: time.Now().Add(time.Minute),+ LastSentAt: time.Now(),+ Workspace: workspaceID,+ }, 0)+ require.NoError(t, err)++ _, err = service.authenticateEmailCodeLogin(ctx, &v1pb.LoginRequest{+ Email: email,+ EmailCode: ptr(code),+ })+ require.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))+ require.ErrorContains(t, err, "does not belong to allowed domains")+ })++ t.Run("authenticate workspace admin", func(t *testing.T) {+ _, err := stores.UpsertEmailVerificationCodeIfCooldownExpired(ctx, &store.EmailVerificationCodeMessage{+ Email: blockedAdmin.Email,+ Purpose: storepb.EmailVerificationCodePurpose_LOGIN,+ CodeHash: service.hashEmailCode(code),+ ExpiresAt: time.Now().Add(time.Minute),+ LastSentAt: time.Now(),+ Workspace: workspaceID,+ }, 0)+ require.NoError(t, err)++ _, err = service.authenticateEmailCodeLogin(ctx, &v1pb.LoginRequest{+ Email: blockedAdmin.Email,+ EmailCode: ptr(code),+ })+ require.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))+ require.ErrorContains(t, err, "does not belong to allowed domains")+ })++ t.Run("authenticate unknown user before provisioning", func(t *testing.T) {+ const email = "[email protected]"+ _, err := stores.UpsertEmailVerificationCodeIfCooldownExpired(ctx, &store.EmailVerificationCodeMessage{+ Email: email,+ Purpose: storepb.EmailVerificationCodePurpose_LOGIN,+ CodeHash: service.hashEmailCode(code),+ ExpiresAt: time.Now().Add(time.Minute),+ LastSentAt: time.Now(),+ Workspace: workspaceID,+ }, 0)+ require.NoError(t, err)++ _, err = service.authenticateEmailCodeLogin(ctx, &v1pb.LoginRequest{+ Email: email,+ EmailCode: ptr(code),+ })+ require.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))+ require.ErrorContains(t, err, "does not belong to allowed domains")++ user, err := stores.GetUserByEmail(ctx, email)+ require.NoError(t, err)+ require.Nil(t, user)++ policy, err := stores.GetWorkspaceIamPolicy(ctx, workspaceID)+ require.NoError(t, err)+ for _, binding := range policy.Policy.Bindings {+ require.NotContains(t, binding.Members, common.FormatUserEmail(email))+ }+ })+}+// TestSwitchWorkspaceMCPRecognition pins the SwitchWorkspace guard predicate// across both MCP credential generations. An MCP session must never mint a// plain user token: that token is not audience-bound to the MCP resource, doesdiff --git a/backend/api/v1/user_service.go b/backend/api/v1/user_service.goindex cb50a20909..2c7c2d00a4 100644--- a/backend/api/v1/user_service.go+++ b/backend/api/v1/user_service.go@@ -755,6 +755,10 @@ func validateEndUserEmail(email string) error {if common.IsWorkloadIdentityEmail(email) {return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("email for end users cannot end with %v", common.WorkloadIdentitySuffix))}+ // Check if the email is valid.+ if err := common.ValidateEmail(email); err != nil {+ return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("invalid email: %v", err.Error()))+ }return nil}@@ -764,10 +768,6 @@ func validateEmailWithDomains(ctx context.Context, licenseService *enterprise.Li}if licenseService.IsFeatureEnabled(ctx, workspaceID, v1pb.PlanFeature_FEATURE_USER_EMAIL_DOMAIN_RESTRICTION) != nil {// nolint:nilerr- // feature not enabled, only validate email and skip domain restriction.- if err := common.ValidateEmail(email); err != nil {- return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("invalid email: %v", err.Error()))- }return nil}setting, err := stores.GetWorkspaceProfileSetting(ctx, workspaceID)@@ -780,10 +780,6 @@ func validateEmailWithDomains(ctx context.Context, licenseService *enterprise.LiallowedDomains = setting.Domains}- // Check if the email is valid.- if err := common.ValidateEmail(email); err != nil {- return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("invalid email: %v", err.Error()))- }// Enforce domain restrictions.if len(allowedDomains) > 0 {ok := false@@ -794,7 +790,7 @@ func validateEmailWithDomains(ctx context.Context, licenseService *enterprise.Li}}if !ok {- return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("email %q does not belong to domains %v", email, allowedDomains))+ return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("email %q does not belong to allowed domains", email))}}return nildiff --git a/backend/tests/tests.go b/backend/tests/tests.goindex 85b2720db9..947c5914ab 100644--- a/backend/tests/tests.go+++ b/backend/tests/tests.go@@ -9,7 +9,6 @@ import ("fmt""net""net/http"- "strings""sync""time"@@ -399,7 +398,7 @@ func (ctl *controller) signupAndLogin(ctx context.Context) (string, error) {Email: "[email protected]",Password: "1024bytebase",Title: "demo",- })); err != nil && !strings.Contains(err.Error(), "already registered") {+ })); err != nil && connect.CodeOf(err) != connect.CodeAlreadyExists {return "", err}loginResp, err := ctl.authServiceClient.Login(ctx, connect.NewRequest(&v1pb.LoginRequest{