Skip to content

armgit / ente

Public Imported from GitHub
0

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

24.0 KB
Raw Blame
package user

import (
	"bytes"
	"crypto/sha256"
	"database/sql"
	"encoding/base64"
	"errors"
	"fmt"
	"net/http"
	"strings"
	t "time"

	"github.com/ente/museum/pkg/utils/random"

	"github.com/ente/museum/pkg/utils/config"
	"github.com/ente/museum/pkg/utils/network"
	"github.com/gin-contrib/requestid"
	"github.com/spf13/viper"

	"github.com/ente/museum/ente"
	"github.com/ente/museum/pkg/controller/authsession"
	emailCtrl "github.com/ente/museum/pkg/controller/email"
	"github.com/ente/museum/pkg/repo"
	"github.com/ente/museum/pkg/utils/auth"
	"github.com/ente/museum/pkg/utils/crypto"
	emailUtil "github.com/ente/museum/pkg/utils/email"
	"github.com/ente/museum/pkg/utils/time"
	"github.com/ente/stacktrace"

	"github.com/gin-gonic/gin"
	log "github.com/sirupsen/logrus"
)

type HardCodedOTTEmail struct {
	Email string
	Value string
}

type HardCodedOTT struct {
	Emails            []HardCodedOTTEmail
	LocalDomainSuffix string
	LocalDomainValue  string
}

type signUpState int

const (
	signUpStateNoAccount signUpState = iota
	signUpStateIncomplete
	signUpStateComplete
)

func ReadHardCodedOTTFromConfig() HardCodedOTT {
	emails := make([]HardCodedOTTEmail, 0)
	emailsSlice := viper.GetStringSlice("internal.hardcoded-ott.emails")
	for _, entry := range emailsSlice {
		xs := strings.Split(entry, ",")
		if len(xs) == 2 && xs[0] != "" && xs[1] != "" {
			emails = append(emails, HardCodedOTTEmail{
				Email: xs[0],
				Value: xs[1],
			})
		} else {
			log.Errorf("Ignoring malformed internal.hardcoded-ott.emails entry %s", entry)
		}
	}

	localDomainSuffix := ""
	localDomainValue := ""
	if config.IsLocalEnvironment() {
		localDomainSuffix = viper.GetString("internal.hardcoded-ott.local-domain-suffix")
		localDomainValue = viper.GetString("internal.hardcoded-ott.local-domain-value")
	}

	return HardCodedOTT{
		Emails:            emails,
		LocalDomainSuffix: localDomainSuffix,
		LocalDomainValue:  localDomainValue,
	}
}

func hardcodedOTTForEmail(hardCodedOTT HardCodedOTT, email string) string {
	for _, entry := range hardCodedOTT.Emails {
		if email == entry.Email {
			return entry.Value
		}
	}

	if hardCodedOTT.LocalDomainSuffix != "" && strings.HasSuffix(email, hardCodedOTT.LocalDomainSuffix) {
		return hardCodedOTT.LocalDomainValue
	}

	return ""
}

