π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
package user
import (
"database/sql"
"errors"
"net/http"
"net/http/httptest"
"net/url"
"testing"
stdtime "time"
"github.com/ente/museum/ente"
contactmodel "github.com/ente/museum/ente/contact"
cleanupentity "github.com/ente/museum/ente/data_cleanup"
enteJWT "github.com/ente/museum/ente/jwt"
"github.com/ente/museum/internal/testutil"
"github.com/ente/museum/pkg/repo"
contactrepo "github.com/ente/museum/pkg/repo/contact"
cleanuprepo "github.com/ente/museum/pkg/repo/datacleanup"
"github.com/ente/museum/pkg/utils/config"
"github.com/ente/museum/pkg/utils/time"
"github.com/gin-gonic/gin"
"github.com/spf13/viper"
)
func TestGetAccountRecoveryLinkExpiresAfterSevenDays(t *testing.T) {
viper.Reset()
viper.Set("apps.accounts", "https://accounts.example.com/")
t.Cleanup(viper.Reset)
controller := &UserController{JwtSecret: []byte("test-jwt-secret")}
before := time.Microseconds()
recoveryLink, err := controller.getAccountRecoveryLink(42, "[email protected]")
if err != nil {
t.Fatalf("getAccountRecoveryLink() error = %v", err)
}
after := time.Microseconds()
parsedLink, err := url.Parse(recoveryLink)
if err != nil {
t.Fatalf("failed to parse recovery link: %v", err)
}
if parsedLink.Scheme != "https" || parsedLink.Host != "accounts.example.com" || parsedLink.Path != "/recover-account" {
t.Fatalf("recovery link = %q, want configured accounts recovery page", recoveryLink)
}
if parsedLink.RawQuery != "" {
t.Fatalf("recovery link query = %q, want token only in fragment", parsedLink.RawQuery)
}
fragment, err := url.ParseQuery(parsedLink.Fragment)
if err != nil {
t.Fatalf("failed to parse recovery link fragment: %v", err)
}
claim, err := controller.ValidateJWTToken(fragment.Get("recoveryToken"), enteJWT.RestoreAccount)
if err != nil {
t.Fatalf("ValidateJWTToken() error = %v", err)
}
const sevenDays = int64(7*24) * time.MicroSecondsInOneHour
if claim.ExpiryTime < before+sevenDays || claim.ExpiryTime > after+sevenDays {
t.Fatalf("token expiry = %d, want approximately 7 days after issuance", claim.ExpiryTime)
}
if claim.UserID != 42 || claim.Email != "[email protected]" {
t.Fatalf("recovery token claim = %+v, want user 42 and [email protected]", claim)
}
}
func TestValidateSelfAccountRecoveryClassifiesTokenErrors(t *testing.T) {
controller := &UserController{JwtSecret: []byte("test-jwt-secret")}
expiredToken := accountRecoveryToken(t, controller, &enteJWT.WebCommonJWTClaim{
UserID: 42,
Email: "[email protected]",
ExpiryTime: time.Microseconds() - 1,
ClaimScope: enteJWT.RestoreAccount.Ptr(),
})
wrongScopeToken := accountRecoveryToken(t, controller, &enteJWT.WebCommonJWTClaim{
UserID: 42,
Email: "[email protected]",
ExpiryTime: time.MicrosecondsAfterDays(1),
ClaimScope: enteJWT.DELETE_ACCOUNT.Ptr(),
})
tests := []struct {
name string
token string
wantError *ente.ApiError
wantCode ente.ErrorCode
wantStatus int
}{
{
name: "malformed",
token: "not-a-jwt",
wantError: ErrAccountRecoveryInvalidLink,
wantCode: accountRecoveryInvalidLinkCode,
wantStatus: http.StatusBadRequest,
},
{
name: "wrong scope",
token: wrongScopeToken,
wantError: ErrAccountRecoveryInvalidLink,
wantCode: accountRecoveryInvalidLinkCode,
wantStatus: http.StatusBadRequest,
},
{
name: "expired",
token: expiredToken,
wantError: ErrAccountRecoveryLinkExpired,
wantCode: accountRecoveryLinkExpiredCode,
wantStatus: http.StatusGone,
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
_, err := controller.ValidateSelfAccountRecovery(test.token)
if !errors.Is(err, test.wantError) {
t.Fatalf("ValidateSelfAccountRecovery() error = %v, want %v", err, test.wantError)
}
var apiErr *ente.ApiError
if !errors.As(err, &apiErr) {
t.Fatalf("ValidateSelfAccountRecovery() error = %v, want ApiError", err)
}
if apiErr.Code != test.wantCode || apiErr.HttpStatusCode != test.wantStatus {
t.Fatalf("ApiError = %+v, want code %s and status %d", apiErr, test.wantCode, test.wantStatus)
}
})
}
}
func TestSelfAccountRecoveryStatusAndRecovery(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{
UserID: 82,
Email: "[email protected]",
CreationTime: 1,
})
insertKeyAttributes(t, db, userID)
insertScheduledDelete(t, db, userID)
userRepo := &repo.UserRepository{
DB: db,
SecretEncryptionKey: testutil.SecretEncryptionKey(),
HashingKey: testutil.HashingKey(),
}
if err := userRepo.Delete(userID); err != nil {
t.Fatalf("failed to delete user: %v", err)
}
controller := &UserController{
UserRepo: userRepo,
DataCleanupRepo: &cleanuprepo.Repository{DB: db},
SecretEncryptionKey: testutil.SecretEncryptionKey(),
HashingKey: testutil.HashingKey(),
JwtSecret: []byte("test-jwt-secret"),
}
token := accountRecoveryToken(t, controller, &enteJWT.WebCommonJWTClaim{
UserID: userID,
Email: "[email protected]",
ExpiryTime: time.MicrosecondsAfterDays(1),
ClaimScope: enteJWT.RestoreAccount.Ptr(),
})
response, err := controller.ValidateSelfAccountRecovery(token)
if err != nil {
t.Fatalf("ValidateSelfAccountRecovery() error = %v", err)
}
if response.Status != ente.AccountRecoveryReady {
t.Fatalf("validation status = %q, want %q", response.Status, ente.AccountRecoveryReady)
}
if _, err := db.Exec(`UPDATE data_cleanup SET stage = $1 WHERE user_id = $2`, cleanupentity.Collection, userID); err != nil {
t.Fatalf("failed to advance cleanup: %v", err)
}
if _, err := controller.ValidateSelfAccountRecovery(token); !errors.Is(err, ErrAccountRecoveryUnavailable) {
t.Fatalf("validation after cleanup advanced error = %v, want ErrAccountRecoveryUnavailable", err)
}
if _, err := db.Exec(`UPDATE data_cleanup SET stage = $1 WHERE user_id = $2`, cleanupentity.Scheduled, userID); err != nil {
t.Fatalf("failed to restore scheduled cleanup fixture: %v", err)
}
gin.SetMode(gin.TestMode)
ctx, _ := gin.CreateTestContext(httptest.NewRecorder())
response, err = controller.RecoverSelfAccount(ctx, token)
if err != nil {
t.Fatalf("RecoverSelfAccount() error = %v", err)
}
if response.Status != ente.AccountRecoveryRecovered {
t.Fatalf("recovery status = %q, want %q", response.Status, ente.AccountRecoveryRecovered)
}
if _, err := userRepo.Get(userID); err != nil {
t.Fatalf("recovered user is not active: %v", err)
}
var cleanupRows int
if err := db.QueryRow(`SELECT COUNT(*) FROM data_cleanup WHERE user_id = $1`, userID).Scan(&cleanupRows); err != nil {
t.Fatalf("failed to count cleanup rows: %v", err)
}
if cleanupRows != 0 {
t.Fatalf("cleanup row count = %d, want 0", cleanupRows)
}
response, err = controller.ValidateSelfAccountRecovery(token)
if err != nil {
t.Fatalf("ValidateSelfAccountRecovery() after recovery error = %v", err)
}
if response.Status != ente.AccountRecoveryRecovered {
t.Fatalf("validation status after recovery = %q, want %q", response.Status, ente.AccountRecoveryRecovered)
}
err = controller.HandleAccountRecovery(ctx, ente.RecoverAccountRequest{
UserID: userID,
EmailID: "[email protected]",
})
var apiErr *ente.ApiError
if !errors.As(err, &apiErr) || apiErr.Code != ente.BadRequest || apiErr.HttpStatusCode != http.StatusBadRequest {
t.Fatalf("HandleAccountRecovery() for active account error = %v, want bad request", err)
}
}
func TestValidateSelfAccountRecoveryReportsUnavailableAfterKeyCleanup(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{
UserID: 82,
Email: "[email protected]",
CreationTime: 1,
})
userRepo := &repo.UserRepository{
DB: db,
SecretEncryptionKey: testutil.SecretEncryptionKey(),
HashingKey: testutil.HashingKey(),
}
if err := userRepo.Delete(userID); err != nil {
t.Fatalf("failed to delete user: %v", err)
}
controller := &UserController{
UserRepo: userRepo,
JwtSecret: []byte("test-jwt-secret"),
}
token := accountRecoveryToken(t, controller, &enteJWT.WebCommonJWTClaim{
UserID: userID,
Email: "[email protected]",
ExpiryTime: time.MicrosecondsAfterDays(1),
ClaimScope: enteJWT.RestoreAccount.Ptr(),
})
_, err := controller.ValidateSelfAccountRecovery(token)
if !errors.Is(err, ErrAccountRecoveryUnavailable) {
t.Fatalf("ValidateSelfAccountRecovery() error = %v, want ErrAccountRecoveryUnavailable", err)
}
var apiErr *ente.ApiError
if !errors.As(err, &apiErr) || apiErr.Code != accountRecoveryUnavailableCode || apiErr.HttpStatusCode != http.StatusGone {
t.Fatalf("ValidateSelfAccountRecovery() error = %v, want unavailable ApiError", err)
}
}
func TestAccountRecoveryLosesRaceToCleanupStageAdvance(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{
UserID: 82,
Email: "[email protected]",
CreationTime: 1,
})
insertKeyAttributes(t, db, userID)
insertScheduledDelete(t, db, userID)
userRepo := &repo.UserRepository{
DB: db,
SecretEncryptionKey: testutil.SecretEncryptionKey(),
HashingKey: testutil.HashingKey(),
}
if err := userRepo.Delete(userID); err != nil {
t.Fatalf("failed to delete user: %v", err)
}
controller := &UserController{
UserRepo: userRepo,
DataCleanupRepo: &cleanuprepo.Repository{DB: db},
SecretEncryptionKey: testutil.SecretEncryptionKey(),
HashingKey: testutil.HashingKey(),
}
cleanupTx, err := db.BeginTx(t.Context(), nil)
if err != nil {
t.Fatalf("failed to start cleanup transaction: %v", err)
}
defer cleanupTx.Rollback()
if _, err := cleanupTx.ExecContext(t.Context(),
`UPDATE data_cleanup SET stage = $1 WHERE user_id = $2`,
cleanupentity.Collection,
userID,
); err != nil {
t.Fatalf("failed to advance cleanup: %v", err)
}
gin.SetMode(gin.TestMode)
ctx, _ := gin.CreateTestContext(httptest.NewRecorder())
recoveryDone := make(chan error, 1)
go func() {
recoveryDone <- controller.HandleAccountRecovery(ctx, ente.RecoverAccountRequest{
UserID: userID,
EmailID: "[email protected]",
})
}()
waitForDataCleanupRowLock(t, db)
if err := cleanupTx.Commit(); err != nil {
t.Fatalf("failed to commit cleanup stage advance: %v", err)
}
select {
case err := <-recoveryDone:
if !errors.Is(err, ErrAccountRecoveryUnavailable) {
t.Fatalf("HandleAccountRecovery() error = %v, want ErrAccountRecoveryUnavailable", err)
}
case <-stdtime.After(2 * stdtime.Second):
t.Fatal("account recovery did not finish after cleanup committed")
}
if _, err := userRepo.Get(userID); !errors.Is(err, ente.ErrUserDeleted) {
t.Fatalf("user state after lost recovery race = %v, want deleted", err)
}
var stage cleanupentity.Stage
if err := db.QueryRow(`SELECT stage FROM data_cleanup WHERE user_id = $1`, userID).Scan(&stage); err != nil {
t.Fatalf("failed to read cleanup stage: %v", err)
}
if stage != cleanupentity.Collection {
t.Fatalf("cleanup stage = %q, want %q", stage, cleanupentity.Collection)
}
}
func waitForDataCleanupRowLock(t *testing.T, db *sql.DB) {
t.Helper()
deadline := stdtime.Now().Add(2 * stdtime.Second)
for {
var waiting bool
err := db.QueryRow(`SELECT EXISTS(
SELECT 1 FROM pg_stat_activity
WHERE datname = current_database()
AND pid <> pg_backend_pid()
AND wait_event_type = 'Lock'
AND query LIKE '%data_cleanup%'
AND query LIKE '%FOR UPDATE%'
)`).Scan(&waiting)
if err != nil {
t.Fatalf("failed to inspect recovery lock wait: %v", err)
}
if waiting {
return
}
if stdtime.Now().After(deadline) {
t.Fatal("account recovery did not wait for the cleanup row lock")
}
stdtime.Sleep(10 * stdtime.Millisecond)
}
}
func accountRecoveryToken(t *testing.T, controller *UserController, claim *enteJWT.WebCommonJWTClaim) string {
t.Helper()
token, err := controller.GetJWTTokenForClaim(claim)
if err != nil {
t.Fatalf("failed to create account recovery token: %v", err)
}
return token
}
func TestHandleAccountRecoveryTouchesContactsForResolvedEmailSync(t *testing.T) {
testutil.WithServerRoot(t)
viper.Reset()
if err := config.ConfigureViper("local"); err != nil {
t.Fatalf("failed to configure viper: %v", err)
}
t.Cleanup(viper.Reset)
db := testutil.RequireTestDB(t)
testutil.ResetTables(t, db)
t.Cleanup(func() {
testutil.ResetTables(t, db)
})
ownerID := testutil.InsertUser(t, db, testutil.UserFixture{
UserID: 1,
Email: "[email protected]",
CreationTime: 1,
})
contactUserID := testutil.InsertUser(t, db, testutil.UserFixture{
UserID: 82,
Email: "[email protected]",
CreationTime: 1,
})
insertKeyAttributes(t, db, contactUserID)
insertScheduledDelete(t, db, contactUserID)
objectCleanupRepo := &repo.ObjectCleanupRepository{DB: db}
contactsRepo := &contactrepo.Repository{
DB: db,
ObjectCleanupRepo: objectCleanupRepo,
SecretEncryptionKey: testutil.SecretEncryptionKey(),
}
contactID, err := contactsRepo.Create(t.Context(), ownerID, contactmodel.CreateRequest{
ContactUserID: contactUserID,
EncryptedKey: []byte("wrapped-key"),
EncryptedData: []byte("payload"),
})
if err != nil {
t.Fatalf("failed to create contact: %v", err)
}
created, err := contactsRepo.Get(t.Context(), ownerID, contactID)
if err != nil {
t.Fatalf("failed to fetch created contact: %v", err)
}
if created.Email == nil || *created.Email != "[email protected]" {
t.Fatalf("unexpected initial email: %v", created.Email)
}
userRepo := &repo.UserRepository{
DB: db,
SecretEncryptionKey: testutil.SecretEncryptionKey(),
HashingKey: testutil.HashingKey(),
}
if err := userRepo.Delete(contactUserID); err != nil {
t.Fatalf("failed to soft-delete contact user: %v", err)
}
gin.SetMode(gin.TestMode)
recorder := httptest.NewRecorder()
ctx, _ := gin.CreateTestContext(recorder)
ctx.Request = httptest.NewRequest("POST", "/", nil)
ctx.Set("req_id", "recovery-test")
controller := &UserController{
UserRepo: userRepo,
DataCleanupRepo: &cleanuprepo.Repository{DB: db},
ContactRepo: contactsRepo,
SecretEncryptionKey: testutil.SecretEncryptionKey(),
HashingKey: testutil.HashingKey(),
}
if err := controller.HandleAccountRecovery(ctx, ente.RecoverAccountRequest{
UserID: contactUserID,
EmailID: "[email protected]",
}); err != nil {
t.Fatalf("HandleAccountRecovery() error = %v", err)
}
diff, err := contactsRepo.GetDiff(t.Context(), ownerID, created.UpdatedAt, 10)
if err != nil {
t.Fatalf("GetDiff() error = %v", err)
}
if len(diff) != 1 {
t.Fatalf("diff length = %d, want 1", len(diff))
}
if diff[0].Email == nil || *diff[0].Email != "[email protected]" {
t.Fatalf("resolved email after recovery = %v, want updated email", diff[0].Email)
}
}
func TestHandleAccountRecoveryReportsEmailInUse(t *testing.T) {
testutil.WithServerRoot(t)
viper.Reset()
if err := config.ConfigureViper("local"); err != nil {
t.Fatalf("failed to configure viper: %v", err)
}
t.Cleanup(viper.Reset)
db := testutil.RequireTestDB(t)
testutil.ResetTables(t, db)
t.Cleanup(func() {
testutil.ResetTables(t, db)
})
deletedUserID := testutil.InsertUser(t, db, testutil.UserFixture{
UserID: 82,
Email: "[email protected]",
CreationTime: 1,
})
insertKeyAttributes(t, db, deletedUserID)
insertScheduledDelete(t, db, deletedUserID)
userRepo := &repo.UserRepository{
DB: db,
SecretEncryptionKey: testutil.SecretEncryptionKey(),
HashingKey: testutil.HashingKey(),
}
if err := userRepo.Delete(deletedUserID); err != nil {
t.Fatalf("failed to delete user: %v", err)
}
testutil.InsertUser(t, db, testutil.UserFixture{
UserID: 83,
Email: "[email protected]",
CreationTime: 1,
})
gin.SetMode(gin.TestMode)
ctx, _ := gin.CreateTestContext(httptest.NewRecorder())
controller := &UserController{
UserRepo: userRepo,
DataCleanupRepo: &cleanuprepo.Repository{DB: db},
SecretEncryptionKey: testutil.SecretEncryptionKey(),
HashingKey: testutil.HashingKey(),
}
err := controller.HandleAccountRecovery(ctx, ente.RecoverAccountRequest{
UserID: deletedUserID,
EmailID: "[email protected]",
})
if !errors.Is(err, ErrAccountRecoveryEmailInUse) {
t.Fatalf("HandleAccountRecovery() error = %v, want ErrAccountRecoveryEmailInUse", err)
}
var apiErr *ente.ApiError
if !errors.As(err, &apiErr) || apiErr.Code != accountRecoveryEmailInUseCode || apiErr.HttpStatusCode != http.StatusConflict {
t.Fatalf("HandleAccountRecovery() error = %v, want email-in-use ApiError", err)
}
}
func insertKeyAttributes(t *testing.T, db *sql.DB, userID int64) {
t.Helper()
_, err := db.Exec(
`INSERT INTO key_attributes(
user_id, kek_salt, encrypted_key, key_decryption_nonce,
public_key, encrypted_secret_key, secret_key_decryption_nonce, mem_limit, ops_limit
) VALUES($1, $2, $3, $4, $5, $6, $7, $8, $9)`,
userID,
"kek-salt",
"encrypted-key",
"key-nonce",
"public-key",
"encrypted-secret-key",
"secret-key-nonce",
int64(67108864),
int64(2),
)
if err != nil {
t.Fatalf("failed to insert key_attributes for user %d: %v", userID, err)
}
}
func insertScheduledDelete(t *testing.T, db *sql.DB, userID int64) {
t.Helper()
t.Cleanup(func() {
if _, err := db.Exec(`DELETE FROM data_cleanup WHERE user_id = $1`, userID); err != nil {
t.Errorf("failed to remove data_cleanup fixture for user %d: %v", userID, err)
}
})
_, err := db.Exec(
`INSERT INTO data_cleanup(user_id, stage, stage_schedule_time, stage_attempt_count)
VALUES($1, $2, $3, $4)`,
userID,
cleanupentity.Scheduled,
int64(1),
0,
)
if err != nil {
t.Fatalf("failed to insert scheduled delete row for user %d: %v", userID, err)
}
}