Skip to content

armgit / ente

Public Imported from GitHub
0

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

Bind push registrations to login sessions

AmanRajSinghMourya4c52ba4cf6c3
diff --git a/server/ente/push.go b/server/ente/push.go
index 31f77fd0f8..4dba725249 100644
--- a/server/ente/push.go
+++ b/server/ente/push.go
@@ -6,8 +6,9 @@ import (
)
type PushTokenRequest struct {
- FCMToken string `json:"fcmToken" binding:"required"`
- APNSToken string `json:"apnsToken"`
+ FCMToken string `json:"fcmToken" binding:"required"`
+ APNSToken string `json:"apnsToken"`
+ Platform *string `json:"platform" binding:"required,oneof=ios android"`
LastNotificationTime int64
}
diff --git a/server/migrations/149_push_token_registration.down.sql b/server/migrations/149_push_token_registration.down.sql
new file mode 100644
index 0000000000..ea6aec6bf9
--- /dev/null
+++ b/server/migrations/149_push_token_registration.down.sql
@@ -0,0 +1,3 @@
+ALTER TABLE push_tokens
+ DROP COLUMN session_token_hash,
+ DROP COLUMN platform;
diff --git a/server/migrations/149_push_token_registration.up.sql b/server/migrations/149_push_token_registration.up.sql
new file mode 100644
index 0000000000..a66692ece6
--- /dev/null
+++ b/server/migrations/149_push_token_registration.up.sql
@@ -0,0 +1,6 @@
+ALTER TABLE push_tokens
+ ADD COLUMN session_token_hash BYTEA,
+ ADD COLUMN platform TEXT NOT NULL DEFAULT 'ios' CHECK (platform IN ('ios', 'android'));
+
+CREATE INDEX push_tokens_session_token_hash_idx ON push_tokens (session_token_hash)
+ WHERE session_token_hash IS NOT NULL;
diff --git a/server/pkg/api/push.go b/server/pkg/api/push.go
index 7142cb55f7..63919466f7 100644
--- a/server/pkg/api/push.go
+++ b/server/pkg/api/push.go
@@ -16,13 +16,15 @@ type PushHandler struct {
}
func (h *PushHandler) AddToken(c *gin.Context) {
- var req ente.PushTokenRequest
+ platform := "ios"
+ req := ente.PushTokenRequest{Platform: &platform}
err := handler.BindJSON(c, &req)
if err != nil {
handler.Error(c, stacktrace.Propagate(err, ""))
return
}
- err = h.PushController.AddToken(auth.GetUserID(c.Request.Header), req)
+ sessionHash := auth.HashToken(auth.GetToken(c))
+ err = h.PushController.AddToken(auth.GetUserID(c.Request.Header), sessionHash[:], req)
if err != nil {
handler.Error(c, stacktrace.Propagate(err, ""))
return
diff --git a/server/pkg/api/push_test.go b/server/pkg/api/push_test.go
new file mode 100644
index 0000000000..6eca11673a
--- /dev/null
+++ b/server/pkg/api/push_test.go
@@ -0,0 +1,124 @@
+package api
+
+import (
+ "encoding/base64"
+ "fmt"
+ "net/http"
+ "net/http/httptest"
+ "strings"
+ "testing"
+
+ "github.com/ente/museum/ente"
+ "github.com/ente/museum/internal/testutil"
+ "github.com/ente/museum/pkg/controller"
+ "github.com/ente/museum/pkg/repo"
+ "github.com/ente/museum/pkg/utils/auth"
+ "github.com/gin-gonic/gin"
+ "github.com/stretchr/testify/require"
+)
+
+func TestPushRegistrationBindsRequestSession(t *testing.T) {
+ testutil.WithServerRoot(t)
+ db := testutil.RequireTestDB(t)
+ testutil.ResetTables(t, db)
+ t.Cleanup(func() { testutil.ResetTables(t, db) })
+ router := gin.New()
+ handler := PushHandler{PushController: &controller.PushController{PushRepo: &repo.PushTokenRepository{DB: db}}}
+ router.POST("/push/token", handler.AddToken)
+ for _, id := range []int64{1, 2} {
+ testutil.InsertUser(t, db, testutil.UserFixture{UserID: id, Email: fmt.Sprintf("user%[email protected]", id), CreationTime: 1})
+ session := fmt.Sprintf("session-%d", id)
+ require.NoError(t, (&repo.UserAuthRepository{DB: db}).AddToken(id, ente.Photos, session, "", ""))
+ body := fmt.Sprintf(`{"fcmToken":"device", "apnsToken":"apns", "sessionTokenHash":"%s"}`, base64.StdEncoding.EncodeToString([]byte("untrusted-session")))
+ request := httptest.NewRequest(http.MethodPost, "/push/token", strings.NewReader(body))
+ request.Header.Set("Content-Type", "application/json")
+ request.Header.Set("X-Auth-User-ID", fmt.Sprint(id))
+ request.Header.Set("X-Auth-Token", session)
+ response := httptest.NewRecorder()
+ router.ServeHTTP(response, request)
+ require.Equal(t, http.StatusOK, response.Code)
+ var owner int64
+ require.NoError(t, db.QueryRow(`SELECT user_id FROM push_tokens WHERE fcm_token = 'device'`).Scan(&owner))
+ require.Equal(t, id, owner)
+ }
+ oldHash := auth.HashToken("session-1")
+ _, err := (&repo.UserAuthRepository{DB: db}).RemoveTokenByHash(1, oldHash[:])
+ require.NoError(t, err)
+ for _, session := range []string{"session-1", "session-2"} {
+ request := httptest.NewRequest(http.MethodPost, "/push/token", strings.NewReader(`{"fcmToken":"device"}`))
+ request.Header.Set("Content-Type", "application/json")
+ request.Header.Set("X-Auth-User-ID", "1")
+ request.Header.Set("X-Auth-Token", session)
+ response := httptest.NewRecorder()
+ router.ServeHTTP(response, request)
+ require.Equal(t, http.StatusUnauthorized, response.Code)
+ var owner int64
+ require.NoError(t, db.QueryRow(`SELECT user_id FROM push_tokens WHERE fcm_token = 'device'`).Scan(&owner))
+ require.Equal(t, int64(2), owner)
+ }
+ var hash []byte
+ require.NoError(t, db.QueryRow(`SELECT session_token_hash FROM push_tokens WHERE fcm_token = 'device'`).Scan(&hash))
+ expected := auth.HashToken("session-2")
+ require.Equal(t, expected[:], hash)
+}
+
+func TestPushRegistrationPlatform(t *testing.T) {
+ testutil.WithServerRoot(t)
+ db := testutil.RequireTestDB(t)
+ testutil.ResetTables(t, db)
+ t.Cleanup(func() { testutil.ResetTables(t, db) })
+ for _, id := range []int64{1, 2} {
+ testutil.InsertUser(t, db, testutil.UserFixture{UserID: id, Email: fmt.Sprintf("user%[email protected]", id), CreationTime: 1})
+ }
+ router := gin.New()
+ handler := PushHandler{PushController: &controller.PushController{PushRepo: &repo.PushTokenRepository{DB: db}}}
+ router.POST("/push/token", handler.AddToken)
+ for _, tc := range []struct {
+ name, fields, platform string
+ userID int64
+ }{
+ {"legacy omission", `"apnsToken":"apns"`, "ios", 1},
+ {"android reassignment", `"platform":"android","apnsToken":null`, "android", 2},
+ {"ios reassignment", `"platform":"ios","apnsToken":"apns"`, "ios", 1},
+ {"omission without APNs", `"apnsToken":null`, "ios", 2},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ require.NoError(t, (&repo.UserAuthRepository{DB: db}).AddToken(tc.userID, ente.Photos, tc.name, "", ""))
+ body := fmt.Sprintf(`{"fcmToken":"device",%s}`, tc.fields)
+ request := httptest.NewRequest(http.MethodPost, "/push/token", strings.NewReader(body))
+ request.Header.Set("Content-Type", "application/json")
+ request.Header.Set("X-Auth-User-ID", fmt.Sprint(tc.userID))
+ request.Header.Set("X-Auth-Token", tc.name)
+ response := httptest.NewRecorder()
+ router.ServeHTTP(response, request)
+ require.Equal(t, http.StatusOK, response.Code, response.Body.String())
+ var owner int64
+ var platform, apns string
+ var hash []byte
+ require.NoError(t, db.QueryRow(`SELECT user_id, platform, apns_token, session_token_hash FROM push_tokens WHERE fcm_token = 'device'`).Scan(&owner, &platform, &apns, &hash))
+ require.Equal(t, tc.userID, owner)
+ require.Equal(t, tc.platform, platform)
+ expectedHash := auth.HashToken(tc.name)
+ require.Equal(t, expectedHash[:], hash)
+ if strings.Contains(tc.fields, "null") {
+ require.Empty(t, apns)
+ } else {
+ require.Equal(t, "apns", apns)
+ }
+ })
+ }
+ for _, platform := range []string{`""`, `"web"`, `"Android"`, `null`, `1`} {
+ t.Run("reject "+platform, func(t *testing.T) {
+ body := fmt.Sprintf(`{"fcmToken":"invalid-device","platform":%s}`, platform)
+ request := httptest.NewRequest(http.MethodPost, "/push/token", strings.NewReader(body))
+ request.Header.Set("Content-Type", "application/json")
+ request.Header.Set("X-Auth-User-ID", "1")
+ response := httptest.NewRecorder()
+ router.ServeHTTP(response, request)
+ require.Equal(t, http.StatusBadRequest, response.Code, response.Body.String())
+ var count int
+ require.NoError(t, db.QueryRow(`SELECT count(*) FROM push_tokens WHERE fcm_token = 'invalid-device'`).Scan(&count))
+ require.Zero(t, count)
+ })
+ }
+}
diff --git a/server/pkg/controller/push.go b/server/pkg/controller/push.go
index 4b10a8dffc..ee779f63ba 100644
--- a/server/pkg/controller/push.go
+++ b/server/pkg/controller/push.go
@@ -99,8 +99,8 @@ func newFCMClient() (*fcmClient, error) {
}, nil
}
-func (c *PushController) AddToken(userID int64, token ente.PushTokenRequest) error {
- return stacktrace.Propagate(c.PushRepo.AddToken(userID, token), "")
+func (c *PushController) AddToken(userID int64, sessionTokenHash []byte, token ente.PushTokenRequest) error {
+ return stacktrace.Propagate(c.PushRepo.AddToken(userID, sessionTokenHash, token), "")
}
func (c *PushController) RemoveTokensForUser(userID int64) error {
diff --git a/server/pkg/repo/push.go b/server/pkg/repo/push.go
index dec90f7590..4d3c010c37 100644
--- a/server/pkg/repo/push.go
+++ b/server/pkg/repo/push.go
@@ -13,16 +13,33 @@ type PushTokenRepository struct {
DB *sql.DB
}
-func (repo *PushTokenRepository) AddToken(userID int64, token ente.PushTokenRequest) error {
- _, err := repo.DB.Exec(`INSERT INTO push_tokens(user_id, fcm_token, apns_token) VALUES($1, $2, $3)
+func (repo *PushTokenRepository) AddToken(userID int64, sessionTokenHash []byte, token ente.PushTokenRequest) error {
+ result, err := repo.DB.Exec(`INSERT INTO push_tokens(user_id, fcm_token, apns_token, session_token_hash, platform)
+ SELECT user_id, $2, $3, token_hash, COALESCE($5, 'ios') FROM tokens
+ WHERE user_id = $1 AND token_hash = $4 AND is_deleted = false FOR SHARE
ON CONFLICT (fcm_token) DO UPDATE
- SET apns_token = $3`,
- userID, token.FCMToken, token.APNSToken)
- return stacktrace.Propagate(err, "")
+ SET user_id = $1, apns_token = $3, session_token_hash = $4, platform = EXCLUDED.platform`,
+ userID, token.FCMToken, token.APNSToken, sessionTokenHash, token.Platform)
+ if err != nil {
+ return stacktrace.Propagate(err, "")
+ }
+ count, err := result.RowsAffected()
+ if err != nil {
+ return stacktrace.Propagate(err, "")
+ }
+ if count == 0 {
+ return ente.ErrAuthenticationRequired
+ }
+ return nil
}
func (repo *PushTokenRepository) GetTokensToBeNotified(lastNotificationTime int64, limit int) ([]ente.PushToken, error) {
- rows, err := repo.DB.Query(`SELECT user_id, fcm_token, created_at, last_notified_at FROM push_tokens WHERE last_notified_at < $1 LIMIT $2`, lastNotificationTime, limit)
+ rows, err := repo.DB.Query(`SELECT p.user_id, p.fcm_token, p.created_at, p.last_notified_at FROM push_tokens p
+ WHERE p.platform = 'ios' AND p.last_notified_at < $1
+ AND (p.session_token_hash IS NULL OR EXISTS (
+ SELECT 1 FROM tokens t WHERE t.token_hash = p.session_token_hash
+ AND t.user_id = p.user_id AND t.is_deleted = false
+ )) LIMIT $2`, lastNotificationTime, limit)
if err != nil {
return nil, stacktrace.Propagate(err, "")
}
diff --git a/server/pkg/repo/push_test.go b/server/pkg/repo/push_test.go
new file mode 100644
index 0000000000..39588da831
--- /dev/null
+++ b/server/pkg/repo/push_test.go
@@ -0,0 +1,174 @@
+package repo
+
+import (
+ "crypto/sha256"
+ "fmt"
+ "os"
+ "testing"
+ "time"
+
+ "github.com/ente/museum/ente"
+ "github.com/ente/museum/internal/testutil"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+)
+
+func TestPushTokenRegistrationMigration(t *testing.T) {
+ testutil.WithServerRoot(t)
+ db := testutil.RequireTestDB(t)
+ tx, err := db.Begin()
+ require.NoError(t, err)
+ defer tx.Rollback()
+ _, err = tx.Exec(`CREATE TEMP TABLE push_tokens (fcm_token TEXT, apns_token TEXT) ON COMMIT DROP;
+ INSERT INTO push_tokens VALUES ('with-apns', 'apns'), ('without-apns', '');`)
+ require.NoError(t, err)
+ up, err := os.ReadFile("migrations/149_push_token_registration.up.sql")
+ require.NoError(t, err)
+ _, err = tx.Exec(string(up))
+ require.NoError(t, err)
+ _, err = tx.Exec(`INSERT INTO push_tokens (fcm_token) VALUES ('old-server')`)
+ require.NoError(t, err)
+ var count int
+ require.NoError(t, tx.QueryRow(`SELECT count(*) FROM push_tokens WHERE platform = 'ios' AND session_token_hash IS NULL`).Scan(&count))
+ require.Equal(t, 3, count)
+ _, err = tx.Exec(`UPDATE push_tokens SET platform = 'android' WHERE fcm_token = 'without-apns'`)
+ require.NoError(t, err)
+ down, err := os.ReadFile("migrations/149_push_token_registration.down.sql")
+ require.NoError(t, err)
+ _, err = tx.Exec(string(down))
+ require.NoError(t, err)
+ require.NoError(t, tx.QueryRow(`SELECT count(*) FROM push_tokens`).Scan(&count))
+ require.Equal(t, 3, count)
+}
+
+func TestGetTokensToBeNotifiedFiltersPlatformBeforeLimit(t *testing.T) {
+ testutil.WithServerRoot(t)
+ db := testutil.RequireTestDB(t)
+ testutil.ResetTables(t, db)
+ t.Cleanup(func() { testutil.ResetTables(t, db) })
+ testutil.InsertUser(t, db, testutil.UserFixture{UserID: 1, Email: "[email protected]", CreationTime: 1})
+ _, err := db.Exec(`INSERT INTO push_tokens (user_id, fcm_token, platform, last_notified_at) VALUES
+ (1, 'android-one', 'android', 0), (1, 'android-two', 'android', 0),
+ (1, 'ios-one', 'ios', 0), (1, 'ios-two', 'ios', 0), (1, 'ios-recent', 'ios', 100)`)
+ require.NoError(t, err)
+ r := PushTokenRepository{DB: db}
+ tokens, err := r.GetTokensToBeNotified(100, 2)
+ require.NoError(t, err)
+ var fcmTokens []string
+ for _, token := range tokens {
+ fcmTokens = append(fcmTokens, token.FCMToken)
+ }
+ require.ElementsMatch(t, []string{"ios-one", "ios-two"}, fcmTokens)
+}
+
+func TestPeriodicPushExcludesRevokedSessions(t *testing.T) {
+ testutil.WithServerRoot(t)
+ db := testutil.RequireTestDB(t)
+ testutil.ResetTables(t, db)
+ t.Cleanup(func() { testutil.ResetTables(t, db) })
+ for _, id := range []int64{1, 2} {
+ testutil.InsertUser(t, db, testutil.UserFixture{UserID: id, Email: fmt.Sprintf("user%[email protected]", id), CreationTime: 1})
+ }
+ authRepo := &UserAuthRepository{DB: db}
+ for _, session := range []struct {
+ token string
+ userID int64
+ }{
+ {"active", 1}, {"revoked", 1}, {"other-user", 2},
+ } {
+ require.NoError(t, authRepo.AddToken(session.userID, ente.Photos, session.token, "", ""))
+ }
+ revokedHash := sha256.Sum256([]byte("revoked"))
+ _, err := authRepo.RemoveTokenByHash(1, revokedHash[:])
+ require.NoError(t, err)
+ for _, token := range []string{"active", "revoked", "other-user", "missing"} {
+ hash := sha256.Sum256([]byte(token))
+ _, err := db.Exec(`INSERT INTO push_tokens(user_id, fcm_token, session_token_hash, last_notified_at) VALUES(1, $1, $2, 0)`, token, hash[:])
+ require.NoError(t, err)
+ }
+ _, err = db.Exec(`INSERT INTO push_tokens(user_id, fcm_token, last_notified_at) VALUES(1, 'legacy', 0)`)
+ require.NoError(t, err)
+ r := &PushTokenRepository{DB: db}
+ tokens, err := r.GetTokensToBeNotified(1, 10)
+ require.NoError(t, err)
+ var fcmTokens []string
+ for _, token := range tokens {
+ fcmTokens = append(fcmTokens, token.FCMToken)
+ }
+ require.ElementsMatch(t, []string{"active", "legacy"}, fcmTokens)
+}
+
+func TestPushRegistrationRejectsRevokedSessionAfterAccountSwitch(t *testing.T) {
+ testutil.WithServerRoot(t)
+ db := testutil.RequireTestDB(t)
+ testutil.ResetTables(t, db)
+ t.Cleanup(func() { testutil.ResetTables(t, db) })
+ authRepo := &UserAuthRepository{DB: db}
+ pushRepo := &PushTokenRepository{DB: db}
+ for _, id := range []int64{1, 2} {
+ testutil.InsertUser(t, db, testutil.UserFixture{UserID: id, Email: fmt.Sprintf("user%[email protected]", id), CreationTime: 1})
+ require.NoError(t, authRepo.AddToken(id, ente.Photos, fmt.Sprint(id), "", ""))
+ }
+ oldHash, newHash := sha256.Sum256([]byte("1")), sha256.Sum256([]byte("2"))
+ request := ente.PushTokenRequest{FCMToken: "device"}
+ require.NoError(t, pushRepo.AddToken(1, oldHash[:], request))
+ _, err := authRepo.RemoveTokenByHash(1, oldHash[:])
+ require.NoError(t, err)
+ var count int
+ require.NoError(t, db.QueryRow(`SELECT count(*) FROM push_tokens`).Scan(&count))
+ require.Zero(t, count)
+ require.NoError(t, pushRepo.AddToken(2, newHash[:], request))
+ for _, tc := range []struct {
+ name string
+ userID int64
+ hash []byte
+ }{
+ {"revoked", 1, oldHash[:]}, {"wrong owner", 1, newHash[:]}, {"missing", 1, nil},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ require.ErrorIs(t, pushRepo.AddToken(tc.userID, tc.hash, request), ente.ErrAuthenticationRequired)
+ var owner int64
+ var hash []byte
+ require.NoError(t, db.QueryRow(`SELECT user_id, session_token_hash FROM push_tokens WHERE fcm_token = 'device'`).Scan(&owner, &hash))
+ require.Equal(t, int64(2), owner)
+ require.Equal(t, newHash[:], hash)
+ })
+ }
+}
+
+func TestPushRegistrationWaitsForSessionRevocation(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})
+ require.NoError(t, (&UserAuthRepository{DB: db}).AddToken(userID, ente.Photos, "session", "", ""))
+ hash := sha256.Sum256([]byte("session"))
+ revocation, err := db.Begin()
+ require.NoError(t, err)
+ defer revocation.Rollback()
+ _, err = revocation.Exec(`UPDATE tokens SET is_deleted = true WHERE token_hash = $1`, hash[:])
+ require.NoError(t, err)
+ var pid int
+ require.NoError(t, revocation.QueryRow(`SELECT pg_backend_pid()`).Scan(&pid))
+ done := make(chan error, 1)
+ go func() {
+ done <- (&PushTokenRepository{DB: db}).AddToken(userID, hash[:], ente.PushTokenRequest{FCMToken: "device"})
+ }()
+ require.EventuallyWithT(t, func(collect *assert.CollectT) {
+ var blocked bool
+ require.NoError(collect, db.QueryRow(`SELECT EXISTS(SELECT 1 FROM pg_stat_activity
+ WHERE datname = current_database() AND $1 = ANY(pg_blocking_pids(pid)))`, pid).Scan(&blocked))
+ require.True(collect, blocked)
+ }, 5*time.Second, 10*time.Millisecond)
+ require.NoError(t, revocation.Commit())
+ select {
+ case err := <-done:
+ require.ErrorIs(t, err, ente.ErrAuthenticationRequired)
+ case <-time.After(5 * time.Second):
+ t.Fatal("push registration did not finish")
+ }
+ var count int
+ require.NoError(t, db.QueryRow(`SELECT count(*) FROM push_tokens`).Scan(&count))
+ require.Zero(t, count)
+}
diff --git a/server/pkg/repo/userauth.go b/server/pkg/repo/userauth.go
index 0491d4d95c..09596fba5d 100644
--- a/server/pkg/repo/userauth.go
+++ b/server/pkg/repo/userauth.go
@@ -338,31 +338,44 @@ func (repo *UserAuthRepository) RemoveTokensForApps(userID int64, apps []ente.Ap
}
func (repo *UserAuthRepository) markTokensDeleted(query string, args ...interface{}) ([]RevokedToken, error) {
- return markTokensDeleted(repo.DB, query, args...)
-}
-
-type rowsQueryer interface {
- Query(query string, args ...any) (*sql.Rows, error)
+ tx, err := repo.DB.Begin()
+ if err != nil {
+ return nil, stacktrace.Propagate(err, "")
+ }
+ defer tx.Rollback()
+ tokens, err := markTokensDeleted(tx, query, args...)
+ if err != nil {
+ return nil, err
+ }
+ if err = tx.Commit(); err != nil {
+ return nil, stacktrace.Propagate(err, "")
+ }
+ return tokens, nil
}
-func markTokensDeleted(queryer rowsQueryer, query string, args ...interface{}) ([]RevokedToken, error) {
- rows, err := queryer.Query(query, args...)
+func markTokensDeleted(tx *sql.Tx, query string, args ...interface{}) ([]RevokedToken, error) {
+ rows, err := tx.Query(query, args...)
if err != nil {
return nil, stacktrace.Propagate(err, "")
}
defer rows.Close()
tokens := make([]RevokedToken, 0)
+ var hashes pq.ByteaArray
for rows.Next() {
var token RevokedToken
if err = rows.Scan(&token.App, &token.TokenHash); err != nil {
return nil, stacktrace.Propagate(err, "")
}
tokens = append(tokens, token)
+ hashes = append(hashes, token.TokenHash)
}
if err = rows.Err(); err != nil {
return nil, stacktrace.Propagate(err, "")
}
+ if _, err = tx.Exec(`DELETE FROM push_tokens WHERE session_token_hash = ANY($1)`, hashes); err != nil {
+ return nil, stacktrace.Propagate(err, "")
+ }
return tokens, nil
}
diff --git a/server/pkg/repo/userauth_test.go b/server/pkg/repo/userauth_test.go
index 576bb5d0cb..f67605c907 100644
--- a/server/pkg/repo/userauth_test.go
+++ b/server/pkg/repo/userauth_test.go
@@ -6,12 +6,16 @@ import (
"crypto/sha256"
"database/sql"
"errors"
+ "fmt"
"testing"
+ gotime "time"
"github.com/ente/museum/ente"
"github.com/ente/museum/internal/testutil"
"github.com/ente/museum/pkg/utils/time"
"github.com/google/uuid"
+ "github.com/lib/pq"
+ "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
@@ -251,3 +255,134 @@ func TestPasswordUpdateRollsBackRecoveryAuthorization(t *testing.T) {
userID, oldSRPUserID, tokenHash[:], recoveryID, ente.RecoveryStatusReady, browserTokenHash).Scan(&unchanged))
require.True(t, unchanged)
}
+
+func TestPushTokensRemovedOnSessionRevocation(t *testing.T) {
+ testutil.WithServerRoot(t)
+ db := testutil.RequireTestDB(t)
+ for _, tc := range []struct {
+ name string
+ remaining []string
+ }{
+ {"session", []string{"other", "locker", "other-account"}},
+ {"other sessions", []string{"current", "rotated", "other-account"}},
+ {"apps", []string{"locker", "other-account"}},
+ {"wrong user", []string{"current", "rotated", "other", "locker", "other-account"}},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ testutil.ResetTables(t, db)
+ t.Cleanup(func() { testutil.ResetTables(t, db) })
+ for _, id := range []int64{1, 2} {
+ testutil.InsertUser(t, db, testutil.UserFixture{UserID: id, Email: fmt.Sprintf("user%[email protected]", id), CreationTime: 1})
+ }
+ r := &UserAuthRepository{DB: db}
+ for _, session := range []struct {
+ token string
+ userID int64
+ app ente.App
+ }{
+ {"current", 1, ente.Photos}, {"other", 1, ente.Photos},
+ {"locker", 1, ente.Locker}, {"other-account", 2, ente.Photos},
+ } {
+ require.NoError(t, r.AddToken(session.userID, session.app, session.token, "", ""))
+ hash := sha256.Sum256([]byte(session.token))
+ _, err := db.Exec(`INSERT INTO push_tokens(user_id, fcm_token, session_token_hash) VALUES($1, $2, $3)`, session.userID, session.token, hash[:])
+ require.NoError(t, err)
+ }
+ currentHash := sha256.Sum256([]byte("current"))
+ _, err := db.Exec(`INSERT INTO push_tokens(user_id, fcm_token, session_token_hash) VALUES(1, 'rotated', $1)`, currentHash[:])
+ require.NoError(t, err)
+ var revoked []RevokedToken
+ switch tc.name {
+ case "session":
+ revoked, err = r.RemoveTokenByHash(1, currentHash[:])
+ case "other sessions":
+ revoked, err = r.RemoveAllOtherTokensByHash(1, currentHash[:])
+ case "apps":
+ revoked, err = r.RemoveTokensForApps(1, []ente.App{ente.Photos})
+ case "wrong user":
+ revoked, err = r.RemoveTokenByHash(2, currentHash[:])
+ }
+ require.NoError(t, err)
+ for _, session := range revoked {
+ var deleted bool
+ require.NoError(t, db.QueryRow(`SELECT is_deleted FROM tokens WHERE token_hash = $1`, session.TokenHash).Scan(&deleted))
+ require.True(t, deleted)
+ }
+ var remaining pq.StringArray
+ require.NoError(t, db.QueryRow(`SELECT ARRAY(SELECT fcm_token FROM push_tokens)`).Scan(&remaining))
+ require.ElementsMatch(t, tc.remaining, []string(remaining))
+ })
+ }
+}
+
+func TestPushTokenCleanupFailureRollsBackSessionRevocation(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})
+ r := &UserAuthRepository{DB: db}
+ require.NoError(t, r.AddToken(userID, ente.Photos, "session", "", ""))
+ hash := sha256.Sum256([]byte("session"))
+ _, err := db.Exec(`INSERT INTO push_tokens(user_id, fcm_token, session_token_hash) VALUES($1, 'device', $2)`, userID, hash[:])
+ require.NoError(t, err)
+ _, err = db.Exec(`CREATE FUNCTION fail_push_cleanup() RETURNS trigger LANGUAGE plpgsql AS $$
+ BEGIN RAISE EXCEPTION 'push cleanup failed'; END;
+ $$;
+ CREATE TRIGGER fail_push_cleanup BEFORE DELETE ON push_tokens
+ FOR EACH ROW EXECUTE FUNCTION fail_push_cleanup()`)
+ require.NoError(t, err)
+ t.Cleanup(func() {
+ _, err := db.Exec(`DROP TRIGGER fail_push_cleanup ON push_tokens; DROP FUNCTION fail_push_cleanup()`)
+ require.NoError(t, err)
+ })
+ _, err = r.RemoveTokenByHash(userID, hash[:])
+ require.ErrorContains(t, err, "push cleanup failed")
+ var deleted bool
+ require.NoError(t, db.QueryRow(`SELECT is_deleted FROM tokens WHERE token_hash = $1`, hash[:]).Scan(&deleted))
+ require.False(t, deleted)
+ var count int
+ require.NoError(t, db.QueryRow(`SELECT count(*) FROM push_tokens WHERE fcm_token = 'device'`).Scan(&count))
+ require.Equal(t, 1, count)
+}
+
+func TestSessionRevocationDeletesConcurrentPushRegistration(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})
+ r := &UserAuthRepository{DB: db}
+ require.NoError(t, r.AddToken(userID, ente.Photos, "session", "", ""))
+ hash := sha256.Sum256([]byte("session"))
+ registration, err := db.Begin()
+ require.NoError(t, err)
+ defer registration.Rollback()
+ var sessionUserID int64
+ require.NoError(t, registration.QueryRow(`SELECT user_id FROM tokens WHERE token_hash = $1 FOR SHARE`, hash[:]).Scan(&sessionUserID))
+ _, err = registration.Exec(`INSERT INTO push_tokens(user_id, fcm_token, session_token_hash) VALUES($1, 'device', $2)`, userID, hash[:])
+ require.NoError(t, err)
+ var pid int
+ require.NoError(t, registration.QueryRow(`SELECT pg_backend_pid()`).Scan(&pid))
+ done := make(chan error, 1)
+ go func() {
+ _, err := r.RemoveTokenByHash(userID, hash[:])
+ done <- err
+ }()
+ require.EventuallyWithT(t, func(collect *assert.CollectT) {
+ var blocked bool
+ require.NoError(collect, db.QueryRow(`SELECT EXISTS(SELECT 1 FROM pg_stat_activity
+ WHERE datname = current_database() AND $1 = ANY(pg_blocking_pids(pid)))`, pid).Scan(&blocked))
+ require.True(collect, blocked)
+ }, 5*gotime.Second, 10*gotime.Millisecond)
+ require.NoError(t, registration.Commit())
+ select {
+ case err := <-done:
+ require.NoError(t, err)
+ case <-gotime.After(5 * gotime.Second):
+ t.Fatal("session revocation did not finish")
+ }
+ var count int
+ require.NoError(t, db.QueryRow(`SELECT count(*) FROM push_tokens`).Scan(&count))
+ require.Zero(t, count)
+}