func (c *UserController) SendEmailOTT(context *gin.Context, email string, purpose string, mobile bool) error {
	if c.OTTSendLimiter.IsGloballyBlocked() {
		return stacktrace.Propagate(ente.ErrTooManyBadRequest, "too many OTT requests")
	}

	shouldSend, err := c.validateSendOTT(context, email, purpose)
	if err != nil {
		return err
	}
	if !shouldSend {
		return nil
	}
	emailHash, err := crypto.GetHash(email, c.HashingKey)
	if err != nil {
		return stacktrace.Propagate(err, "")
	}
	app := auth.GetApp(context)
	otts, err := c.UserAuthRepo.GetValidOTTs(emailHash, app)
	if err != nil {
		return stacktrace.Propagate(err, "")
	}
	if len(otts) >= OTTActiveCodeLimit {
		alertMsg := fmt.Sprintf("Too many OTT requests for %s in %d minutes",
			emailUtil.GetMaskedEmailWithHint(email),
			OTTValidityDurationInMicroSeconds/(60*1000000))
		go c.DiscordController.NotifyPotentialAbuse(alertMsg)
		return stacktrace.Propagate(ente.ErrTooManyBadRequest, "too many OTT requests")
	}

	decision := c.OTTSendLimiter.Allow(network.GetClientIP(context))
	if decision.alert != "" {
		go c.DiscordController.NotifyPotentialAbuse(decision.alert)
	}
	if !decision.allowed {
		return stacktrace.Propagate(ente.ErrTooManyBadRequest, "too many OTT requests")
	}

	ott, err := random.GenerateSixDigitOtp()
	if err != nil {
		return stacktrace.Propagate(err, "")
	}
	hasHardcodedOTT := false
	if purpose != ente.ChangeEmailOTTPurpose {
		hardCodedOTT := hardcodedOTTForEmail(c.HardCodedOTT, email)
		if hardCodedOTT != "" {
			log.Warn(fmt.Sprintf("returning hardcoded ott for %s", email))
			hasHardcodedOTT = true
			ott = hardCodedOTT
		}
	}

	err = c.UserAuthRepo.AddOTT(emailHash, app, ott, time.Microseconds()+OTTValidityDurationInMicroSeconds)
	// Reused hard-coded OTTs may violate the database uniqueness check.
	if !hasHardcodedOTT {
		if err != nil {
			return stacktrace.Propagate(err, "")
		}
		err = emailOTT(app, email, ott, purpose, mobile)
		if err != nil {
			return stacktrace.Propagate(err, "")
		}
	} else {
		log.Info("Added hard coded ott for " + email + " : " + ott)
	}
	return nil
}

func (c *UserController) isEmailAlreadyUsed(email string) error {
	_, err := c.UserRepo.GetUserIDWithEmailUnrestricted(email)
	if err == nil {
		return stacktrace.Propagate(ente.ErrPermissionDenied, "email already belongs to a user")
	}
	if !errors.Is(err, sql.ErrNoRows) {
		return stacktrace.Propagate(err, "")
	}
	return nil
}

func (c *UserController) validateSendOTT(ctx *gin.Context, email string, purpose string) (bool, error) {
	var disclosureErr error
	if purpose == ente.ChangeEmailOTTPurpose {
		if err := c.isEmailAlreadyUsed(email); err != nil {
			if !errors.Is(err, ente.ErrPermissionDenied) {
				return false, err
			}
			disclosureErr = err
		}
	}
	if purpose != ente.ChangeEmailOTTPurpose {
		signupState, err := c.getSignUpState(email)
		if err != nil {
			return false, stacktrace.Propagate(err, "")
		}
		if purpose == ente.SignUpOTTPurpose && viper.GetBool("internal.disable-registration") && signupState != signUpStateComplete {
			return false, stacktrace.Propagate(ente.ErrPermissionDenied, "registration is disabled")
		}
		if purpose == ente.SignUpOTTPurpose && signupState == signUpStateComplete {
			disclosureErr = stacktrace.Propagate(ente.ErrUserAlreadyRegistered, "user has already completed sign up process")
		}
		if purpose == ente.LoginOTTPurpose && signupState == signUpStateNoAccount {
			disclosureErr = stacktrace.Propagate(ente.ErrUserNotRegistered, "user account does not exist")
		}
		if purpose == ente.LoginOTTPurpose && signupState == signUpStateIncomplete {
			disclosureErr = stacktrace.Propagate(ente.ErrUserSignupIncomplete, "user has not completed sign up process")
		}
	}
	if disclosureErr == nil {
		return true, nil
	}

	if c.shouldSwallowSendOTTDisclosureError(ctx) {
		return false, nil
	}
	return false, disclosureErr
}

func (c *UserController) shouldSwallowSendOTTDisclosureError(ctx *gin.Context) bool {
	if c.OTTLimiter == nil {
		return false
	}
	limitContext, limitErr := c.OTTLimiter.Get(ctx, "send-ott")
	if limitErr != nil {
		log.WithError(limitErr).Warn("Failed to check send-ott disclosure rate limit")
		return false
	}
	if !limitContext.Reached {
		return false
	}
	if c.DiscordController != nil {
		go c.DiscordController.NotifyPotentialAbuse("swallowing send-ott disclosure error")
	}
	return true
}

