Skip to content

armgit / ente

Public Imported from GitHub
0

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

Make authentication state changes atomic

Neeraj Gupta24b17f5c6dab
diff --git a/server/cmd/museum/main.go b/server/cmd/museum/main.go
index 8eb002662e..27628d5398 100644
--- a/server/cmd/museum/main.go
+++ b/server/cmd/museum/main.go
@@ -482,10 +482,9 @@ func main() {
UserRepo: userRepo,
}
legacyKitController := &legacykitctrl.Controller{
- Repo: legacyKitRepository,
- UserRepo: userRepo,
- UserCtrl: userController,
- PasskeyController: passkeyCtrl,
+ Repo: legacyKitRepository,
+ UserRepo: userRepo,
+ UserCtrl: userController,
}
authMiddleware := middleware.AuthMiddleware{UserAuthRepo: userAuthRepo, Cache: authCache, UserController: userController}
@@ -673,12 +672,11 @@ func main() {
storageAPI.GET("/comments-reactions/updated-at", socialHandler.LatestUpdates)
emergencyCtrl := &emergency.Controller{
- Repo: emergencyContactRepository,
- UserRepo: userRepo,
- UserLookup: userLookupController,
- UserCtrl: userController,
- PasskeyController: passkeyCtrl,
- LockCtrl: lockController,
+ Repo: emergencyContactRepository,
+ UserRepo: userRepo,
+ UserLookup: userLookupController,
+ UserCtrl: userController,
+ LockCtrl: lockController,
}
userHandler := &api.UserHandler{
UserController: userController,
diff --git a/server/pkg/api/user.go b/server/pkg/api/user.go
index 31ebf00974..8ba8cac22a 100644
--- a/server/pkg/api/user.go
+++ b/server/pkg/api/user.go
@@ -13,6 +13,7 @@ import (
"github.com/ente/museum/ente"
"github.com/ente/museum/ente/jwt"
"github.com/ente/museum/pkg/controller/user"
+ "github.com/ente/museum/pkg/repo"
"github.com/ente/museum/pkg/utils/auth"
emailUtil "github.com/ente/museum/pkg/utils/email"
"github.com/ente/museum/pkg/utils/handler"
@@ -348,18 +349,12 @@ func (h *UserHandler) FinishPasskeyAuthenticationCeremony(c *gin.Context) {
return
}
- response, err := h.UserController.GetKeyAttributeAndToken(c, userID)
+ response, err := h.UserController.GetKeyAttributeAndToken(c, userID, request.SessionID, repo.PasskeyPendingLogin, false, true)
if err != nil {
handler.Error(c, stacktrace.Propagate(err, ""))
return
}
- err = h.UserController.PasskeyRepo.StoreTokenData(request.SessionID, response)
- if err != nil {
- handler.Error(c, stacktrace.Propagate(err, "failed to store token data"))
- return
- }
-
c.JSON(http.StatusOK, response)
}
@@ -379,7 +374,7 @@ func (h *UserHandler) GetTokenForPasskeySession(c *gin.Context) {
func (h *UserHandler) IsPasskeyRecoveryEnabled(c *gin.Context) {
userID := auth.GetUserID(c.Request.Header)
- response, err := h.UserController.GetKeyAttributeAndToken(c, userID)
+ response, err := h.UserController.GetKeyAttributeAndToken(c, userID, "", repo.NoPendingLogin, false, false)
if err != nil {
handler.Error(c, stacktrace.Propagate(err, ""))
return
diff --git a/server/pkg/controller/emergency/controller.go b/server/pkg/controller/emergency/controller.go
index 484a9b0c7c..d406fca942 100644
--- a/server/pkg/controller/emergency/controller.go
+++ b/server/pkg/controller/emergency/controller.go
@@ -19,7 +19,6 @@ type Controller struct {
UserRepo *repo.UserRepository
UserLookup controller.UserLookup
UserCtrl *user.UserController
- PasskeyController *controller.PasskeyController
LockCtrl *lock.LockController
isReminderCronRunning bool
}
diff --git a/server/pkg/controller/emergency/recovery.go b/server/pkg/controller/emergency/recovery.go
index 5ec47aa5f9..67c273cbfe 100644
--- a/server/pkg/controller/emergency/recovery.go
+++ b/server/pkg/controller/emergency/recovery.go
@@ -55,15 +55,6 @@ func (c *Controller) ChangePassword(ctx *gin.Context, userID int64, request ente
if err != nil {
return nil, err
}
- if err := request.UpdateSrp.Validate(); err != nil {
- return nil, stacktrace.Propagate(err, "invalid request")
- }
- if disableErr := c.UserCtrl.DisableTwoFactor(contact.UserID); disableErr != nil {
- return nil, stacktrace.Propagate(disableErr, "failed to disable 2fa")
- }
- if disableErr := c.PasskeyController.RemovePasskey2FA(contact.UserID); disableErr != nil {
- return nil, stacktrace.Propagate(disableErr, "failed to disable passkey")
- }
logOutAllSessions := request.UpdateSrp.LogOutOtherDevices == nil || *request.UpdateSrp.LogOutOtherDevices
resp, err := c.UserCtrl.RecoverSrpAndKeyAttributes(ctx, contact.UserID, request.UpdateSrp, logOutAllSessions)
if err != nil {
diff --git a/server/pkg/controller/legacy_kit/controller.go b/server/pkg/controller/legacy_kit/controller.go
index dc5b62da4e..3866c7254c 100644
--- a/server/pkg/controller/legacy_kit/controller.go
+++ b/server/pkg/controller/legacy_kit/controller.go
@@ -7,7 +7,6 @@ import (
"fmt"
"strings"
- ctrl "github.com/ente/museum/pkg/controller"
"github.com/ente/museum/pkg/controller/user"
"github.com/ente/museum/pkg/repo"
legacykitrepo "github.com/ente/museum/pkg/repo/legacy_kit"
@@ -36,10 +35,9 @@ const (
)
type Controller struct {
- Repo *legacykitrepo.Repository
- UserRepo *repo.UserRepository
- UserCtrl *user.UserController
- PasskeyController *ctrl.PasskeyController
+ Repo *legacykitrepo.Repository
+ UserRepo *repo.UserRepository
+ UserCtrl *user.UserController
}
func (c *Controller) CreateKit(ctx *gin.Context, userID int64, req ente.CreateLegacyKitRequest) (*ente.LegacyKit, error) {
@@ -288,19 +286,6 @@ func (c *Controller) ChangePassword(ctx *gin.Context, req ente.LegacyKitRecovery
if session.Status != ente.LegacyKitRecoveryStatusReady {
return nil, stacktrace.Propagate(ente.NewBadRequestWithMessage("legacy kit recovery is not ready"), "")
}
- if err := req.UpdateSrpAndKeysRequest.Validate(); err != nil {
- return nil, stacktrace.Propagate(err, "invalid request")
- }
- // Known and accepted for the current recovery flow: once a legacy-kit session
- // is READY, we clear existing second-factor requirements before applying the
- // recovered password update, so an old TOTP/passkey enrollment does not block
- // the beneficiary from completing takeover.
- if err := c.UserCtrl.DisableTwoFactor(session.UserID); err != nil {
- return nil, stacktrace.Propagate(err, "failed to disable two-factor")
- }
- if err := c.PasskeyController.RemovePasskey2FA(session.UserID); err != nil {
- return nil, stacktrace.Propagate(err, "failed to disable passkeys")
- }
logOutAllSessions := req.UpdateSrpAndKeysRequest.LogOutOtherDevices == nil || *req.UpdateSrpAndKeysRequest.LogOutOtherDevices
resp, err := c.UserCtrl.RecoverSrpAndKeyAttributes(ctx, session.UserID, req.UpdateSrpAndKeysRequest, logOutAllSessions)
if err != nil {
diff --git a/server/pkg/controller/user/passkey.go b/server/pkg/controller/user/passkey.go
index e89c1e4cff..5c394e3da1 100644
--- a/server/pkg/controller/user/passkey.go
+++ b/server/pkg/controller/user/passkey.go
@@ -2,6 +2,7 @@ package user
import (
"github.com/ente/museum/ente"
+ "github.com/ente/museum/pkg/repo"
"github.com/ente/museum/pkg/utils/auth"
"github.com/ente/stacktrace"
"github.com/gin-gonic/gin"
@@ -52,7 +53,7 @@ func (c *UserController) SkipPasskeyVerification(context *gin.Context, req *ente
if !exists {
return nil, stacktrace.Propagate(ente.ErrPermissionDenied, "")
}
- response, err := c.GetKeyAttributeAndToken(context, userID)
+ response, err := c.GetKeyAttributeAndToken(context, userID, req.SessionID, repo.PasskeyPendingLogin, false, false)
if err != nil {
return nil, stacktrace.Propagate(err, "")
}
diff --git a/server/pkg/controller/user/srp.go b/server/pkg/controller/user/srp.go
index 8ecd3268de..4f532ecb6e 100644
--- a/server/pkg/controller/user/srp.go
+++ b/server/pkg/controller/user/srp.go
@@ -9,6 +9,7 @@ import (
"fmt"
"github.com/ente/go-srp"
"github.com/ente/museum/ente"
+ "github.com/ente/museum/pkg/controller/authsession"
"github.com/ente/museum/pkg/utils/auth"
emailUtil "github.com/ente/museum/pkg/utils/email"
"github.com/ente/stacktrace"
@@ -108,20 +109,18 @@ func (c *UserController) updateSrpAndKeyAttributes(context *gin.Context,
return nil, err
}
}
- err = c.UserAuthRepo.InsertOrUpdateSRPAuthAndKeyAttr(context, userID, *req.UpdateAttributes, setup)
+ var currentTokenHash []byte
+ if revocationScope == revokeOtherSessions {
+ tokenHash := auth.HashToken(auth.GetToken(context))
+ currentTokenHash = tokenHash[:]
+ }
+ revokedTokens, err := c.UserAuthRepo.InsertOrUpdateSRPAuthAndKeyAttr(context, userID, *req.UpdateAttributes, setup, shouldClearTokens, currentTokenHash, revocationScope == revokeAllSessions)
if err != nil {
return nil, stacktrace.Propagate(err, "failed to add entry in srp auth")
}
if shouldClearTokens {
- if revocationScope == revokeAllSessions {
- err = c.RemoveAllTokens(userID)
- } else {
- err = c.RemoveAllOtherTokens(userID, auth.GetToken(context))
- }
- if err != nil {
- return nil, err
- }
+ authsession.MarkRevoked(c.Cache, revokedTokens)
if c.SpaceAccessResetter != nil {
if sweepErr := c.SpaceAccessResetter.RevokeBrowserSessions(context, userID); sweepErr != nil {
logrus.WithError(sweepErr).WithField("user_id", userID).Warn("failed to sweep space browser sessions after password update")
@@ -206,7 +205,7 @@ func (c *UserController) VerifySRPSession(context *gin.Context, req ente.VerifyS
if err != nil {
return nil, err
}
- verResponse, err := c.onVerificationSuccess(context, user.Email, nil)
+ verResponse, err := c.onVerificationSuccess(context, user.Email, nil, srpAuthEntity)
if err != nil {
return nil, stacktrace.Propagate(err, "")
}
diff --git a/server/pkg/controller/user/twofactor.go b/server/pkg/controller/user/twofactor.go
index 459747b806..f7f23a9e94 100644
--- a/server/pkg/controller/user/twofactor.go
+++ b/server/pkg/controller/user/twofactor.go
@@ -5,12 +5,14 @@ import (
"crypto/sha256"
"encoding/base64"
"encoding/hex"
+ "encoding/json"
"fmt"
"image/png"
"github.com/ente/museum/pkg/utils/network"
"github.com/ente/museum/ente"
+ "github.com/ente/museum/pkg/repo"
"github.com/ente/museum/pkg/utils/auth"
"github.com/ente/museum/pkg/utils/crypto"
"github.com/ente/museum/pkg/utils/time"
@@ -142,11 +144,7 @@ func (c *UserController) VerifyTwoFactor(context *gin.Context, sessionID string,
go c.DiscordController.NotifyPotentialAbuse(msg)
return ente.TwoFactorAuthorizationResponse{}, stacktrace.Propagate(ente.ErrIncorrectTOTP, "OTP code has already been used")
}
- if err = c.TwoFactorRepo.ConsumeTwoFactorSession(sessionID); err != nil {
- return ente.TwoFactorAuthorizationResponse{}, stacktrace.Propagate(err, "")
- }
-
- response, err := c.GetKeyAttributeAndToken(context, userID)
+ response, err := c.GetKeyAttributeAndToken(context, userID, sessionID, repo.TOTPPendingLogin, false, false)
if err != nil {
return ente.TwoFactorAuthorizationResponse{}, stacktrace.Propagate(err, "")
}
@@ -188,21 +186,16 @@ func (c *UserController) RemoveTOTPTwoFactor(context *gin.Context, sessionID str
if !exists {
return nil, stacktrace.Propagate(ente.ErrPermissionDenied, "")
}
- if err = c.TwoFactorRepo.ConsumeTwoFactorSession(sessionID); err != nil {
- return nil, stacktrace.Propagate(err, "")
- }
- err = c.TwoFactorRepo.UpdateTwoFactorStatus(userID, false)
- if err != nil {
- return nil, stacktrace.Propagate(err, "")
- }
- response, err := c.GetKeyAttributeAndToken(context, userID)
+ response, err := c.GetKeyAttributeAndToken(context, userID, sessionID, repo.TOTPPendingLogin, true, false)
if err != nil {
return nil, stacktrace.Propagate(err, "")
}
return &response, nil
}
-func (c *UserController) GetKeyAttributeAndToken(context *gin.Context, userID int64) (ente.TwoFactorAuthorizationResponse, error) {
+func (c *UserController) GetKeyAttributeAndToken(context *gin.Context, userID int64, sessionID string,
+ session repo.PendingLoginSession, disableTwoFactor, publishForPolling bool,
+) (ente.TwoFactorAuthorizationResponse, error) {
keyAttributes, err := c.UserRepo.GetKeyAttributes(userID)
if err != nil {
return ente.TwoFactorAuthorizationResponse{}, stacktrace.Propagate(err, "")
@@ -212,14 +205,30 @@ func (c *UserController) GetKeyAttributeAndToken(context *gin.Context, userID in
if err != nil {
return ente.TwoFactorAuthorizationResponse{}, stacktrace.Propagate(err, "")
}
- err = c.AddTokenAndNotify(context, userID, auth.GetApp(context),
- token, network.GetClientIP(context), context.Request.UserAgent())
- if err != nil {
- return ente.TwoFactorAuthorizationResponse{}, stacktrace.Propagate(err, "")
- }
- return ente.TwoFactorAuthorizationResponse{
+ app := auth.GetApp(context)
+ ip := network.GetClientIP(context)
+ userAgent := context.Request.UserAgent()
+ response := ente.TwoFactorAuthorizationResponse{
ID: userID,
KeyAttributes: &keyAttributes,
EncryptedToken: encryptedToken,
- }, nil
+ }
+ if session == repo.NoPendingLogin {
+ err = c.AddTokenAndNotify(context, userID, app, token, ip, userAgent)
+ } else if err = c.ensureStorageWarningDeletionLoginAllowed(userID, app); err == nil {
+ var tokenData []byte
+ if publishForPolling {
+ tokenData, err = json.Marshal(response)
+ }
+ if err == nil {
+ err = c.UserAuthRepo.AddTokenForPendingLogin(context, userID, sessionID, session, disableTwoFactor, app, token, ip, userAgent, tokenData)
+ }
+ if err == nil {
+ err = c.notifyLogin(context, userID, app, ip, userAgent)
+ }
+ }
+ if err != nil {
+ return ente.TwoFactorAuthorizationResponse{}, stacktrace.Propagate(err, "")
+ }
+ return response, nil
}
diff --git a/server/pkg/controller/user/userauth.go b/server/pkg/controller/user/userauth.go
index ccecee7f20..23dccc9b6a 100644
--- a/server/pkg/controller/user/userauth.go
+++ b/server/pkg/controller/user/userauth.go
@@ -306,7 +306,7 @@ func (c *UserController) VerifyEmail(context *gin.Context, request ente.EmailVer
if err != nil {
return ente.EmailAuthorizationResponse{}, stacktrace.Propagate(err, "")
}
- return c.onVerificationSuccess(context, email, request.Source)
+ return c.onVerificationSuccess(context, email, request.Source, nil)
}
func (c *UserController) ChangeEmail(ctx *gin.Context, request ente.EmailVerificationRequest) error {
@@ -493,7 +493,10 @@ func (c *UserController) AddTokenAndNotify(ctx *gin.Context, userID int64, app e
if err != nil {
return stacktrace.Propagate(err, "failed to insert token")
}
+ return c.notifyLogin(ctx, userID, app, ip, userAgent)
+}
+func (c *UserController) notifyLogin(ctx *gin.Context, userID int64, app ente.App, ip string, userAgent string) error {
isEmailMFAEnabled, emailMFAErr := c.UserAuthRepo.IsEmailMFAEnabled(ctx, userID)
if emailMFAErr != nil {
log.WithError(emailMFAErr).WithField("user_id", userID).Warn("Failed to fetch email MFA status")
@@ -621,7 +624,7 @@ func emailOTT(app ente.App, to string, ott string, purpose string, mobile bool)
return nil
}
-func (c *UserController) onVerificationSuccess(context *gin.Context, email string, source *string) (ente.EmailAuthorizationResponse, error) {
+func (c *UserController) onVerificationSuccess(context *gin.Context, email string, source *string, srpAuth *ente.SRPAuthEntity) (ente.EmailAuthorizationResponse, error) {
isTwoFactorEnabled := false
app := auth.GetApp(context)
@@ -658,14 +661,12 @@ func (c *UserController) onVerificationSuccess(context *gin.Context, email strin
}
passKeySessionID = auth.GenerateURLSafeRandomString(PassKeySessionIDLength)
- err = c.PasskeyRepo.AddPasskeyTwoFactorSession(userID, passKeySessionID, time.Microseconds()+TwoFactorValidityDurationInMicroSeconds)
- if err != nil {
- return ente.EmailAuthorizationResponse{}, stacktrace.Propagate(err, "")
- }
}
if isTwoFactorEnabled {
twoFactorSessionID = auth.GenerateURLSafeRandomString(TwoFactorSessionIDLength)
- err = c.TwoFactorRepo.AddTwoFactorSession(userID, twoFactorSessionID, time.Microseconds()+TwoFactorValidityDurationInMicroSeconds)
+ }
+ if hasPasskeys || isTwoFactorEnabled {
+ err = c.UserAuthRepo.AddLoginResult(context, userID, srpAuth, app, "", "", "", passKeySessionID, twoFactorSessionID, time.Microseconds()+TwoFactorValidityDurationInMicroSeconds)
if err != nil {
return ente.EmailAuthorizationResponse{}, stacktrace.Propagate(err, "")
}
@@ -687,8 +688,8 @@ func (c *UserController) onVerificationSuccess(context *gin.Context, email strin
if err := c.ensureStorageWarningDeletionLoginAllowed(userID, app); err != nil {
return ente.EmailAuthorizationResponse{}, err
}
- err = c.UserAuthRepo.AddToken(userID, app, token,
- network.GetClientIP(context), context.Request.UserAgent())
+ err = c.UserAuthRepo.AddLoginResult(context, userID, srpAuth, app, token,
+ network.GetClientIP(context), context.Request.UserAgent(), "", "", 0)
if err != nil {
return ente.EmailAuthorizationResponse{}, stacktrace.Propagate(err, "")
}
@@ -702,8 +703,15 @@ func (c *UserController) onVerificationSuccess(context *gin.Context, email strin
if err != nil {
return ente.EmailAuthorizationResponse{}, stacktrace.Propagate(err, "")
}
- err = c.AddTokenAndNotify(context, userID, app, token,
- network.GetClientIP(context), context.Request.UserAgent())
+ ip := network.GetClientIP(context)
+ userAgent := context.Request.UserAgent()
+ if err = c.ensureStorageWarningDeletionLoginAllowed(userID, app); err != nil {
+ return ente.EmailAuthorizationResponse{}, err
+ }
+ err = c.UserAuthRepo.AddLoginResult(context, userID, srpAuth, app, token, ip, userAgent, "", "", 0)
+ if err == nil {
+ err = c.notifyLogin(context, userID, app, ip, userAgent)
+ }
if err != nil {
return ente.EmailAuthorizationResponse{}, stacktrace.Propagate(err, "")
}
diff --git a/server/pkg/repo/srp.go b/server/pkg/repo/srp.go
index bade14b375..2796128ae0 100644
--- a/server/pkg/repo/srp.go
+++ b/server/pkg/repo/srp.go
@@ -116,26 +116,72 @@ func (repo *UserAuthRepository) InsertSRPAuth(ctx context.Context, userID int64,
return stacktrace.Propagate(err, "")
}
-func (repo *UserAuthRepository) InsertOrUpdateSRPAuthAndKeyAttr(ctx context.Context, userID int64, updateKeyAttr ente.UpdateKeysRequest, setup *ente.SRPSetupEntity) error {
+func (repo *UserAuthRepository) InsertOrUpdateSRPAuthAndKeyAttr(ctx context.Context, userID int64, updateKeyAttr ente.UpdateKeysRequest,
+ setup *ente.SRPSetupEntity, clearTokens bool, currentTokenHash []byte, disableSecondFactors bool,
+) ([]RevokedToken, error) {
tx, err := repo.DB.BeginTx(ctx, nil)
if err != nil {
- return stacktrace.Propagate(err, "")
+ return nil, stacktrace.Propagate(err, "")
}
defer tx.Rollback()
+ if err = lockUserForLogin(ctx, tx, userID, nil); err != nil {
+ return nil, err
+ }
+ if len(currentTokenHash) != 0 {
+ var tokenUserID int64
+ if err = tx.QueryRowContext(ctx, `SELECT user_id FROM tokens WHERE user_id = $1 AND token_hash = $2 AND is_deleted = false`, userID, currentTokenHash).Scan(&tokenUserID); err != nil {
+ if err == sql.ErrNoRows {
+ return nil, stacktrace.Propagate(ente.ErrAuthenticationRequired, "token revoked during password update")
+ }
+ return nil, stacktrace.Propagate(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, "")
+ }
+ if _, err = tx.ExecContext(ctx, `UPDATE passkeys SET friendly_name = id::text, deleted_at = now_utc_micro_seconds() WHERE user_id = $1 AND deleted_at IS NULL`, userID); err != nil {
+ return nil, stacktrace.Propagate(err, "")
+ }
+ }
_, err = tx.ExecContext(ctx, `
INSERT INTO srp_auth(user_id, srp_user_id, salt, verifier) VALUES($1, $2, $3, $4)
ON CONFLICT (user_id) DO UPDATE SET
srp_user_id = EXCLUDED.srp_user_id, salt = EXCLUDED.salt, verifier = EXCLUDED.verifier`,
userID, setup.SRPUserID, setup.Salt, setup.Verifier)
if err != nil {
- return stacktrace.Propagate(err, "")
+ return nil, stacktrace.Propagate(err, "")
}
_, err = tx.ExecContext(ctx, `UPDATE key_attributes SET kek_salt = $1, encrypted_key = $2, key_decryption_nonce = $3, mem_limit = $4, ops_limit = $5 WHERE user_id = $6`,
updateKeyAttr.KEKSalt, updateKeyAttr.EncryptedKey, updateKeyAttr.KeyDecryptionNonce, updateKeyAttr.MemLimit, updateKeyAttr.OpsLimit, userID)
if err != nil {
- return stacktrace.Propagate(err, "")
+ return nil, stacktrace.Propagate(err, "")
+ }
+ _, err = tx.ExecContext(ctx, `
+ WITH deleted_two_factor_sessions AS (
+ DELETE FROM two_factor_sessions WHERE user_id = $1
+ )
+ DELETE FROM passkey_login_sessions WHERE user_id = $1 AND ($2 OR verified_at IS NULL)`, userID, clearTokens)
+ if err != nil {
+ return nil, stacktrace.Propagate(err, "")
+ }
+ var revokedTokens []RevokedToken
+ if clearTokens {
+ query := `UPDATE tokens SET is_deleted = true WHERE user_id = $1 AND is_deleted = false RETURNING app, token_hash`
+ args := []interface{}{userID}
+ if len(currentTokenHash) != 0 {
+ query = `UPDATE tokens SET is_deleted = true WHERE user_id = $1 AND token_hash <> $2 AND is_deleted = false RETURNING app, token_hash`
+ args = append(args, currentTokenHash)
+ }
+ revokedTokens, err = markTokensDeleted(tx, query, args...)
+ if err != nil {
+ return nil, err
+ }
+ }
+ if err = tx.Commit(); err != nil {
+ return nil, stacktrace.Propagate(err, "")
}
- return tx.Commit()
+ return revokedTokens, nil
}
func (repo *UserAuthRepository) GetSrpSessionEntity(ctx context.Context, sessionID uuid.UUID) (*ente.SRPSessionEntity, error) {
diff --git a/server/pkg/repo/userauth.go b/server/pkg/repo/userauth.go
index 050a96d39e..28111d7078 100644
--- a/server/pkg/repo/userauth.go
+++ b/server/pkg/repo/userauth.go
@@ -1,6 +1,7 @@
package repo
import (
+ "context"
"database/sql"
"github.com/ente/museum/ente"
@@ -8,6 +9,7 @@ import (
"github.com/ente/museum/pkg/utils/network"
"github.com/ente/museum/pkg/utils/time"
"github.com/ente/stacktrace"
+ "github.com/google/uuid"
"github.com/lib/pq"
)
@@ -20,6 +22,14 @@ type RevokedToken struct {
TokenHash []byte
}
+type PendingLoginSession int
+
+const (
+ NoPendingLogin PendingLoginSession = iota
+ TOTPPendingLogin
+ PasskeyPendingLogin
+)
+
func (repo *UserAuthRepository) AddOTT(emailHash string, app ente.App, ott string, expirationTime int64) error {
_, err := repo.DB.Exec(`INSERT INTO otts(email_hash, ott, creation_time, expiration_time, app)
VALUES($1, $2, $3, $4, $5)
@@ -164,6 +174,97 @@ func (repo *UserAuthRepository) AddToken(userID int64, app ente.App, token strin
return stacktrace.Propagate(err, "")
}
+func (repo *UserAuthRepository) AddLoginResult(ctx context.Context, userID int64, srpAuth *ente.SRPAuthEntity,
+ app ente.App, token, ip, userAgent, passkeySessionID, twoFactorSessionID string, expirationTime int64,
+) error {
+ tx, err := repo.DB.BeginTx(ctx, nil)
+ if err != nil {
+ return stacktrace.Propagate(err, "")
+ }
+ defer tx.Rollback()
+ if err = lockUserForLogin(ctx, tx, userID, srpAuth); err != nil {
+ return err
+ }
+ now := time.Microseconds()
+ if passkeySessionID != "" {
+ if _, err = tx.ExecContext(ctx, `INSERT INTO passkey_login_sessions(user_id, session_id, creation_time, expiration_time) VALUES($1, $2, $3, $4)`, userID, passkeySessionID, now, expirationTime); err != nil {
+ return stacktrace.Propagate(err, "")
+ }
+ }
+ if twoFactorSessionID != "" {
+ if _, err = tx.ExecContext(ctx, `INSERT INTO two_factor_sessions(user_id, session_id, creation_time, expiration_time) VALUES($1, $2, $3, $4)`, userID, twoFactorSessionID, now, expirationTime); err != nil {
+ return stacktrace.Propagate(err, "")
+ }
+ }
+ if token != "" {
+ tokenHash := auth.HashToken(token)
+ if _, err = tx.ExecContext(ctx, `INSERT INTO tokens(user_id, app, token_hash, creation_time, ip, user_agent) VALUES($1, $2, $3, $4, $5, $6)`, userID, app, tokenHash[:], now, ip, userAgent); err != nil {
+ return stacktrace.Propagate(err, "")
+ }
+ }
+ return stacktrace.Propagate(tx.Commit(), "")
+}
+
+func (repo *UserAuthRepository) AddTokenForPendingLogin(ctx context.Context, userID int64, sessionID string,
+ session PendingLoginSession, disableTwoFactor bool, app ente.App, token, ip, userAgent string, tokenData []byte,
+) error {
+ tx, err := repo.DB.BeginTx(ctx, nil)
+ if err != nil {
+ return stacktrace.Propagate(err, "")
+ }
+ defer tx.Rollback()
+ if err = lockUserForLogin(ctx, tx, userID, nil); err != nil {
+ return err
+ }
+ now := time.Microseconds()
+ sessionQuery := `DELETE FROM two_factor_sessions WHERE session_id = $1 AND user_id = $2 AND expiration_time > $3 RETURNING user_id`
+ sessionArgs := []interface{}{sessionID, userID, now}
+ if session == PasskeyPendingLogin {
+ sessionQuery = `DELETE FROM passkey_login_sessions WHERE session_id = $1 AND user_id = $2 AND expiration_time > $3 AND verified_at IS NULL RETURNING user_id`
+ if len(tokenData) != 0 {
+ sessionQuery = `UPDATE passkey_login_sessions SET token_data = $4, verified_at = $3 WHERE session_id = $1 AND user_id = $2 AND expiration_time > $3 AND verified_at IS NULL RETURNING user_id`
+ sessionArgs = append(sessionArgs, tokenData)
+ }
+ }
+ var sessionUserID int64
+ if err = tx.QueryRowContext(ctx, sessionQuery, sessionArgs...).Scan(&sessionUserID); err != nil {
+ return stacktrace.Propagate(err, "")
+ }
+ if disableTwoFactor {
+ if _, err = tx.ExecContext(ctx, `UPDATE users SET is_two_factor_enabled = false WHERE user_id = $1`, userID); err != nil {
+ return stacktrace.Propagate(err, "")
+ }
+ }
+ tokenHash := auth.HashToken(token)
+ if _, err = tx.ExecContext(ctx, `INSERT INTO tokens(user_id, app, token_hash, creation_time, ip, user_agent) VALUES($1, $2, $3, $4, $5, $6)`, userID, app, tokenHash[:], now, ip, userAgent); err != nil {
+ return stacktrace.Propagate(err, "")
+ }
+ return stacktrace.Propagate(tx.Commit(), "")
+}
+
+func lockUserForLogin(ctx context.Context, tx *sql.Tx, userID int64, srpAuth *ente.SRPAuthEntity) error {
+ var lockedUserID int64
+ if err := tx.QueryRowContext(ctx, `SELECT user_id FROM users WHERE user_id = $1 FOR NO KEY UPDATE`, userID).Scan(&lockedUserID); err != nil {
+ return stacktrace.Propagate(err, "")
+ }
+ if srpAuth == nil {
+ return nil
+ }
+ var currentSRPUserID uuid.UUID
+ var currentSRPSalt string
+ var currentSRPVerifier string
+ if err := tx.QueryRowContext(ctx, `SELECT srp_user_id, salt, verifier FROM srp_auth WHERE user_id = $1`, userID).Scan(&currentSRPUserID, &currentSRPSalt, &currentSRPVerifier); err != nil {
+ if err == sql.ErrNoRows {
+ return stacktrace.Propagate(ente.ErrInvalidPassword, "stale SRP login")
+ }
+ return stacktrace.Propagate(err, "")
+ }
+ if currentSRPUserID != srpAuth.SRPUserID || currentSRPSalt != srpAuth.Salt || currentSRPVerifier != srpAuth.Verifier {
+ return stacktrace.Propagate(ente.ErrInvalidPassword, "stale SRP login")
+ }
+ return nil
+}
+
func (repo *UserAuthRepository) GetUserIDWithTokenHash(tokenHash []byte, app ente.App) (int64, bool, error) {
row := repo.DB.QueryRow(`
SELECT
@@ -231,7 +332,15 @@ func (repo *UserAuthRepository) RemoveAllTokens(userID int64) ([]RevokedToken, e
}
func (repo *UserAuthRepository) markTokensDeleted(query string, args ...interface{}) ([]RevokedToken, error) {
- rows, err := repo.DB.Query(query, args...)
+ return markTokensDeleted(repo.DB, query, args...)
+}
+
+type rowsQueryer interface {
+ Query(query string, args ...any) (*sql.Rows, error)
+}
+
+func markTokensDeleted(queryer rowsQueryer, query string, args ...interface{}) ([]RevokedToken, error) {
+ rows, err := queryer.Query(query, args...)
if err != nil {
return nil, stacktrace.Propagate(err, "")
}
diff --git a/server/pkg/repo/userauth_test.go b/server/pkg/repo/userauth_test.go
index d8240335b4..27c7a7e63e 100644
--- a/server/pkg/repo/userauth_test.go
+++ b/server/pkg/repo/userauth_test.go
@@ -2,8 +2,10 @@ package repo
import (
"bytes"
+ "context"
"crypto/sha256"
"database/sql"
+ "errors"
"testing"
"github.com/ente/museum/ente"
@@ -119,3 +121,28 @@ func TestUserAuthRepositoryRemoveOTTReturnsWhetherRowWasConsumed(t *testing.T) {
t.Fatal("second remove should report that the ott was already consumed")
}
}
+
+func TestAddTokenForPendingLoginConsumesPasskeyRecoverySession(t *testing.T) {
+ testutil.WithServerRoot(t)
+
+ db := testutil.RequireTestDB(t)
+ testutil.ResetTables(t, db)
+ t.Cleanup(func() { testutil.ResetTables(t, db) })
+
+ userID := testutil.InsertUser(t, db, testutil.UserFixture{
+ Email: "[email protected]",
+ CreationTime: 1,
+ })
+ sessionID := "passkey-recovery-session"
+ if _, err := db.Exec(`INSERT INTO passkey_login_sessions(user_id, session_id, creation_time, expiration_time) VALUES($1, $2, $3, $4)`, userID, sessionID, 1, time.Microseconds()+1000000); err != nil {
+ t.Fatalf("failed to insert session: %v", err)
+ }
+
+ repo := &UserAuthRepository{DB: db}
+ if err := repo.AddTokenForPendingLogin(context.Background(), userID, sessionID, PasskeyPendingLogin, false, ente.Photos, "first-token", "", "", nil); err != nil {
+ t.Fatalf("first recovery failed: %v", err)
+ }
+ if err := repo.AddTokenForPendingLogin(context.Background(), userID, sessionID, PasskeyPendingLogin, false, ente.Photos, "second-token", "", "", nil); !errors.Is(err, sql.ErrNoRows) {
+ t.Fatalf("replayed recovery returned %v, want no rows", err)
+ }
+}