Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

chore: domain restriction for email code login (#21177)

ecmadaofff15927a85d
diff --git a/backend/api/v1/auth_service.go b/backend/api/v1/auth_service.go
index 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.Sign
if 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.Sign
return 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.Reque
if 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 *v
if 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 *v
return 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.go
index 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"},
+ 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, does
diff --git a/backend/api/v1/user_service.go b/backend/api/v1/user_service.go
index 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.Li
allowedDomains = 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 nil
diff --git a/backend/tests/tests.go b/backend/tests/tests.go
index 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) {
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{