// Signup requires both an account row and key attributes.
func (c *UserController) getSignUpState(email string) (signUpState, error) {
	userID, err := c.UserRepo.GetUserIDWithEmailUnrestricted(email)
	if err != nil && errors.Is(err, sql.ErrNoRows) {
		return signUpStateNoAccount, nil
	}
	if err != nil {
		return signUpStateNoAccount, stacktrace.Propagate(err, "")
	}
	_, keyErr := c.UserRepo.GetKeyAttributes(userID)
	if keyErr != nil && errors.Is(keyErr, sql.ErrNoRows) {
		return signUpStateIncomplete, nil
	}
	if keyErr != nil {
		return signUpStateNoAccount, stacktrace.Propagate(keyErr, "")
	}
	return signUpStateComplete, nil
}

func (c *UserController) AddAdminOtt(req ente.AdminOttReq) error {
	emailHash, err := crypto.GetHash(req.Email, c.HashingKey)
	if err != nil {
		log.WithError(err).Error("Failed to get hash")
		return nil
	}
	err = c.UserAuthRepo.AddOTT(emailHash, req.App, req.Code, req.ExpiryTime)
	if err != nil {
		log.WithError(err).Error("Failed to add ott")
		return stacktrace.Propagate(err, "")
	}
	return nil
}

// verifyEmailOtt should be deprecated in favor of verifyEmailOttWithSession once clients are updated.
func (c *UserController) verifyEmailOtt(context *gin.Context, email string, ott string) error {
	ott = strings.TrimSpace(ott)
	app := auth.GetApp(context)
	emailHash, err := crypto.GetHash(email, c.HashingKey)
	if err != nil {
		return stacktrace.Propagate(err, "")
	}
	otts, limited, err := c.UserAuthRepo.ReserveOTTVerificationAttempt(emailHash, app, ott, OTTWrongAttemptLimit)
	if err != nil {
		return stacktrace.Propagate(err, "")
	}
	if limited {
		msg := fmt.Sprintf("Too many wrong ott verification attemp for app %s", app)
		go c.DiscordController.NotifyPotentialAbuse(msg)
		return stacktrace.Propagate(ente.ErrTooManyBadRequest, "User needs to wait before active ott are expired")
	}
	if len(otts) < 1 {
		return stacktrace.Propagate(ente.ErrExpiredOTT, "")
	}
	isValidOTT := false
	for _, validOTT := range otts {
		if ott == validOTT {
			isValidOTT = true
		}
	}
	if !isValidOTT {
		return stacktrace.Propagate(ente.ErrIncorrectOTT, "")
	}
	removed, err := c.UserAuthRepo.RemoveOTT(emailHash, ott, app)
	if err != nil {
		return stacktrace.Propagate(err, "")
	}
	if !removed {
		return stacktrace.Propagate(ente.ErrExpiredOTT, "")
	}
	return nil
}

func (c *UserController) VerifyEmail(context *gin.Context, request ente.EmailVerificationRequest) (ente.EmailAuthorizationResponse, error) {
	email := emailUtil.NormalizeEmail(request.Email)
	err := c.verifyEmailOtt(context, email, request.OTT)
	if err != nil {
		return ente.EmailAuthorizationResponse{}, stacktrace.Propagate(err, "")
	}
	return c.onVerificationSuccess(context, email, request.Source, nil)
}

func (c *UserController) ChangeEmail(ctx *gin.Context, request ente.EmailVerificationRequest) error {
	email := emailUtil.NormalizeEmail(request.Email)
	err := c.verifyEmailOtt(ctx, email, request.OTT)
	if err != nil {
		return stacktrace.Propagate(err, "")
	}

	return c.UpdateEmail(ctx, auth.GetUserID(ctx.Request.Header), email)
}

