Skip to content

armgit / ente

Public Imported from GitHub
0

πŸ’š End-to-end encrypted cloud for everything.

Serialize account recovery updates

Neeraj Gupta52e6a2ffc8cd
diff --git a/server/pkg/controller/emergency/account_owner.go b/server/pkg/controller/emergency/account_owner.go
index 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, reques
return 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.go
index 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.go
index 67c273cbfe..15cd14f7a1 100644
--- a/server/pkg/controller/emergency/recovery.go
+++ b/server/pkg/controller/emergency/recovery.go
@@ -2,6 +2,7 @@ package emergency
import (
"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 ente
return 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.go
index 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.go
index 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_kit
import (
"context"
"crypto/rand"
+ "database/sql"
"encoding/base64"
"fmt"
"strings"
@@ -287,13 +288,13 @@ func (c *Controller) ChangePassword(ctx *gin.Context, req ente.LegacyKitRecovery
return 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.go
index 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 []byte
if 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.go
index 7c62def779..396c1a3ff2 100644
--- a/server/pkg/controller/user/user.go
+++ b/server/pkg/controller/user/user.go
@@ -2,6 +2,7 @@ package user
import (
"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) error
RevokeBrowserSessions(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.go
index 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.Contac
logrus.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 error
if 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.UU
return &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.go
index 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 int64
func (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.go
index 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.UU
return 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.CreateLe
func 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.go
index 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.Cont
return 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.go
index c3bba63773..5d0228b306 100644
--- a/server/space/repo/sessions.go
+++ b/server/space/repo/sessions.go
@@ -2,6 +2,7 @@ package repo
import (
"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, "")
}