π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
Serialize account recovery updates
Neeraj Gupta52e6a2ffc8cd
diff --git a/server/pkg/controller/emergency/account_owner.go b/server/pkg/controller/emergency/account_owner.goindex c75ecf2513..8d38b86c2d 100644--- a/server/pkg/controller/emergency/account_owner.go+++ b/server/pkg/controller/emergency/account_owner.go@@ -133,16 +133,8 @@ func (c *Controller) UpdateRecoveryNotice(ctx *gin.Context, userID int64, requesreturn stacktrace.Propagate(ente.NewBadRequestWithMessage("recovery notice must be between 1 and 60 days"), "")}- activeSessions, err := c.Repo.GetActiveSessions(ctx, userID, request.EmergencyContactID)- if err != nil {- return stacktrace.Propagate(err, "failed to check active recovery sessions")- }- if len(activeSessions) > 0 {- return stacktrace.Propagate(&ente.ErrActiveRecoverySession, "")- }-noticePeriodInHrs := request.RecoveryNoticeInDays * 24- err = c.Repo.UpdateRecoveryNotice(ctx, userID, request.EmergencyContactID, noticePeriodInHrs)+ err := c.Repo.UpdateRecoveryNotice(ctx, userID, request.EmergencyContactID, noticePeriodInHrs)if err != nil {return stacktrace.Propagate(err, "failed to update recovery notice")}diff --git a/server/pkg/controller/emergency/controller.go b/server/pkg/controller/emergency/controller.goindex d406fca942..ed3b8d186b 100644--- a/server/pkg/controller/emergency/controller.go+++ b/server/pkg/controller/emergency/controller.go@@ -29,43 +29,23 @@ func (c *Controller) UpdateContact(ctx *gin.Context,if err := validateUpdateReq(userID, req); err != nil {return stacktrace.Propagate(err, "")}- if req.State == ente.ContactDenied || req.State == ente.ContactLeft || req.State == ente.UserRevokedContact {- activeSessions, sessionErr := c.Repo.GetActiveSessions(ctx, req.UserID, req.EmergencyContactID)- if sessionErr != nil {- return stacktrace.Propagate(sessionErr, "")- }- for _, session := range activeSessions {- if req.State == ente.UserRevokedContact {- rejErr := c.RejectRecovery(ctx, userID, ente.RecoveryIdentifier{- ID: session.ID,- UserID: session.UserID,- EmergencyContactID: session.EmergencyContactID,- })- if rejErr != nil {- return stacktrace.Propagate(rejErr, "failed to reject recovery")- }- } else {- stopErr := c.StopRecovery(ctx, userID, ente.RecoveryIdentifier{- ID: session.ID,- UserID: session.UserID,- EmergencyContactID: session.EmergencyContactID,- })- if stopErr != nil {- return stacktrace.Propagate(stopErr, "failed to stop recovery")- }- }- }+ hasUpdate, cancelled, err := c.Repo.UpdateState(ctx, req.UserID, req.EmergencyContactID, req.State)+ if err != nil {+ return stacktrace.Propagate(err, "")}- hasUpdate, err := c.Repo.UpdateState(ctx, req.UserID, req.EmergencyContactID, req.State)if !hasUpdate {log.WithField("userID", userID).WithField("req", req).Warn("No update applied for emergency contact")} else {+ status := ente.RecoveryStatusStopped+ if req.State == ente.UserRevokedContact {+ status = ente.RecoveryStatusRejected+ }+ for _, session := range cancelled {+ go c.sendRecoveryNotification(ctx, session.UserID, session.EmergencyContactID, status, nil)+ }go c.sendContactNotification(ctx, req.UserID, req.EmergencyContactID, req.State)}- if err != nil {- return stacktrace.Propagate(err, "")- }return nil}diff --git a/server/pkg/controller/emergency/recovery.go b/server/pkg/controller/emergency/recovery.goindex 67c273cbfe..15cd14f7a1 100644--- a/server/pkg/controller/emergency/recovery.go+++ b/server/pkg/controller/emergency/recovery.go@@ -2,6 +2,7 @@ package emergencyimport ("context"+ "database/sql""fmt""github.com/ente/museum/ente""github.com/ente/museum/pkg/repo/emergency"@@ -56,21 +57,14 @@ func (c *Controller) ChangePassword(ctx *gin.Context, userID int64, request entereturn nil, err}logOutAllSessions := request.UpdateSrp.LogOutOtherDevices == nil || *request.UpdateSrp.LogOutOtherDevices- resp, err := c.UserCtrl.RecoverSrpAndKeyAttributes(ctx, contact.UserID, request.UpdateSrp, logOutAllSessions)+ resp, err := c.UserCtrl.RecoverSrpAndKeyAttributes(ctx, contact.UserID, request.UpdateSrp, logOutAllSessions,+ func(txCtx context.Context, tx *sql.Tx) error {+ return c.Repo.CompleteRecovery(txCtx, tx, sessionID, contact.UserID, contact.EmergencyContactID)+ })if err != nil {return nil, stacktrace.Propagate(err, "")}-- hasUpdate, err := c.Repo.UpdateRecoveryStatusForSession(ctx, sessionID, contact.UserID, contact.EmergencyContactID, ente.RecoveryStatusRecovered)- if err != nil {- return nil, stacktrace.Propagate(err, "failed to update recovery status")- }- if !hasUpdate {- log.WithField("userID", userID).WithField("req", request).- Warn("no row updated while marking recovery complete")- } else {- go c.sendRecoveryNotification(ctx, contact.UserID, contact.EmergencyContactID, ente.RecoveryStatusRecovered, nil)- }+ go c.sendRecoveryNotification(ctx, contact.UserID, contact.EmergencyContactID, ente.RecoveryStatusRecovered, nil)return resp, nil}diff --git a/server/pkg/controller/emergency/recovery_contact.go b/server/pkg/controller/emergency/recovery_contact.goindex 4a0cd5ccd2..63f319c123 100644--- a/server/pkg/controller/emergency/recovery_contact.go+++ b/server/pkg/controller/emergency/recovery_contact.go@@ -18,12 +18,10 @@ func (c *Controller) StartRecovery(ctx *gin.Context,return stacktrace.Propagate(ente.ErrPermissionDenied, "only the emergency contact can start recovery")}- contact, err := c.Repo.GetActiveEmergencyContact(ctx, req.UserID, req.EmergencyContactID)+ hasUpdate, contact, err := c.Repo.InsertIntoRecovery(ctx, req)if err != nil {return stacktrace.Propagate(err, "")}-- hasUpdate, err := c.Repo.InsertIntoRecovery(ctx, req, *contact)if !hasUpdate {log.WithField("userID", actorUserID).WithField("req", req).Warn("No need to send email")@@ -31,9 +29,6 @@ func (c *Controller) StartRecovery(ctx *gin.Context,recoveryNoticeInDays := int64(contact.NoticePeriodInHrs / 24)go c.sendRecoveryNotification(ctx, req.UserID, req.EmergencyContactID, ente.RecoveryStatusInitiated, &recoveryNoticeInDays)}- if err != nil {- return stacktrace.Propagate(err, "")- }return nil}@@ -54,15 +49,13 @@ func (c *Controller) RejectRecovery(ctx *gin.Context,return stacktrace.Propagate(ente.ErrPermissionDenied, "only account owner can reject recovery")}hasUpdate, err := c.Repo.UpdateRecoveryStatusForSession(ctx, session.ID, session.UserID, session.EmergencyContactID, ente.RecoveryStatusRejected)- if !hasUpdate {- log.WithField("userID", userID).WithField("req", req).- Warn("no row updated while rejecting recovery")- } else {- go c.sendRecoveryNotification(ctx, session.UserID, session.EmergencyContactID, ente.RecoveryStatusRejected, nil)- }if err != nil {return stacktrace.Propagate(err, "")}+ if !hasUpdate {+ return stacktrace.Propagate(ente.NewConflictError("recovery session is no longer active"), "")+ }+ go c.sendRecoveryNotification(ctx, session.UserID, session.EmergencyContactID, ente.RecoveryStatusRejected, nil)return nil}@@ -80,15 +73,15 @@ func (c *Controller) ApproveRecovery(ctx *gin.Context,return stacktrace.Propagate(ente.ErrPermissionDenied, "only account owner can approve recovery")}hasUpdate, err := c.Repo.UpdateRecoveryStatusForSession(ctx, session.ID, session.UserID, session.EmergencyContactID, ente.RecoveryStatusReady)+ if err != nil {+ return stacktrace.Propagate(err, "")+ }if !hasUpdate {log.WithField("userID", userID).WithField("req", req).Warn("no row updated while approving recovery")} else {go c.sendRecoveryNotification(ctx, session.UserID, session.EmergencyContactID, ente.RecoveryStatusReady, nil)}- if err != nil {- return stacktrace.Propagate(err, "")- }return nil}@@ -113,12 +106,10 @@ func (c *Controller) StopRecovery(ctx *gin.Context,return stacktrace.Propagate(err, "")}if !hasUpdate {- log.WithField("userID", userID).WithField("req", req).- Warn("no row updated while stopping recovery")- } else {- go c.sendRecoveryNotification(ctx, session.UserID, session.EmergencyContactID, ente.RecoveryStatusStopped, nil)+ return stacktrace.Propagate(ente.NewConflictError("recovery session is no longer active"), "")}- return stacktrace.Propagate(err, "")+ go c.sendRecoveryNotification(ctx, session.UserID, session.EmergencyContactID, ente.RecoveryStatusStopped, nil)+ return nil}func (c *Controller) getRecoverySessionMatchingRequest(ctx *gin.Context, req ente.RecoveryIdentifier) (*emergencyRepo.RecoverRow, error) {diff --git a/server/pkg/controller/legacy_kit/controller.go b/server/pkg/controller/legacy_kit/controller.goindex 3866c7254c..7e30b81892 100644--- a/server/pkg/controller/legacy_kit/controller.go+++ b/server/pkg/controller/legacy_kit/controller.go@@ -3,6 +3,7 @@ package legacy_kitimport ("context""crypto/rand"+ "database/sql""encoding/base64""fmt""strings"@@ -287,13 +288,13 @@ func (c *Controller) ChangePassword(ctx *gin.Context, req ente.LegacyKitRecoveryreturn nil, stacktrace.Propagate(ente.NewBadRequestWithMessage("legacy kit recovery is not ready"), "")}logOutAllSessions := req.UpdateSrpAndKeysRequest.LogOutOtherDevices == nil || *req.UpdateSrpAndKeysRequest.LogOutOtherDevices- resp, err := c.UserCtrl.RecoverSrpAndKeyAttributes(ctx, session.UserID, req.UpdateSrpAndKeysRequest, logOutAllSessions)+ resp, err := c.UserCtrl.RecoverSrpAndKeyAttributes(ctx, session.UserID, req.UpdateSrpAndKeysRequest, logOutAllSessions,+ func(txCtx context.Context, tx *sql.Tx) error {+ return c.Repo.CompleteRecovery(txCtx, tx, session.ID, session.KitID, session.UserID, strings.TrimSpace(req.SessionToken))+ })if err != nil {return nil, stacktrace.Propagate(err, "failed to update password via legacy kit")}- if _, err := c.Repo.UpdateSessionStatus(ctx, session.ID, ente.LegacyKitRecoveryStatusRecovered); err != nil {- return nil, err- }go c.sendRecoveryCompletedNotification(context.Background(), session.UserID)return resp, nil}diff --git a/server/pkg/controller/user/srp.go b/server/pkg/controller/user/srp.goindex 4f532ecb6e..bc5028c144 100644--- a/server/pkg/controller/user/srp.go+++ b/server/pkg/controller/user/srp.go@@ -10,6 +10,7 @@ import ("github.com/ente/go-srp""github.com/ente/museum/ente""github.com/ente/museum/pkg/controller/authsession"+ "github.com/ente/museum/pkg/repo""github.com/ente/museum/pkg/utils/auth"emailUtil "github.com/ente/museum/pkg/utils/email""github.com/ente/stacktrace"@@ -76,45 +77,56 @@ func (c *UserController) UpdateSrpAndKeyAttributes(context *gin.Context,req ente.UpdateSRPAndKeysRequest,shouldClearTokens bool,) (*ente.UpdateSRPSetupResponse, error) {- return c.updateSrpAndKeyAttributes(context, userID, req, shouldClearTokens, revokeOtherSessions)+ return c.updateSrpAndKeyAttributes(context, userID, req, shouldClearTokens, revokeOtherSessions, nil)}func (c *UserController) RecoverSrpAndKeyAttributes(context *gin.Context,userID int64,req ente.UpdateSRPAndKeysRequest,logOutAllSessions bool,+ authorize repo.PasswordUpdateAuthorization,) (*ente.UpdateSRPSetupResponse, error) {- return c.updateSrpAndKeyAttributes(context, userID, req, logOutAllSessions, revokeAllSessions)+ return c.updateSrpAndKeyAttributes(context, userID, req, logOutAllSessions, revokeAllSessions, authorize)}-func (c *UserController) updateSrpAndKeyAttributes(context *gin.Context,+func (c *UserController) updateSrpAndKeyAttributes(ctx *gin.Context,userID int64,req ente.UpdateSRPAndKeysRequest,shouldClearTokens bool,revocationScope sessionRevocationScope,+ authorize repo.PasswordUpdateAuthorization,) (*ente.UpdateSRPSetupResponse, error) {if err := req.Validate(); err != nil {return nil, stacktrace.Propagate(err, "invalid request")}- setup, err := c.UserAuthRepo.GetTempSRPSetupEntity(context, req.SetupID)+ setup, err := c.UserAuthRepo.GetTempSRPSetupEntity(ctx, req.SetupID)if err != nil {return nil, stacktrace.Propagate(err, "")}- srpM2, err := c.verifySRPSession(context, setup.Verifier, setup.SessionID, req.SRPM1)+ srpM2, err := c.verifySRPSession(ctx, setup.Verifier, setup.SessionID, req.SRPM1)if err != nil {return nil, err}- if shouldClearTokens && c.SpaceAccessResetter != nil {- if err = c.SpaceAccessResetter.RevokeBrowserSessions(context, userID); err != nil {+ if shouldClearTokens && authorize == nil && c.SpaceAccessResetter != nil {+ if err = c.SpaceAccessResetter.RevokeBrowserSessions(ctx, userID); err != nil {return nil, err}}+ if authorize != nil && shouldClearTokens && c.SpaceAccessResetter != nil {+ recoveryAuthorization := authorize+ authorize = func(txCtx context.Context, tx *sql.Tx) error {+ if err := recoveryAuthorization(txCtx, tx); err != nil {+ return err+ }+ return c.SpaceAccessResetter.RevokeBrowserSessionsTx(txCtx, tx, userID)+ }+ }var currentTokenHash []byteif revocationScope == revokeOtherSessions {- tokenHash := auth.HashToken(auth.GetToken(context))+ tokenHash := auth.HashToken(auth.GetToken(ctx))currentTokenHash = tokenHash[:]}- revokedTokens, err := c.UserAuthRepo.InsertOrUpdateSRPAuthAndKeyAttr(context, userID, *req.UpdateAttributes, setup, shouldClearTokens, currentTokenHash, revocationScope == revokeAllSessions)+ revokedTokens, err := c.UserAuthRepo.InsertOrUpdateSRPAuthAndKeyAttr(ctx, userID, *req.UpdateAttributes, setup, shouldClearTokens, currentTokenHash, revocationScope == revokeAllSessions, authorize)if err != nil {return nil, stacktrace.Propagate(err, "failed to add entry in srp auth")}@@ -122,7 +134,7 @@ func (c *UserController) updateSrpAndKeyAttributes(context *gin.Context,if shouldClearTokens {authsession.MarkRevoked(c.Cache, revokedTokens)if c.SpaceAccessResetter != nil {- if sweepErr := c.SpaceAccessResetter.RevokeBrowserSessions(context, userID); sweepErr != nil {+ if sweepErr := c.SpaceAccessResetter.RevokeBrowserSessions(ctx, userID); sweepErr != nil {logrus.WithError(sweepErr).WithField("user_id", userID).Warn("failed to sweep space browser sessions after password update")}}diff --git a/server/pkg/controller/user/user.go b/server/pkg/controller/user/user.goindex 7c62def779..396c1a3ff2 100644--- a/server/pkg/controller/user/user.go+++ b/server/pkg/controller/user/user.go@@ -2,6 +2,7 @@ package userimport ("context"+ "database/sql""errors""fmt""github.com/ente/museum/pkg/controller/collections"@@ -34,6 +35,7 @@ import (type SpaceAccessResetter interface {ResetUserAccess(ctx context.Context, userID int64) errorRevokeBrowserSessions(ctx context.Context, userID int64) error+ RevokeBrowserSessionsTx(ctx context.Context, tx *sql.Tx, userID int64) error}type SpaceAccountDeletionAccessResetter interface {diff --git a/server/pkg/repo/emergency/recovery.go b/server/pkg/repo/emergency/recovery.goindex 991314a680..75359f0114 100644--- a/server/pkg/repo/emergency/recovery.go+++ b/server/pkg/repo/emergency/recovery.go@@ -34,10 +34,32 @@ func (r RecoverRow) CanRecover() error {return nil}-func (repo *Repository) InsertIntoRecovery(ctx *gin.Context, contact ente.ContactIdentifier, contactRow ContactRow) (bool, error) {+func (repo *Repository) InsertIntoRecovery(ctx context.Context, contact ente.ContactIdentifier) (bool, *ContactRow, error) {+ tx, err := repo.DB.BeginTx(ctx, nil)+ if err != nil {+ return false, nil, stacktrace.Propagate(err, "failed to start emergency recovery")+ }+ defer tx.Rollback()+ if err = lockOwnerForUpdate(ctx, tx, contact.UserID); err != nil {+ return false, nil, err+ }+ contactRow, err := getContactForUpdate(ctx, tx, contact.UserID, contact.EmergencyContactID)+ if err != nil {+ return false, nil, err+ }+ if contactRow.State != ente.ContactAccepted {+ return false, nil, stacktrace.Propagate(sql.ErrNoRows, "active emergency contact not found")+ }if contactRow.NoticePeriodInHrs <= 24 {logrus.Warn("notice period is less than 24 hours")- return false, ente.NewBadRequestWithMessage("notice period should be greater than 24 hours")+ return false, nil, ente.NewBadRequestWithMessage("notice period should be greater than 24 hours")+ }+ activeSessions, err := getActiveSessionsForUpdate(ctx, tx, contact.UserID, contact.EmergencyContactID)+ if err != nil {+ return false, nil, err+ }+ if len(activeSessions) > 0 {+ return false, contactRow, nil}waitTime := time.MicrosecondsAfterHours(contactRow.NoticePeriodInHrs)nextReminder := time.MicrosecondsAfterHours(24 * 7)@@ -45,13 +67,15 @@ func (repo *Repository) InsertIntoRecovery(ctx *gin.Context, contact ente.Contaclogrus.Warn("initial reminder is greater than wait time")nextReminder = time.MicrosecondsAfterHours(24 * 1)}- result, err := repo.DB.ExecContext(ctx, `INSERT INTO emergency_recovery (id,user_id, emergency_contact_id, status, wait_till, next_reminder_at) VALUES ($1, $2, $3, $4, $5, $6) on conflict DO NOTHING`,+ _, err = tx.ExecContext(ctx, `INSERT INTO emergency_recovery (id,user_id, emergency_contact_id, status, wait_till, next_reminder_at) VALUES ($1, $2, $3, $4, $5, $6)`,uuid.New(), contact.UserID, contact.EmergencyContactID, ente.RecoveryStatusWaiting, waitTime, nextReminder)if err != nil {- return false, stacktrace.Propagate(err, "")+ return false, nil, stacktrace.Propagate(err, "")+ }+ if err = tx.Commit(); err != nil {+ return false, nil, stacktrace.Propagate(err, "failed to commit emergency recovery")}- count, _ := result.RowsAffected()- return count > 0, nil+ return true, contactRow, nil}func (repo *Repository) GetActiveRecoverySessions(ctx *gin.Context, userID int64) ([]*RecoverRow, error) {@@ -134,21 +158,69 @@ func (repo *Repository) UpdateRecoveryStatusForID(ctx context.Context, sessionID}func (repo *Repository) UpdateRecoveryStatusForSession(ctx context.Context, sessionID uuid.UUID, userID, emergencyContactID int64, status ente.RecoveryStatus) (bool, error) {+ tx, err := repo.DB.BeginTx(ctx, nil)+ if err != nil {+ return false, stacktrace.Propagate(err, "failed to start recovery status update")+ }+ defer tx.Rollback()+ if err = lockOwnerForUpdate(ctx, tx, userID); err != nil {+ return false, err+ }+ if _, err = getContactForUpdate(ctx, tx, userID, emergencyContactID); err != nil {+ return false, err+ }+ session, err := getRecoveryForUpdate(ctx, tx, sessionID)+ if err != nil {+ if err == sql.ErrNoRows {+ return false, nil+ }+ return false, err+ }+ if session.UserID != userID || session.EmergencyContactID != emergencyContactID {+ return false, nil+ }validPrevStatus := validPreviousStatus(status)var result sql.Result- var err errorif status == ente.RecoveryStatusReady {- result, err = repo.DB.ExecContext(ctx, `UPDATE emergency_recovery SET status=$1, wait_till=$2 WHERE id=$3 and user_id=$4 and emergency_contact_id=$5 and status = ANY($6)`,+ result, err = tx.ExecContext(ctx, `UPDATE emergency_recovery SET status=$1, wait_till=$2 WHERE id=$3 and user_id=$4 and emergency_contact_id=$5 and status = ANY($6)`,status, time.Microseconds(), sessionID, userID, emergencyContactID, pq.Array(validPrevStatus))} else {- result, err = repo.DB.ExecContext(ctx, `UPDATE emergency_recovery SET status=$1 WHERE id=$2 and user_id=$3 and emergency_contact_id=$4 and status = ANY($5)`,+ result, err = tx.ExecContext(ctx, `UPDATE emergency_recovery SET status=$1 WHERE id=$2 and user_id=$3 and emergency_contact_id=$4 and status = ANY($5)`,status, sessionID, userID, emergencyContactID, pq.Array(validPrevStatus))}if err != nil {return false, stacktrace.Propagate(err, "")}rows, _ := result.RowsAffected()- return rows > 0, nil+ if rows == 0 {+ return false, nil+ }+ if err = tx.Commit(); err != nil {+ return false, stacktrace.Propagate(err, "failed to commit recovery status update")+ }+ return true, nil+}++func (repo *Repository) CompleteRecovery(ctx context.Context, tx *sql.Tx, sessionID uuid.UUID, userID, emergencyContactID int64) error {+ contact, err := getContactForUpdate(ctx, tx, userID, emergencyContactID)+ if err != nil {+ return err+ }+ if contact.State != ente.ContactAccepted || contact.EncryptedKey == nil {+ return stacktrace.Propagate(ente.ErrNotFound, "active emergency contact not found")+ }+ session, err := getRecoveryForUpdate(ctx, tx, sessionID)+ if err != nil {+ return err+ }+ if session.UserID != userID || session.EmergencyContactID != emergencyContactID {+ return stacktrace.Propagate(ente.ErrPermissionDenied, "recovery session does not match contact")+ }+ if err = session.CanRecover(); err != nil {+ return stacktrace.Propagate(ente.NewBadRequestWithMessage(err.Error()), "")+ }+ _, err = tx.ExecContext(ctx, `UPDATE emergency_recovery SET status=$1 WHERE id=$2`, ente.RecoveryStatusRecovered, sessionID)+ return stacktrace.Propagate(err, "failed to complete emergency recovery")}func (repo *Repository) GetRecoverRowByID(ctx context.Context, sessionID uuid.UUID) (*RecoverRow, error) {@@ -161,6 +233,36 @@ func (repo *Repository) GetRecoverRowByID(ctx context.Context, sessionID uuid.UUreturn &row, nil}+func getActiveSessionsForUpdate(ctx context.Context, tx *sql.Tx, userID, emergencyContactID int64) ([]*RecoverRow, error) {+ rows, err := tx.QueryContext(ctx, `SELECT id, user_id, emergency_contact_id, status, wait_till, next_reminder_at, created_at+ FROM emergency_recovery WHERE user_id=$1 AND emergency_contact_id=$2 AND status=ANY($3) ORDER BY id FOR UPDATE`,+ userID, emergencyContactID, pq.Array([]ente.RecoveryStatus{ente.RecoveryStatusWaiting, ente.RecoveryStatusReady}))+ if err != nil {+ return nil, stacktrace.Propagate(err, "failed to lock active recovery sessions")+ }+ defer rows.Close()+ var sessions []*RecoverRow+ for rows.Next() {+ var session RecoverRow+ if err := rows.Scan(&session.ID, &session.UserID, &session.EmergencyContactID, &session.Status, &session.WaitTill, &session.NextReminderAt, &session.CreatedAt); err != nil {+ return nil, stacktrace.Propagate(err, "failed to scan active recovery session")+ }+ sessions = append(sessions, &session)+ }+ return sessions, stacktrace.Propagate(rows.Err(), "failed to read active recovery sessions")+}++func getRecoveryForUpdate(ctx context.Context, tx *sql.Tx, sessionID uuid.UUID) (*RecoverRow, error) {+ var session RecoverRow+ err := tx.QueryRowContext(ctx, `SELECT id, user_id, emergency_contact_id, status, wait_till, next_reminder_at, created_at+ FROM emergency_recovery WHERE id=$1 FOR UPDATE`, sessionID).+ Scan(&session.ID, &session.UserID, &session.EmergencyContactID, &session.Status, &session.WaitTill, &session.NextReminderAt, &session.CreatedAt)+ if err != nil {+ return nil, err+ }+ return &session, nil+}+func (repo *Repository) UpdateRecoveryStatus(ctx context.Context, userID, emergencyContactID int64, status ente.RecoveryStatus) error {validPrevStatus := validPreviousStatus(status)_, err := repo.DB.ExecContext(ctx, `UPDATE emergency_recovery SET status=$1 WHERE user_id =$2 and emergency_contact_id =$3 and status = ANY($4)`, status, userID, emergencyContactID, pq.Array(validPrevStatus))diff --git a/server/pkg/repo/emergency/repository.go b/server/pkg/repo/emergency/repository.goindex fa08b65e98..3e93c38df9 100644--- a/server/pkg/repo/emergency/repository.go+++ b/server/pkg/repo/emergency/repository.go@@ -97,44 +97,118 @@ func (r *Repository) GetActiveEmergencyContact(ctx context.Context, userID int64func (r *Repository) UpdateState(ctx context.Context,userID int64,emergencyContactID int64,- newState ente.ContactState) (bool, error) {- allowedPreviousStates := getValidPreviousState(newState)- var res sql.Result- var err error+ newState ente.ContactState) (bool, []*RecoverRow, error) {+ tx, err := r.DB.BeginTx(ctx, nil)+ if err != nil {+ return false, nil, stacktrace.Propagate(err, "failed to start emergency contact update")+ }+ defer tx.Rollback()+ if err = lockOwnerForUpdate(ctx, tx, userID); err != nil {+ return false, nil, err+ }+ contact, err := getContactForUpdate(ctx, tx, userID, emergencyContactID)+ if err == sql.ErrNoRows {+ return false, nil, nil+ }+ if err != nil {+ return false, nil, err+ }+ validState := false+ for _, state := range getValidPreviousState(newState) {+ if contact.State == state {+ validState = true+ break+ }+ }+ if !validState {+ return false, nil, nil+ }++ var cancelled []*RecoverRow+ if newState == ente.ContactDenied || newState == ente.ContactLeft || newState == ente.UserRevokedContact {+ cancelled, err = getActiveSessionsForUpdate(ctx, tx, userID, emergencyContactID)+ if err != nil {+ return false, nil, err+ }+ if len(cancelled) > 0 {+ status := ente.RecoveryStatusStopped+ if newState == ente.UserRevokedContact {+ status = ente.RecoveryStatusRejected+ }+ if _, err = tx.ExecContext(ctx, `UPDATE emergency_recovery SET status=$1 WHERE user_id=$2 AND emergency_contact_id=$3 AND status = ANY($4)`,+ status, userID, emergencyContactID, pq.Array([]ente.RecoveryStatus{ente.RecoveryStatusWaiting, ente.RecoveryStatusReady})); err != nil {+ return false, nil, stacktrace.Propagate(err, "failed to cancel emergency recovery")+ }+ }+ }+if newState == ente.ContactAccepted || newState == ente.UserInvitedContact {- res, err = r.DB.ExecContext(ctx, `UPDATE emergency_contact SET state=$1 WHERE user_id=$2 and emergency_contact_id=$3 and state = ANY($4)`,- newState, userID, emergencyContactID, pq.Array(allowedPreviousStates))+ _, err = tx.ExecContext(ctx, `UPDATE emergency_contact SET state=$1 WHERE user_id=$2 and emergency_contact_id=$3`,+ newState, userID, emergencyContactID)} else {- res, err = r.DB.ExecContext(ctx, `UPDATE emergency_contact SET state=$1, encrypted_key = NULL WHERE user_id=$2 and emergency_contact_id=$3 and state = ANY($4)`,- newState, userID, emergencyContactID, pq.Array(allowedPreviousStates))+ _, err = tx.ExecContext(ctx, `UPDATE emergency_contact SET state=$1, encrypted_key = NULL WHERE user_id=$2 and emergency_contact_id=$3`,+ newState, userID, emergencyContactID)}if err != nil {- return false, stacktrace.Propagate(err, "")+ return false, nil, stacktrace.Propagate(err, "")}- count, err2 := res.RowsAffected()- if count > 1 {- panic("invalid state, only one row should be updated")+ if err = tx.Commit(); err != nil {+ return false, nil, stacktrace.Propagate(err, "failed to commit emergency contact update")}- return count > 0, stacktrace.Propagate(err2, "")+ return true, cancelled, nil}func (r *Repository) UpdateRecoveryNotice(ctx context.Context,userID int64,emergencyContactID int64,noticePeriodInHrs int) error {- res, err := r.DB.ExecContext(ctx, `UPDATE emergency_contact SET notice_period_in_hrs=$1 WHERE user_id=$2 and emergency_contact_id=$3 and state = ANY($4)`,- noticePeriodInHrs, userID, emergencyContactID, pq.Array([]ente.ContactState{ente.UserInvitedContact, ente.ContactAccepted}))+ tx, err := r.DB.BeginTx(ctx, nil)if err != nil {- return stacktrace.Propagate(err, "failed to update notice period")+ return stacktrace.Propagate(err, "failed to start recovery notice update")+ }+ defer tx.Rollback()+ if err = lockOwnerForUpdate(ctx, tx, userID); err != nil {+ return err+ }+ contact, err := getContactForUpdate(ctx, tx, userID, emergencyContactID)+ if err != nil && err != sql.ErrNoRows {+ return err}- count, err := res.RowsAffected()+ activeSessions, err := getActiveSessionsForUpdate(ctx, tx, userID, emergencyContactID)if err != nil {- return stacktrace.Propagate(err, "failed to get rows affected")+ return err}- if count == 0 {+ if len(activeSessions) > 0 {+ return stacktrace.Propagate(&ente.ErrActiveRecoverySession, "")+ }+ if contact == nil || contact.State != ente.UserInvitedContact && contact.State != ente.ContactAccepted {return ente.NewBadRequestWithMessage("emergency contact not found or not in valid state")}- return nil+ _, err = tx.ExecContext(ctx, `UPDATE emergency_contact SET notice_period_in_hrs=$1 WHERE user_id=$2 and emergency_contact_id=$3`,+ noticePeriodInHrs, userID, emergencyContactID)+ if err != nil {+ return stacktrace.Propagate(err, "failed to update notice period")+ }+ return stacktrace.Propagate(tx.Commit(), "failed to commit recovery notice update")+}++func lockOwnerForUpdate(ctx context.Context, tx *sql.Tx, userID int64) error {+ var lockedUserID int64+ err := tx.QueryRowContext(ctx, `SELECT user_id FROM users WHERE user_id=$1 FOR NO KEY UPDATE`, userID).Scan(&lockedUserID)+ return stacktrace.Propagate(err, "failed to lock recovery owner")+}++func getContactForUpdate(ctx context.Context, tx *sql.Tx, userID, emergencyContactID int64) (*ContactRow, error) {+ row := tx.QueryRowContext(ctx, `SELECT user_id, emergency_contact_id, state, notice_period_in_hrs, encrypted_key+ FROM emergency_contact WHERE user_id=$1 AND emergency_contact_id=$2 FOR UPDATE`, userID, emergencyContactID)+ var contact ContactRow+ if err := row.Scan(&contact.UserID, &contact.EmergencyContactID, &contact.State, &contact.NoticePeriodInHrs, &contact.EncryptedKey); err != nil {+ if err == sql.ErrNoRows {+ return nil, err+ }+ return nil, stacktrace.Propagate(err, "failed to lock emergency contact")+ }+ return &contact, nil}func getValidPreviousState(cs ente.ContactState) []ente.ContactState {diff --git a/server/pkg/repo/legacy_kit/repository.go b/server/pkg/repo/legacy_kit/repository.goindex 22c2789365..5aa7b715a0 100644--- a/server/pkg/repo/legacy_kit/repository.go+++ b/server/pkg/repo/legacy_kit/repository.go@@ -224,6 +224,16 @@ func (r *Repository) OpenOrResumeRecovery(}defer tx.Rollback()+ var userID int64+ if err := tx.QueryRowContext(ctx, `SELECT user_id FROM legacy_kit WHERE id=$1`, kitID).Scan(&userID); err != nil {+ if err == sql.ErrNoRows {+ return nil, nil, "", false, stacktrace.Propagate(ente.ErrNotFound, "legacy kit not found")+ }+ return nil, nil, "", false, stacktrace.Propagate(err, "failed to read legacy kit owner")+ }+ if err := lockUserRow(ctx, tx, userID); err != nil {+ return nil, nil, "", false, err+ }kit, err := getKitByIDForUpdate(ctx, tx, kitID)if err != nil {if err == sql.ErrNoRows {@@ -393,22 +403,6 @@ func hashChallenge(challenge string) string {return base64.RawURLEncoding.EncodeToString(sum[:])}-func (r *Repository) UpdateSessionStatus(ctx context.Context, sessionID uuid.UUID, status ente.LegacyKitRecoveryStatus) (bool, error) {- result, err := r.DB.ExecContext(ctx, `- UPDATE legacy_kit_recovery_session SET status = $1- WHERE id = $2 AND status IN ($3, $4)`,- status, sessionID, ente.LegacyKitRecoveryStatusWaiting, ente.LegacyKitRecoveryStatusReady,- )- if err != nil {- return false, stacktrace.Propagate(err, "failed to update legacy kit session status")- }- rows, err := result.RowsAffected()- if err != nil {- return false, stacktrace.Propagate(err, "failed to inspect legacy kit session update")- }- return rows > 0, nil-}-func (r *Repository) UpdateRecoveryNotice(ctx context.Context, userID int64, kitID uuid.UUID, noticePeriodHrs int32) (bool, error) {tx, err := r.DB.BeginTx(ctx, nil)if err != nil {@@ -458,6 +452,9 @@ func (r *Repository) BlockActiveSessionForKit(ctx context.Context, kitID uuid.UU}defer tx.Rollback()+ if err := lockUserRow(ctx, tx, userID); err != nil {+ return false, err+ }if _, err := getKitForOwnerByIDForUpdate(ctx, tx, userID, kitID); err != nil {if err == sql.ErrNoRows {return false, nil@@ -474,6 +471,38 @@ func (r *Repository) BlockActiveSessionForKit(ctx context.Context, kitID uuid.UUreturn updated, nil}+func (r *Repository) CompleteRecovery(+ ctx context.Context,+ tx *sql.Tx,+ sessionID, kitID uuid.UUID,+ userID int64,+ sessionToken string,+) error {+ kit, err := getKitByIDForUpdate(ctx, tx, kitID)+ if err != nil {+ return err+ }+ if kit.IsDeleted || kit.UserID != userID {+ return stacktrace.Propagate(ente.ErrNotFound, "legacy kit not found")+ }+ session, err := getSessionByIDAndTokenForUpdate(ctx, tx, sessionID, sessionToken)+ if err != nil {+ if err == sql.ErrNoRows {+ return stacktrace.Propagate(ente.ErrNotFound, "legacy kit recovery session not found")+ }+ return err+ }+ if session.KitID != kitID || session.UserID != userID {+ return stacktrace.Propagate(ente.ErrNotFound, "legacy kit recovery session not found")+ }+ if session.Status != ente.LegacyKitRecoveryStatusReady {+ return stacktrace.Propagate(ente.NewBadRequestWithMessage("legacy kit recovery is not ready"), "")+ }+ _, err = tx.ExecContext(ctx, `UPDATE legacy_kit_recovery_session SET status=$1 WHERE id=$2`,+ ente.LegacyKitRecoveryStatusRecovered, sessionID)+ return stacktrace.Propagate(err, "failed to complete legacy kit recovery")+}+func nullableInt64(value sql.NullInt64) any {if value.Valid {return value.Int64@@ -534,7 +563,7 @@ func insertKit(ctx context.Context, exec execer, userID int64, req ente.CreateLefunc lockUserRow(ctx context.Context, tx *sql.Tx, userID int64) error {var lockedUserID int64- err := tx.QueryRowContext(ctx, `SELECT user_id FROM users WHERE user_id = $1 FOR UPDATE`, userID).Scan(&lockedUserID)+ err := tx.QueryRowContext(ctx, `SELECT user_id FROM users WHERE user_id = $1 FOR NO KEY UPDATE`, userID).Scan(&lockedUserID)if err != nil {if err == sql.ErrNoRows {return stacktrace.Propagate(ente.ErrNotFound, "legacy kit owner not found")diff --git a/server/pkg/repo/srp.go b/server/pkg/repo/srp.goindex 29f0ed77f2..2d74d232be 100644--- a/server/pkg/repo/srp.go+++ b/server/pkg/repo/srp.go@@ -11,6 +11,8 @@ import (log "github.com/sirupsen/logrus")+type PasswordUpdateAuthorization func(context.Context, *sql.Tx) error+func (repo *UserAuthRepository) AddSRPSession(srpUserID uuid.UUID, serverKey string, srpA string) (uuid.UUID, error) {id := uuid.New()_, err := repo.DB.Exec(`@@ -117,7 +119,7 @@ func (repo *UserAuthRepository) InsertSRPAuth(ctx context.Context, userID int64,}func (repo *UserAuthRepository) InsertOrUpdateSRPAuthAndKeyAttr(ctx context.Context, userID int64, updateKeyAttr ente.UpdateKeysRequest,- setup *ente.SRPSetupEntity, clearTokens bool, currentTokenHash []byte, disableSecondFactors bool,+ setup *ente.SRPSetupEntity, clearTokens bool, currentTokenHash []byte, disableSecondFactors bool, authorize PasswordUpdateAuthorization,) ([]RevokedToken, error) {tx, err := repo.DB.BeginTx(ctx, nil)if err != nil {@@ -136,6 +138,11 @@ func (repo *UserAuthRepository) InsertOrUpdateSRPAuthAndKeyAttr(ctx context.Contreturn nil, stacktrace.Propagate(err, "")}}+ if authorize != nil {+ if err = authorize(ctx, tx); err != nil {+ return nil, err+ }+ }if disableSecondFactors {if _, err = tx.ExecContext(ctx, `UPDATE users SET is_two_factor_enabled = false WHERE user_id = $1`, userID); err != nil {return nil, stacktrace.Propagate(err, "")diff --git a/server/space/repo/sessions.go b/server/space/repo/sessions.goindex c3bba63773..5d0228b306 100644--- a/server/space/repo/sessions.go+++ b/server/space/repo/sessions.go@@ -2,6 +2,7 @@ package repoimport ("context"+ "database/sql""github.com/ente/museum/ente"timeutil "github.com/ente/museum/pkg/utils/time"@@ -104,7 +105,19 @@ func (r *SessionsRepository) DeleteBrowserSessionsForToken(ctx context.Context,}func (r *SessionsRepository) DeleteBrowserSessionsForUser(ctx context.Context, userID int64) error {- _, err := r.DB.ExecContext(ctx, `DELETE FROM space_browser_sessions WHERE user_id = $1`, userID)+ return deleteBrowserSessionsForUser(ctx, r.DB, userID)+}++func (m *Module) RevokeBrowserSessionsTx(ctx context.Context, tx *sql.Tx, userID int64) error {+ return deleteBrowserSessionsForUser(ctx, tx, userID)+}++type browserSessionExecer interface {+ ExecContext(ctx context.Context, query string, args ...any) (sql.Result, error)+}++func deleteBrowserSessionsForUser(ctx context.Context, execer browserSessionExecer, userID int64) error {+ _, err := execer.ExecContext(ctx, `DELETE FROM space_browser_sessions WHERE user_id = $1`, userID)return stacktrace.Propagate(err, "")}