func (c *UserController) UpdateEmail(ctx *gin.Context, userID int64, email string) error {
	email = emailUtil.NormalizeEmail(email)

	_, err := c.UserRepo.GetUserIDWithEmailUnrestricted(email)
	if err == nil {
		return stacktrace.Propagate(ente.ErrPermissionDenied, "")
	}
	if !errors.Is(err, sql.ErrNoRows) {
		return stacktrace.Propagate(err, "")
	}
	user, err := c.UserRepo.Get(userID)
	if err != nil {
		return stacktrace.Propagate(err, "")
	}
	oldEmail := user.Email
	encryptedEmail, err := crypto.Encrypt(email, c.SecretEncryptionKey)
	if err != nil {
		return stacktrace.Propagate(err, "")
	}
	emailHash, err := crypto.GetHash(email, c.HashingKey)
	if err != nil {
		return stacktrace.Propagate(err, "")
	}
	err = c.UserRepo.UpdateEmail(userID, encryptedEmail, emailHash)
	if err != nil {
		return stacktrace.Propagate(err, "")
	}
	c.touchContactsAfterEmailUpdate(ctx, userID)
	_ = emailUtil.SendTemplatedEmail([]string{user.Email}, "ente", "[email protected]",
		ente.EmailChangedSubject, ente.EmailChangedTemplate, map[string]interface{}{
			"NewEmail": email,
		}, nil)

	err = c.BillingController.UpdateBillingEmail(userID, email)
	if err != nil {
		log.WithError(err).
			WithFields(log.Fields{
				"req_id":  requestid.Get(ctx),
				"user_id": userID,
			}).Error("stripe update email failed")
	}

	// Mailing list failures must not block email changes.
	go func() {
		if err := c.MailingListsController.Unsubscribe(oldEmail); err != nil {
			log.WithError(err).WithFields(log.Fields{
				"user_id": userID,
				"email":   oldEmail,
			}).Error("mailing list unsubscribe failed")
		}
		if err := c.MailingListsController.Subscribe(email); err != nil {
			log.WithError(err).WithFields(log.Fields{
				"user_id": userID,
				"email":   email,
			}).Error("mailing list subscribe failed")
		}
	}()

	return nil
}

func (c *UserController) touchContactsAfterEmailUpdate(ctx *gin.Context, userID int64) {
	if c.ContactRepo == nil {
		return
	}
	if touchErr := c.ContactRepo.TouchContactsForContactUser(ctx, userID); touchErr != nil {
		log.WithError(touchErr).
			WithFields(log.Fields{
				"req_id":  requestid.Get(ctx),
				"user_id": userID,
			}).
			Error("failed to touch contacts after email update")
	}
}

// known issue: the token may be still cached in other instances till the expiry time (10min), JWTs might remain too
func (c *UserController) Logout(ctx *gin.Context) error {
	token := auth.GetToken(ctx)
	userID := auth.GetUserID(ctx.Request.Header)
	return c.TerminateSession(userID, token)
}

func (c *UserController) GetActiveSessions(context *gin.Context, userID int64) ([]ente.Session, error) {
	sessions, err := c.UserAuthRepo.GetActiveSessions(userID, auth.GetApp(context))
	if err != nil {
		return nil, stacktrace.Propagate(err, "")
	}
	currentHash := auth.HashToken(auth.GetToken(context))
	for i := range sessions {
		session := &sessions[i]
		session.Token = encodeSessionTokenHash(session.TokenHash)
		session.IsCurrent = bytes.Equal(session.TokenHash, currentHash[:])
	}
	return sessions, nil
}

const (
	StorageWarningDeletionScheduledCode    = "ACCOUNT_SCHEDULED_FOR_DELETION"
	StorageWarningDeletionScheduledMessage = "Access to this account has been restricted because its Ente Photos and Ente Locker data is scheduled for deletion. If you think this was a mistake, please reply to this email."
)

func shouldEnforceStorageWarningDeletionLoginBlock(app ente.App) bool {
	return app == ente.Photos || app == ente.Locker
}

func storageWarningDeletionScheduledError() error {
	return stacktrace.Propagate(&ente.ApiError{
		Code:           StorageWarningDeletionScheduledCode,
		Message:        StorageWarningDeletionScheduledMessage,
		HttpStatusCode: http.StatusForbidden,
	}, "storage warning deletion scheduled")
}

