Skip to content

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

chore: audit login request (#21189)

ecmadaof21abc450732
diff --git a/backend/api/v1/audit.go b/backend/api/v1/audit.go
index 9ad653532b..733d5d0153 100644
--- a/backend/api/v1/audit.go
+++ b/backend/api/v1/audit.go
@@ -496,7 +496,7 @@ func getRequestResource(request any, method string) string {
case *v1pb.CreateUserRequest:
return r.GetUser().GetName()
case *v1pb.LoginRequest:
- return r.GetEmail()
+ return strings.ToLower(strings.TrimSpace(r.GetEmail()))
case *v1pb.SignupRequest:
return r.GetEmail()
case *v1pb.ExchangeTokenRequest:
diff --git a/backend/api/v1/audit_test.go b/backend/api/v1/audit_test.go
index faa62d3960..eeedd09a8b 100644
--- a/backend/api/v1/audit_test.go
+++ b/backend/api/v1/audit_test.go
@@ -15,9 +15,11 @@ import (
"google.golang.org/protobuf/types/known/durationpb"
"github.com/bytebase/bytebase/backend/common"
+ "github.com/bytebase/bytebase/backend/component/config"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"
"github.com/bytebase/bytebase/backend/generated-go/v1/v1connect"
+ "github.com/bytebase/bytebase/backend/store"
)
// TestLogAuditToStdoutFormat is a contract test for the structured JSON fields
@@ -204,6 +206,58 @@ func TestAuditRedactsCredentials(t *testing.T) {
})
}
+func TestFailedLoginWithoutWorkspaceIsSkipped(t *testing.T) {
+ ctx := context.WithValue(context.Background(), common.AuthContextKey, &common.AuthContext{Audit: true})
+ st := newAuditLiveStore(t)
+ t.Cleanup(func() { require.NoError(t, st.Close()) })
+ in := NewAuditInterceptor(st, "test-secret", &config.Profile{})
+
+ err := in.createAuditLog(ctx, &auditEntry{
+ request: &v1pb.LoginRequest{
+ Email: " [email protected] ",
+ Password: "wrong-password",
+ },
+ method: v1connect.AuthServiceLoginProcedure,
+ rerr: connect.NewError(
+ connect.CodeUnauthenticated,
+ errors.New("invalid email or password"),
+ ),
+ })
+ require.NoError(t, err)
+
+ rows, err := st.SearchAuditLogs(ctx, &store.AuditLogFind{})
+ require.NoError(t, err)
+ require.Empty(t, rows)
+}
+
+func TestFailedLoginWithHandlerWorkspaceCreatesSingleAuditRow(t *testing.T) {
+ ctx := context.WithValue(context.Background(), common.AuthContextKey, &common.AuthContext{Audit: true})
+ st := newAuditLiveStore(t)
+ t.Cleanup(func() { require.NoError(t, st.Close()) })
+ in := NewAuditInterceptor(st, "test-secret", &config.Profile{})
+
+ err := in.createAuditLog(ctx, &auditEntry{
+ request: &v1pb.LoginRequest{
+ Email: " [email protected] ",
+ Password: "wrong-password",
+ },
+ method: v1connect.AuthServiceLoginProcedure,
+ handlerAuditWorkspaceID: auditTestWorkspace,
+ rerr: connect.NewError(
+ connect.CodeUnauthenticated,
+ errors.New("invalid email or password"),
+ ),
+ })
+ require.NoError(t, err)
+
+ rows, err := st.SearchAuditLogs(ctx, &store.AuditLogFind{})
+ require.NoError(t, err)
+ require.Len(t, rows, 1)
+ require.Equal(t, auditTestWorkspace, rows[0].Workspace)
+ require.Equal(t, common.FormatWorkspace(auditTestWorkspace), rows[0].Payload.GetParent())
+ require.Equal(t, "[email protected]", rows[0].Payload.GetResource())
+}
+
// TestStreamingAuditPersistedBeforeSend pins the streaming audit contract: a
// client must not observe a successful streaming response before the
// corresponding audit entry is durably persisted. Regression test for the
diff --git a/backend/api/v1/auth_service.go b/backend/api/v1/auth_service.go
index be63f993f6..3f3e5ef389 100644
--- a/backend/api/v1/auth_service.go
+++ b/backend/api/v1/auth_service.go
@@ -141,20 +141,9 @@ func (s *AuthService) GetAuthenticationRestriction(
ctx context.Context,
req *connect.Request[v1pb.GetAuthenticationRestrictionRequest],
) (*connect.Response[v1pb.AuthenticationInfo], error) {
- workspaceID := ""
- if req.Msg.Workspace != "" {
- id, err := common.GetWorkspaceID(req.Msg.Workspace)
- if err != nil {
- return nil, connect.NewError(connect.CodeInvalidArgument, err)
- }
- workspaceID = id
- }
- if workspaceID == "" && !s.profile.SaaS {
- id, err := s.store.GetWorkspaceID(ctx)
- if err != nil {
- return nil, connect.NewError(connect.CodeInternal, err)
- }
- workspaceID = id
+ workspaceID, err := s.resolveAuthenticationWorkspaceID(ctx, &req.Msg.Workspace)
+ if err != nil {
+ return nil, err
}
restriction, err := getAccountRestriction(ctx, s.store, s.licenseService, s.profile.SaaS, workspaceID)
@@ -171,10 +160,45 @@ func (s *AuthService) GetAuthenticationRestriction(
return connect.NewResponse(info), nil
}
+// resolveAuthenticationWorkspaceID resolves the workspace targeted by an
+// authentication request and announces it to the audit interceptor. An explicit
+// existing workspace is used regardless of account membership; self-hosted falls
+// back to the singleton workspace when the request omits it.
+func (s *AuthService) resolveAuthenticationWorkspaceID(ctx context.Context, workspaceName *string) (string, error) {
+ workspaceID, err := parseOptionalWorkspace(workspaceName)
+ if err != nil {
+ return "", connect.NewError(connect.CodeInvalidArgument, err)
+ }
+ if workspaceID != "" {
+ workspace, err := s.store.GetWorkspaceByID(ctx, workspaceID)
+ if err != nil {
+ return "", connect.NewError(connect.CodeInternal, errors.Wrap(err, "failed to get workspace"))
+ }
+ if workspace == nil {
+ return "", connect.NewError(connect.CodeInvalidArgument, errors.Errorf("workspace %q not found", common.FormatWorkspace(workspaceID)))
+ }
+ } else if !s.profile.SaaS {
+ workspaceID, err = s.store.GetWorkspaceID(ctx)
+ if err != nil {
+ return "", connect.NewError(connect.CodeInternal, errors.Wrap(err, "failed to get workspace"))
+ }
+ }
+ if workspaceID != "" {
+ common.SetAuditWorkspaceID(ctx, workspaceID)
+ }
+ return workspaceID, nil
+}
+
// Login is the auth login method including SSO.
func (s *AuthService) Login(ctx context.Context, req *connect.Request[v1pb.LoginRequest]) (*connect.Response[v1pb.LoginResponse], error) {
request := req.Msg
mfaSecondLogin := request.GetMfaTempToken() != ""
+ // Resolve the audit workspace before authentication so failures for unknown
+ // accounts can be recorded. SaaS requires an explicit workspace; self-hosted
+ // falls back to the singleton workspace.
+ if _, err := s.resolveAuthenticationWorkspaceID(ctx, request.Workspace); err != nil {
+ return nil, err
+ }
// 1. Authenticate user (password, IDP, or MFA completion)
loginUser, loginMethod, err := s.authenticateLogin(ctx, request)
@@ -596,21 +620,24 @@ func (s *AuthService) Refresh(ctx context.Context, req *connect.Request[v1pb.Ref
}
func (s *AuthService) getAndVerifyUser(ctx context.Context, request *v1pb.LoginRequest) (*store.UserMessage, error) {
+ email := strings.ToLower(strings.TrimSpace(request.Email))
+
// Check if user is locked out due to too many failed password attempts.
- if err := s.checkPasswordLockout(ctx, request.Email); err != nil {
+ if err := s.checkPasswordLockout(ctx, email); err != nil {
return nil, err
}
// GetAccountByEmail is cross-workspace, which is correct for login.
// Email is globally unique (PK). The token gets workspace from account.Workspace (SA/WI)
// or from the default workspace (END_USER).
- account, err := s.store.GetAccountByEmail(ctx, request.Email)
+ account, err := s.store.GetAccountByEmail(ctx, email)
if err != nil {
- return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get user by email %q", request.Email))
+ return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get user by email %q", email))
}
if account == nil {
return nil, invalidCredentialsError
}
+
// Compare the stored hashed password, with the hashed version of the password that was received.
if err := bcrypt.CompareHashAndPassword([]byte(account.PasswordHash), []byte(request.Password)); err != nil {
// If the two passwords don't match, return a 401 status.
@@ -862,7 +889,7 @@ func (s *AuthService) countRecentLoginFailures(ctx context.Context, email string
// Build filter query for login failures.
filterQ := qb.Q().Space("TRUE")
- filterQ.And("payload->>'method' = ?", "/bytebase.v1.AuthService/Login")
+ filterQ.And("payload->>'method' = ?", v1connect.AuthServiceLoginProcedure)
filterQ.And("payload->>'resource' = ?", email)
filterQ.And("(payload->'status'->>'code')::int != 0")
@@ -1046,7 +1073,6 @@ func (s *AuthService) completeMFALogin(ctx context.Context, request *v1pb.LoginR
if user == nil {
return nil, loginAuthMethodPassword, invalidCredentialsError
}
-
if err := s.checkMFALockout(ctx, user.Email); err != nil {
return nil, loginAuthMethodPassword, err
}
diff --git a/backend/api/v1/auth_service_test.go b/backend/api/v1/auth_service_test.go
index 80d007fa1a..238edb7e4b 100644
--- a/backend/api/v1/auth_service_test.go
+++ b/backend/api/v1/auth_service_test.go
@@ -10,6 +10,7 @@ import (
"connectrpc.com/connect"
"github.com/golang-jwt/jwt/v5"
"github.com/stretchr/testify/require"
+ statuspb "google.golang.org/genproto/googleapis/rpc/status"
"github.com/bytebase/bytebase/backend/api/auth"
"github.com/bytebase/bytebase/backend/common"
@@ -18,12 +19,161 @@ import (
"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/generated-go/v1/v1connect"
"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 TestCountRecentLoginFailures(t *testing.T) {
+ ctx := context.Background()
+ container := testcontainer.GetTestPgContainer(ctx, t)
+ t.Cleanup(func() { container.Close(ctx) })
+ db := container.GetDB()
+ require.NoError(t, migrator.MigrateSchema(ctx, db))
+ _, err := db.ExecContext(ctx, `INSERT INTO workspace (resource_id) VALUES ('ws-test')`)
+ require.NoError(t, err)
+
+ 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()) })
+ service := &AuthService{store: stores}
+
+ const email = "[email protected]"
+ createFailure := func(workspace, method, resource, user, message, response string) {
+ t.Helper()
+ require.NoError(t, stores.CreateAuditLog(ctx, workspace, &storepb.AuditLog{
+ Method: method,
+ Resource: resource,
+ User: user,
+ Response: response,
+ Status: &statuspb.Status{
+ Code: int32(connect.CodeUnauthenticated),
+ Message: message,
+ },
+ }))
+ }
+
+ createFailure("ws-test", v1connect.AuthServiceLoginProcedure, email, "", errMsgInvalidCredentials, "")
+ createFailure("ws-test", v1connect.AuthServiceLoginProcedure, email, "", errMsgInvalidCredentials, "")
+ createFailure("ws-test", v1connect.AuthServiceLoginProcedure, email, "", errMsgInvalidCredentials, "old")
+ createFailure("ws-test", v1connect.AuthServiceLoginProcedure, email, "", errMsgInvalidMFACode, "")
+ createFailure("ws-test", v1connect.AuthServiceLoginProcedure, email, "", errMsgInvalidRecoveryCode, "")
+ createFailure("ws-test", v1connect.AuthServiceSwitchWorkspaceProcedure, "workspaces/ws-test", common.FormatUserEmail(email), errMsgInvalidMFACode, "")
+ createFailure("ws-test", v1connect.AuthServiceSwitchWorkspaceProcedure, "workspaces/ws-test", common.FormatUserEmail(email), errMsgInvalidRecoveryCode, "")
+ require.NoError(t, stores.CreateAuditLog(ctx, "ws-test", &storepb.AuditLog{
+ Method: v1connect.AuthServiceLoginProcedure,
+ Resource: email,
+ Status: &statuspb.Status{},
+ }))
+
+ result, err := db.ExecContext(ctx, `UPDATE audit_log SET created_at = $1 WHERE payload->>'response' = 'old'`, time.Now().Add(-2*time.Hour))
+ require.NoError(t, err)
+ rowsAffected, err := result.RowsAffected()
+ require.NoError(t, err)
+ require.EqualValues(t, 1, rowsAffected)
+
+ passwordFailures, err := service.countRecentLoginFailures(ctx, email, time.Hour, errMsgInvalidCredentials)
+ require.NoError(t, err)
+ require.Equal(t, 2, passwordFailures)
+
+ mfaFailures, err := service.countRecentLoginFailures(ctx, email, time.Hour, errMsgInvalidMFACode, errMsgInvalidRecoveryCode)
+ require.NoError(t, err)
+ require.Equal(t, 2, mfaFailures)
+}
+
+func TestLoginAnnouncesPreAuthenticationWorkspace(t *testing.T) {
+ ctx := context.Background()
+ container := testcontainer.GetTestPgContainer(ctx, t)
+ t.Cleanup(func() { container.Close(ctx) })
+ db := container.GetDB()
+ require.NoError(t, migrator.MigrateSchema(ctx, db))
+ _, err := db.ExecContext(ctx, `INSERT INTO workspace (resource_id) VALUES ('ws-test')`)
+ require.NoError(t, err)
+
+ 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()) })
+
+ t.Run("self-hosted singleton", func(t *testing.T) {
+ service := &AuthService{store: stores, profile: &config.Profile{}}
+ var auditWorkspaceID string
+ ctx := common.WithSetAuditWorkspaceID(ctx, func(workspaceID string) {
+ auditWorkspaceID = workspaceID
+ })
+ _, err := service.Login(ctx, connect.NewRequest(&v1pb.LoginRequest{
+ Email: "[email protected]",
+ Password: "wrong-password",
+ }))
+ require.Equal(t, connect.CodeUnauthenticated, connect.CodeOf(err))
+ require.Equal(t, "ws-test", auditWorkspaceID)
+ })
+
+ t.Run("SaaS requested workspace", func(t *testing.T) {
+ service := &AuthService{store: stores, profile: &config.Profile{SaaS: true}}
+ var auditWorkspaceID string
+ ctx := common.WithSetAuditWorkspaceID(ctx, func(workspaceID string) {
+ auditWorkspaceID = workspaceID
+ })
+ workspace := common.FormatWorkspace("ws-test")
+ _, err := service.Login(ctx, connect.NewRequest(&v1pb.LoginRequest{
+ Email: "[email protected]",
+ Password: "wrong-password",
+ Workspace: &workspace,
+ }))
+ require.Equal(t, connect.CodeUnauthenticated, connect.CodeOf(err))
+ require.Equal(t, "ws-test", auditWorkspaceID)
+ })
+
+ t.Run("SaaS requested workspace without membership", func(t *testing.T) {
+ user, err := stores.CreateUser(ctx, &store.UserMessage{
+ Email: "[email protected]",
+ Name: "Member",
+ PasswordHash: "wrong-password-hash",
+ Profile: &storepb.UserProfile{},
+ })
+ require.NoError(t, err)
+ _, err = stores.CreateWorkspace(ctx, &store.WorkspaceMessage{
+ ResourceID: "ws-member",
+ Payload: &storepb.WorkspacePayload{Title: "Member workspace"},
+ }, user.Email)
+ require.NoError(t, err)
+
+ service := &AuthService{store: stores, profile: &config.Profile{SaaS: true}}
+ var auditWorkspaceIDs []string
+ ctx := common.WithSetAuditWorkspaceID(ctx, func(workspaceID string) {
+ auditWorkspaceIDs = append(auditWorkspaceIDs, workspaceID)
+ })
+ workspace := common.FormatWorkspace("ws-test")
+ _, err = service.Login(ctx, connect.NewRequest(&v1pb.LoginRequest{
+ Email: user.Email,
+ Password: "wrong-password",
+ Workspace: &workspace,
+ }))
+ require.Equal(t, connect.CodeUnauthenticated, connect.CodeOf(err))
+ require.Equal(t, []string{"ws-test"}, auditWorkspaceIDs)
+ })
+
+ t.Run("rejects nonexistent requested workspace", func(t *testing.T) {
+ service := &AuthService{store: stores, profile: &config.Profile{}}
+ var auditWorkspaceID string
+ ctx := common.WithSetAuditWorkspaceID(ctx, func(workspaceID string) {
+ auditWorkspaceID = workspaceID
+ })
+ workspace := common.FormatWorkspace("missing")
+ _, err := service.Login(ctx, connect.NewRequest(&v1pb.LoginRequest{
+ Email: "[email protected]",
+ Password: "wrong-password",
+ Workspace: &workspace,
+ }))
+ require.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))
+ require.Empty(t, auditWorkspaceID)
+ })
+}
+
func TestExtractDomain(t *testing.T) {
tests := []struct {
domain string
diff --git a/backend/tests/login_audit_test.go b/backend/tests/login_audit_test.go
index b0413fb636..463864e940 100644
--- a/backend/tests/login_audit_test.go
+++ b/backend/tests/login_audit_test.go
@@ -13,6 +13,7 @@ import (
"time"
"connectrpc.com/connect"
+ "github.com/pquerna/otp/totp"
"github.com/stretchr/testify/require"
"google.golang.org/protobuf/types/known/fieldmaskpb"
@@ -20,6 +21,142 @@ import (
v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"
)
+func TestLoginFailureLockout(t *testing.T) {
+ a := require.New(t)
+ ctx := context.Background()
+ ctl := &controller{}
+ ctx, err := ctl.StartServerWithExternalPg(ctx)
+ a.NoError(err)
+ defer ctl.Close(ctx)
+
+ workspaceResp, err := ctl.workspaceServiceClient.GetWorkspace(ctx, connect.NewRequest(&v1pb.GetWorkspaceRequest{
+ Name: "workspaces/-",
+ }))
+ a.NoError(err)
+ workspace := workspaceResp.Msg.Name
+ a.NotEmpty(workspace)
+ workspaceID, err := common.GetWorkspaceID(workspace)
+ a.NoError(err)
+
+ metadataDB, err := sql.Open("pgx", ctl.profile.PgURL)
+ a.NoError(err)
+ defer metadataDB.Close()
+ userName := common.FormatUserEmail("[email protected]")
+ mfaSetup, err := ctl.userServiceClient.UpdateUser(ctx, connect.NewRequest(&v1pb.UpdateUserRequest{
+ User: &v1pb.User{Name: userName},
+ UpdateMask: &fieldmaskpb.FieldMask{},
+ RegenerateTempMfaSecret: true,
+ }))
+ a.NoError(err)
+ validOTP, err := totp.GenerateCode(mfaSetup.Msg.TempOtpSecret, time.Now())
+ a.NoError(err)
+ _, err = ctl.userServiceClient.UpdateUser(ctx, connect.NewRequest(&v1pb.UpdateUserRequest{
+ User: &v1pb.User{Name: userName, MfaEnabled: true},
+ UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"mfa_enabled"}},
+ OtpCode: &validOTP,
+ }))
+ a.NoError(err)
+
+ adminToken := ctl.authInterceptor.token
+ ctl.authInterceptor.token = ""
+
+ mfaStart, err := ctl.authServiceClient.Login(ctx, connect.NewRequest(&v1pb.LoginRequest{
+ Email: "[email protected]",
+ Password: "1024bytebase",
+ }))
+ a.NoError(err)
+ mfaTempToken := mfaStart.Msg.GetMfaTempToken()
+ a.NotEmpty(mfaTempToken)
+ invalidOTP := "not-a-code"
+ for range 5 {
+ _, err := ctl.authServiceClient.Login(ctx, connect.NewRequest(&v1pb.LoginRequest{
+ OtpCode: &invalidOTP,
+ MfaTempToken: &mfaTempToken,
+ }))
+ a.Equal(connect.CodeUnauthenticated, connect.CodeOf(err))
+ a.ErrorContains(err, "invalid MFA code")
+ }
+ _, err = ctl.authServiceClient.Login(ctx, connect.NewRequest(&v1pb.LoginRequest{
+ OtpCode: &invalidOTP,
+ MfaTempToken: &mfaTempToken,
+ }))
+ a.Equal(connect.CodeResourceExhausted, connect.CodeOf(err))
+ a.ErrorContains(err, "too many failed MFA attempts")
+
+ for _, email := range []string{" [email protected] ", " [email protected] "} {
+ for range 10 {
+ _, err := ctl.authServiceClient.Login(ctx, connect.NewRequest(&v1pb.LoginRequest{
+ Email: email,
+ Password: "wrong-password",
+ }))
+ a.Equal(connect.CodeUnauthenticated, connect.CodeOf(err))
+ a.ErrorContains(err, "invalid email or password")
+ }
+ _, err := ctl.authServiceClient.Login(ctx, connect.NewRequest(&v1pb.LoginRequest{
+ Email: email,
+ Password: "wrong-password",
+ }))
+ a.Equal(connect.CodeResourceExhausted, connect.CodeOf(err))
+ a.ErrorContains(err, "too many failed login attempts")
+ }
+
+ ctl.authInterceptor.token = adminToken
+ search, err := ctl.auditLogServiceClient.SearchAuditLogs(ctx, connect.NewRequest(&v1pb.SearchAuditLogsRequest{
+ Parent: workspace,
+ Filter: `method == "/bytebase.v1.AuthService/Login"`,
+ OrderBy: "create_time desc",
+ PageSize: 100,
+ }))
+ a.NoError(err)
+
+ invalidPasswordCount := map[string]int{}
+ passwordLockoutCount := map[string]int{}
+ invalidMFACount := 0
+ mfaLockoutCount := 0
+ for _, auditLog := range search.Msg.AuditLogs {
+ if auditLog.Status == nil {
+ continue
+ }
+ a.True(strings.HasPrefix(auditLog.Name, workspace+"/auditLogs/"))
+ request := &v1pb.LoginRequest{}
+ a.NoError(common.ProtojsonUnmarshaler.Unmarshal([]byte(auditLog.Request), request))
+ a.Empty(request.Password)
+ a.Empty(request.GetOtpCode())
+ a.Empty(request.GetMfaTempToken())
+ a.NotContains(auditLog.Request, "wrong-password")
+ a.NotContains(auditLog.Request, invalidOTP)
+ a.NotContains(auditLog.Request, mfaTempToken)
+
+ switch auditLog.Status.Message {
+ case "invalid email or password":
+ invalidPasswordCount[auditLog.Resource]++
+ case "too many failed login attempts, please try again later":
+ passwordLockoutCount[auditLog.Resource]++
+ case "invalid MFA code":
+ invalidMFACount++
+ case "too many failed MFA attempts, please try again later":
+ mfaLockoutCount++
+ default:
+ }
+ }
+ a.Equal(10, invalidPasswordCount["[email protected]"])
+ a.Equal(10, invalidPasswordCount["[email protected]"])
+ a.Equal(1, passwordLockoutCount["[email protected]"])
+ a.Equal(1, passwordLockoutCount["[email protected]"])
+ a.Equal(5, invalidMFACount)
+ a.Equal(1, mfaLockoutCount)
+
+ var misownedRows int
+ a.NoError(metadataDB.QueryRowContext(ctx, `
+ SELECT COUNT(*)
+ FROM audit_log
+ WHERE workspace != $1
+ AND payload->>'method' = '/bytebase.v1.AuthService/Login'
+ AND payload->>'resource' IN ('[email protected]', '[email protected]')
+ `, workspaceID).Scan(&misownedRows))
+ a.Zero(misownedRows)
+}
+
// TestAuditLogFormat is both a regression test for the 3.17.0 bug where
// AuthService/Login (and Signup/ExchangeToken) silently dropped audit entries,
// AND a contract test for the shape of audit log entries returned by