Skip to content

armgit / ente

Public Imported from GitHub
0

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

Bind SRP login sessions to accounts

Neeraj Gupta1a821efa986c
diff --git a/server/pkg/controller/user/srp.go b/server/pkg/controller/user/srp.go
index b5753ac035..ba45ee7b29 100644
--- a/server/pkg/controller/user/srp.go
+++ b/server/pkg/controller/user/srp.go
@@ -58,7 +58,7 @@ func (c *UserController) CompleteSRPSetup(context *gin.Context, req ente.Complet
if err != nil {
return nil, stacktrace.Propagate(err, "")
}
- srpM2, err := c.verifySRPSession(context, setup.Verifier, setup.SessionID, req.SRPM1)
+ srpM2, err := c.verifySRPSession(context, setup.SRPUserID, setup.Verifier, setup.SessionID, req.SRPM1)
if err != nil {
return nil, err
}
@@ -103,7 +103,7 @@ func (c *UserController) updateSrpAndKeyAttributes(ctx *gin.Context,
if err != nil {
return nil, stacktrace.Propagate(err, "")
}
- srpM2, err := c.verifySRPSession(ctx, setup.Verifier, setup.SessionID, req.SRPM1)
+ srpM2, err := c.verifySRPSession(ctx, setup.SRPUserID, setup.Verifier, setup.SessionID, req.SRPM1)
if err != nil {
return nil, err
}
@@ -204,12 +204,12 @@ func (c *UserController) VerifySRPSession(context *gin.Context, req ente.VerifyS
srpAuthEntity, err := c.UserAuthRepo.GetSRPAuthEntityBySRPUserID(context, req.SRPUserID)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
- _, verifyErr := c.verifySRPSession(context, FakeVerifier, req.SessionID, req.SRPM1)
+ _, verifyErr := c.verifySRPSession(context, req.SRPUserID, FakeVerifier, req.SessionID, req.SRPM1)
return nil, verifyErr
}
return nil, stacktrace.Propagate(err, "")
}
- srpM2, err := c.verifySRPSession(context, srpAuthEntity.Verifier, req.SessionID, req.SRPM1)
+ srpM2, err := c.verifySRPSession(context, srpAuthEntity.SRPUserID, srpAuthEntity.Verifier, req.SessionID, req.SRPM1)
if err != nil {
return nil, stacktrace.Propagate(err, "")
}
@@ -217,6 +217,13 @@ func (c *UserController) VerifySRPSession(context *gin.Context, req ente.VerifyS
if err != nil {
return nil, err
}
+ if *user.IsEmailMFAEnabled {
+ return nil, stacktrace.Propagate(&ente.ApiError{
+ Code: "EMAIL_MFA_ENABLED",
+ Message: "Email MFA is enabled",
+ HttpStatusCode: http.StatusConflict,
+ }, "email mfa is enabled")
+ }
verResponse, err := c.onVerificationSuccess(context, user.Email, nil, srpAuthEntity)
if err != nil {
return nil, stacktrace.Propagate(err, "")
@@ -283,6 +290,7 @@ func (c *UserController) createAndInsertSRPSession(
}
func (c *UserController) verifySRPSession(ctx context.Context,
+ srpUserID uuid.UUID,
srpVerifier string,
sessionID uuid.UUID,
srpM1 string,
@@ -326,6 +334,9 @@ func (c *UserController) verifySRPSession(ctx context.Context,
time.Sleep(time.Duration(20+mathRand.Intn(30)) * time.Millisecond)
return nil, stacktrace.Propagate(ente.ErrInvalidPassword, "fake session verification")
}
+ if srpSession.SRPUserID != srpUserID {
+ return nil, stacktrace.Propagate(ente.ErrInvalidPassword, "srp session belongs to another account")
+ }
srpParams := srp.GetParams(Srp4096Params)
srpVerifierBytes, err := convertStringToBytes(srpVerifier)
diff --git a/server/pkg/controller/user/srp_test.go b/server/pkg/controller/user/srp_test.go
new file mode 100644
index 0000000000..482778805f
--- /dev/null
+++ b/server/pkg/controller/user/srp_test.go
@@ -0,0 +1,154 @@
+package user
+
+import (
+ "math/big"
+ "net/http"
+ "net/http/httptest"
+ "strconv"
+ "testing"
+
+ "github.com/ente/go-srp"
+ "github.com/ente/museum/ente"
+ "github.com/ente/museum/internal/testutil"
+ "github.com/ente/museum/pkg/repo"
+ "github.com/ente/museum/pkg/repo/passkey"
+ "github.com/gin-gonic/gin"
+ "github.com/google/uuid"
+ "github.com/stretchr/testify/require"
+)
+
+func TestVerifySRPSessionRejectsAnotherAccountAndEnabledEmailMFA(t *testing.T) {
+ testutil.WithServerRoot(t)
+ db := testutil.RequireTestDB(t)
+ testutil.ResetTables(t, db)
+ t.Cleanup(func() { testutil.ResetTables(t, db) })
+ controller := &UserController{
+ UserAuthRepo: &repo.UserAuthRepository{DB: db},
+ UserRepo: &repo.UserRepository{
+ DB: db, SecretEncryptionKey: testutil.SecretEncryptionKey(), HashingKey: testutil.HashingKey(),
+ PasskeysRepository: &passkey.Repository{DB: db},
+ },
+ }
+ gin.SetMode(gin.TestMode)
+ ctx, _ := gin.CreateTestContext(httptest.NewRecorder())
+ ctx.Request = httptest.NewRequest(http.MethodPost, "/users/srp/verify-session", nil)
+
+ params := srp.GetParams(Srp4096Params)
+ secret := srp.GenKey()
+ ownerID := testutil.InsertUser(t, db, testutil.UserFixture{Email: "[email protected]", CreationTime: 1})
+ ownerSRPID := uuid.New()
+ ownerVerifier := srp.ComputeVerifier(params, []byte("owner-salt"), ownerSRPID[:], []byte("owner-password"))
+ ownerClient := srp.NewClient(params, []byte("owner-salt"), ownerSRPID[:], []byte("owner-password"), secret)
+ require.NoError(t, controller.UserAuthRepo.InsertSRPAuth(ctx, ownerID, ownerSRPID, convertBytesToString(ownerVerifier), "owner-salt"))
+ require.NoError(t, controller.UserAuthRepo.UpdateEmailMFA(ctx, ownerID, false))
+
+ targetID := testutil.InsertUser(t, db, testutil.UserFixture{Email: "[email protected]", CreationTime: 1})
+ targetSRPID := uuid.New()
+ t.Cleanup(func() {
+ _, err := db.Exec(`DELETE FROM srp_sessions WHERE srp_user_id IN ($1, $2)`, ownerSRPID, targetSRPID)
+ require.NoError(t, err)
+ })
+ targetVerifier := srp.ComputeVerifier(params, []byte("target-salt"), targetSRPID[:], []byte("target-password"))
+ targetClient := srp.NewClient(params, []byte("target-salt"), targetSRPID[:], []byte("target-password"), secret)
+ require.NoError(t, controller.UserAuthRepo.InsertSRPAuth(ctx, targetID, targetSRPID, convertBytesToString(targetVerifier), "target-salt"))
+ require.NoError(t, controller.UserAuthRepo.UpdateEmailMFA(ctx, targetID, true))
+
+ _, err := controller.CreateSrpSession(ctx, ente.CreateSRPSessionRequest{
+ SRPUserID: targetSRPID, SRPA: convertBytesToString(targetClient.ComputeA()),
+ })
+ var apiError *ente.ApiError
+ require.ErrorAs(t, err, &apiError)
+ require.Equal(t, ente.ErrorCode("EMAIL_MFA_ENABLED"), apiError.Code)
+
+ session, err := controller.CreateSrpSession(ctx, ente.CreateSRPSessionRequest{
+ SRPUserID: ownerSRPID, SRPA: convertBytesToString(ownerClient.ComputeA()),
+ })
+ require.NoError(t, err)
+ b, err := convertStringToBytes(session.SRPB)
+ require.NoError(t, err)
+ ownerClient.SetB(b)
+
+ // B_target = B_owner + k * (v_target - v_owner) mod N.
+ verifierDifference := new(big.Int).Sub(new(big.Int).SetBytes(targetVerifier), new(big.Int).SetBytes(ownerVerifier))
+ targetB := new(big.Int).Mul(targetClient.Multiplier, verifierDifference)
+ targetB.Add(targetB, new(big.Int).SetBytes(b)).Mod(targetB, params.N)
+ targetClient.SetB(targetB.FillBytes(make([]byte, params.NLengthBits/8)))
+ response, err := controller.VerifySRPSession(ctx, ente.VerifySRPSessionRequest{
+ SessionID: session.SessionID, SRPUserID: targetSRPID, SRPM1: convertBytesToString(targetClient.ComputeM1()),
+ })
+ require.ErrorIs(t, err, ente.ErrInvalidPassword)
+ require.Nil(t, response)
+ storedSession, err := controller.UserAuthRepo.GetSrpSessionEntity(ctx, session.SessionID)
+ require.NoError(t, err)
+ require.False(t, storedSession.IsVerified)
+ var tokens int
+ require.NoError(t, db.QueryRow(`SELECT COUNT(*) FROM tokens WHERE user_id = $1`, targetID).Scan(&tokens))
+ require.Zero(t, tokens)
+
+ response, err = controller.VerifySRPSession(ctx, ente.VerifySRPSessionRequest{
+ SessionID: session.SessionID, SRPUserID: ownerSRPID, SRPM1: convertBytesToString(ownerClient.ComputeM1()),
+ })
+ require.NoError(t, err)
+ require.Equal(t, ownerID, response.ID)
+ require.NotEmpty(t, response.Token)
+ m2, err := convertStringToBytes(*response.SrpM2)
+ require.NoError(t, err)
+ require.NoError(t, ownerClient.CheckM2(m2))
+
+ session, err = controller.CreateSrpSession(ctx, ente.CreateSRPSessionRequest{
+ SRPUserID: ownerSRPID, SRPA: convertBytesToString(ownerClient.ComputeA()),
+ })
+ require.NoError(t, err)
+ b, err = convertStringToBytes(session.SRPB)
+ require.NoError(t, err)
+ ownerClient.SetB(b)
+ require.NoError(t, controller.UserAuthRepo.UpdateEmailMFA(ctx, ownerID, true))
+ response, err = controller.VerifySRPSession(ctx, ente.VerifySRPSessionRequest{
+ SessionID: session.SessionID, SRPUserID: ownerSRPID, SRPM1: convertBytesToString(ownerClient.ComputeM1()),
+ })
+ require.ErrorAs(t, err, &apiError)
+ require.Equal(t, ente.ErrorCode("EMAIL_MFA_ENABLED"), apiError.Code)
+ require.Nil(t, response)
+ require.NoError(t, db.QueryRow(`SELECT COUNT(*) FROM tokens WHERE user_id = $1`, ownerID).Scan(&tokens))
+ require.Equal(t, 1, tokens)
+}
+
+func TestCompleteSRPSetupPreservesSessionBinding(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})
+ controller := &UserController{UserAuthRepo: &repo.UserAuthRepository{DB: db}}
+ gin.SetMode(gin.TestMode)
+ ctx, _ := gin.CreateTestContext(httptest.NewRecorder())
+ ctx.Request = httptest.NewRequest(http.MethodPost, "/users/srp/complete", nil)
+ ctx.Request.Header.Set("X-Auth-User-ID", strconv.FormatInt(userID, 10))
+ params := srp.GetParams(Srp4096Params)
+ srpUserID := uuid.New()
+ t.Cleanup(func() {
+ _, err := db.Exec(`DELETE FROM srp_sessions WHERE srp_user_id = $1`, srpUserID)
+ require.NoError(t, err)
+ })
+ salt, password := []byte("setup-salt"), []byte("setup-password")
+ client := srp.NewClient(params, salt, srpUserID[:], password, srp.GenKey())
+ verifier := convertBytesToString(srp.ComputeVerifier(params, salt, srpUserID[:], password))
+ setup, err := controller.SetupSRP(ctx, userID, ente.SetupSRPRequest{
+ SrpUserID: srpUserID, SRPSalt: convertBytesToString(salt), SRPVerifier: verifier, SRPA: convertBytesToString(client.ComputeA()),
+ })
+ require.NoError(t, err)
+ b, err := convertStringToBytes(setup.SRPB)
+ require.NoError(t, err)
+ client.SetB(b)
+ response, err := controller.CompleteSRPSetup(ctx, ente.CompleteSRPSetupRequest{
+ SetupID: setup.SetupID, SRPM1: convertBytesToString(client.ComputeM1()),
+ })
+ require.NoError(t, err)
+ m2, err := convertStringToBytes(response.SRPM2)
+ require.NoError(t, err)
+ require.NoError(t, client.CheckM2(m2))
+ storedAuth, err := controller.UserAuthRepo.GetSRPAuthEntity(ctx, userID)
+ require.NoError(t, err)
+ require.Equal(t, srpUserID, storedAuth.SRPUserID)
+ require.Equal(t, verifier, storedAuth.Verifier)
+}