func (c *UserController) ensureStorageWarningDeletionLoginAllowed(userID int64, app ente.App) error {
	if c.NotificationHistoryRepo == nil || !shouldEnforceStorageWarningDeletionLoginBlock(app) {
		return nil
	}
	deletionScheduled, err := c.NotificationHistoryRepo.IsStorageWarningDeletionScheduled(userID)
	if err != nil {
		return stacktrace.Propagate(err, "failed to read storage warning deletion state")
	}
	if deletionScheduled {
		// Login blocking is terminal-row based. If a daily storage-warning run
		// races with an admin soft-unblock, the terminal row can reappear while
		// the grace window is still active, so login must honor grace directly.
		graceActive, graceUntil, err := c.NotificationHistoryRepo.IsStorageWarningLoginGraceActive(userID, time.Microseconds())
		if err != nil {
			return stacktrace.Propagate(err, "failed to read storage warning login grace")
		}
		if graceActive {
			log.WithFields(log.Fields{
				"user_id":     userID,
				"app":         app,
				"grace_until": graceUntil,
			}).Info("allowing login during storage warning grace")
			return nil
		}
		log.WithFields(log.Fields{
			"user_id": userID,
			"app":     app,
			"code":    StorageWarningDeletionScheduledCode,
		}).Warn("blocked login due to storage warning scheduled deletion")
		return storageWarningDeletionScheduledError()
	}
	return nil
}

func (c *UserController) ClearStorageWarningDeletionLoginBlock(userID int64) error {
	if c.NotificationHistoryRepo == nil {
		return nil
	}
	return c.NotificationHistoryRepo.ClearStorageWarningDeletionScheduled(userID)
}

func (c *UserController) AddTokenAndNotify(ctx *gin.Context, userID int64, app ente.App, token string, ip string, userAgent string) error {
	if err := c.ensureStorageWarningDeletionLoginAllowed(userID, app); err != nil {
		return err
	}
	err := c.UserAuthRepo.AddToken(userID, app, token, ip, userAgent)
	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")
	} else if *isEmailMFAEnabled {
		return nil
	}

	clientPackage := ctx.GetHeader("X-Client-Package")
	go func() {
		user, userErr := c.UserRepo.GetUserByIDInternal(userID)
		if userErr != nil {
			log.WithError(userErr).Error("Failed to get user")
			return
		}
		templateData := map[string]interface{}{
			"Date": t.Now().UTC().Format("02 Jan, 2006 15:04"),
		}
		normalizedEmail := emailUtil.NormalizeEmail(user.Email)
		if strings.HasSuffix(normalizedEmail, "@ente.io") ||
			strings.HasSuffix(normalizedEmail, "@ente.com") {
			appDisplayNames := map[ente.App]string{
				ente.Photos: "Ente Photos",
				ente.Auth:   "Ente Auth",
				ente.Locker: "Ente Locker",
			}
			appName, ok := appDisplayNames[app]
			if !ok {
				appName = "Ente"
			}
			if clientPackage == "io.ente.space.web" {
				appName = "Ente Space"
			}
			device := "Unknown Device"
			if strings.TrimSpace(userAgent) != "" {
				device = network.GetPrettyUA(userAgent)
			}
			templateData["App"] = appName
			templateData["Device"] = device
			templateData["IP"] = ip
		}
		emailSendErr := emailUtil.SendTemplatedEmail([]string{user.Email}, "Ente", "[email protected]", emailCtrl.LoginSuccessSubject, emailCtrl.LoginSuccessTemplate, templateData, nil)
		if emailSendErr != nil {
			log.WithError(emailSendErr).Error("Failed to send email")
		}
	}()
	return nil
}

func (c *UserController) RemoveTokensForApps(userID int64, apps []ente.App) error {
	return c.finishTokenRevocation(c.UserAuthRepo.RemoveTokensForApps(userID, apps))
}

func (c *UserController) RemoveAllOtherTokens(userID int64, token string) error {
	tokenHash := auth.HashToken(token)
	return c.finishTokenRevocation(c.UserAuthRepo.RemoveAllOtherTokensByHash(userID, tokenHash[:]))
}

func (c *UserController) TerminateSession(userID int64, token string) error {
	tokenHash := auth.HashToken(token)
	return c.finishTokenRevocation(c.UserAuthRepo.RemoveTokenByHash(userID, tokenHash[:]))
}

func (c *UserController) TerminateSessionByIdentifier(userID int64, currentToken, identifier string) error {
	tokenHash, err := sessionIdentifierHash(identifier)
	if err != nil {
		return err
	}
	currentHash := auth.HashToken(currentToken)
	if bytes.Equal(tokenHash, currentHash[:]) {
		return ente.NewBadRequestWithMessage("use logout to terminate the current session")
	}
	return c.finishTokenRevocation(c.UserAuthRepo.RemoveTokenByHash(userID, tokenHash))
}

const sessionTokenHashPrefix = "th:"

func encodeSessionTokenHash(tokenHash []byte) string {
	return sessionTokenHashPrefix + base64.RawURLEncoding.EncodeToString(tokenHash)
}

func sessionIdentifierHash(identifier string) ([]byte, error) {
	encoded, ok := strings.CutPrefix(identifier, sessionTokenHashPrefix)
	if !ok {
		tokenHash := auth.HashToken(identifier)
		return tokenHash[:], nil
	}
	tokenHash, err := base64.RawURLEncoding.DecodeString(encoded)
	if err != nil || len(tokenHash) != sha256.Size {
		return nil, ente.NewBadRequestWithMessage("invalid session identifier")
	}
	return tokenHash, nil
}

func (c *UserController) finishTokenRevocation(tokens []repo.RevokedToken, err error) error {
	if err != nil {
		return stacktrace.Propagate(err, "failed to remove tokens")
	}
	authsession.MarkRevoked(c.Cache, tokens)
	return nil
}

func emailOTT(app ente.App, to string, ott string, purpose string, mobile bool) error {
	var templateName string
	if purpose == ente.ChangeEmailOTTPurpose {
		templateName = ente.ChangeEmailOTTTemplate
	} else {
		if mobile && app == ente.Photos {
			templateName = ente.OTTMobileTemplate
		} else {
			templateName = ente.OTTTemplate
		}
	}
	subject := fmt.Sprintf("Verification code: %s", ott)
	err := emailUtil.SendTemplatedEmail([]string{to}, "Ente", "[email protected]",
		subject, templateName, map[string]interface{}{
			"VerificationCode": ott,
		}, nil)
	if err != nil {
		return stacktrace.Propagate(err, "")
	}
	return nil
}

func (c *UserController) onVerificationSuccess(context *gin.Context, email string, source *string, srpAuth *ente.SRPAuthEntity) (ente.EmailAuthorizationResponse, error) {
	isSRPLogin := srpAuth != nil
	isTwoFactorEnabled := false
	app := auth.GetApp(context)

	userID, err := c.UserRepo.GetUserIDWithEmailUnrestricted(email)
	if err != nil {
		if errors.Is(err, sql.ErrNoRows) {
			if viper.GetBool("internal.disable-registration") {
				return ente.EmailAuthorizationResponse{}, stacktrace.Propagate(ente.ErrPermissionDenied, "")
			} else {
				userID, _, err = c.createUser(context, email, source)
				if err != nil {
					return ente.EmailAuthorizationResponse{}, stacktrace.Propagate(err, "")
				}
			}
		} else {
			return ente.EmailAuthorizationResponse{}, stacktrace.Propagate(err, "")
		}
	} else {
		isTwoFactorEnabled, err = c.UserRepo.IsTwoFactorEnabled(userID)
		if err != nil {
			return ente.EmailAuthorizationResponse{}, err
		}
	}
	hasPasskeys, err := c.UserRepo.HasPasskeys(userID)
	if err != nil {
		return ente.EmailAuthorizationResponse{}, stacktrace.Propagate(err, "")
	}
	if srpAuth == nil {
		srpAuth, err = c.UserAuthRepo.GetSRPAuthEntity(context, userID)
		if err != nil && !errors.Is(err, sql.ErrNoRows) {
			return ente.EmailAuthorizationResponse{}, stacktrace.Propagate(err, "")
		}
	}
	keyAttributesValue, err := c.UserRepo.GetKeyAttributes(userID)
	if err != nil && !errors.Is(err, sql.ErrNoRows) {
		return ente.EmailAuthorizationResponse{}, stacktrace.Propagate(err, "")
	}
	var keyAttributes *ente.KeyAttributes
	if err == nil {
		keyAttributes = &keyAttributesValue
	}
	var passKeySessionID, twoFactorSessionID, accountsUrl string

	if hasPasskeys {
		accountsUrl, err = c.PasskeyRepo.AccountsURLForUser(userID)
		if err != nil {
			return ente.EmailAuthorizationResponse{}, stacktrace.Propagate(err, "")
		}

		passKeySessionID = auth.GenerateURLSafeRandomString(PassKeySessionIDLength)
	}
	if isTwoFactorEnabled {
		twoFactorSessionID = auth.GenerateURLSafeRandomString(TwoFactorSessionIDLength)
	}
	if hasPasskeys || isTwoFactorEnabled {
		err = c.UserAuthRepo.AddLoginResult(context, userID, srpAuth, keyAttributes, app, "", "", "", passKeySessionID, twoFactorSessionID, time.Microseconds()+TwoFactorValidityDurationInMicroSeconds, isSRPLogin)
		if err != nil {
			return ente.EmailAuthorizationResponse{}, stacktrace.Propagate(err, "")
		}
	}
	if hasPasskeys && isTwoFactorEnabled {
		return ente.EmailAuthorizationResponse{ID: userID, PasskeySessionID: passKeySessionID, AccountsUrl: accountsUrl, TwoFactorSessionIDV2: twoFactorSessionID}, nil
	} else if hasPasskeys {
		return ente.EmailAuthorizationResponse{ID: userID, PasskeySessionID: passKeySessionID, AccountsUrl: accountsUrl}, nil
	} else if isTwoFactorEnabled {
		return ente.EmailAuthorizationResponse{ID: userID, TwoFactorSessionID: twoFactorSessionID}, nil
	}

	if keyAttributes == nil {
		token := auth.GenerateURLSafeRandomString(TokenLength)
		// user creation is pending on key attributes set based on the password.
		// No need to send login notification
		if err := c.ensureStorageWarningDeletionLoginAllowed(userID, app); err != nil {
			return ente.EmailAuthorizationResponse{}, err
		}
		err = c.UserAuthRepo.AddLoginResult(context, userID, srpAuth, nil, app, token,
			network.GetClientIP(context), context.Request.UserAgent(), "", "", 0, isSRPLogin)
		if err != nil {
			return ente.EmailAuthorizationResponse{}, stacktrace.Propagate(err, "")
		}
		return ente.EmailAuthorizationResponse{ID: userID, Token: token}, nil
	}
	token := generateAuthToken()
	var encryptedToken string
	encryptedToken, err = crypto.GetEncryptedToken(token, keyAttributes.PublicKey)
	if err != nil {
		return ente.EmailAuthorizationResponse{}, stacktrace.Propagate(err, "")
	}
	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, keyAttributes, app, token, ip, userAgent, "", "", 0, isSRPLogin)
	if err == nil {
		err = c.notifyLogin(context, userID, app, ip, userAgent)
	}
	if err != nil {
		return ente.EmailAuthorizationResponse{}, stacktrace.Propagate(err, "")
	}
	return ente.EmailAuthorizationResponse{
		ID:             userID,
		KeyAttributes:  keyAttributes,
		EncryptedToken: encryptedToken,
	}, nil

}

func generateAuthToken() string {
	payload := append([]byte("auth-token"), auth.GenerateRandomBytes(TokenLength)...)
	return base64.URLEncoding.EncodeToString(payload)
}

func convertStringToBytes(s string) ([]byte, error) {
	b, err := base64.StdEncoding.DecodeString(s)
	if err != nil {
		return nil, ente.NewBadRequestWithMessage("invalid base64 encoding")
	}
	return b, nil
}

func convertBytesToString(b []byte) string {
	return base64.StdEncoding.EncodeToString(b)
}