Skip to content

armgit / ente

Public Imported from GitHub
0

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

18.3 KB
Raw Blame
package repo

import (
	"bytes"
	"context"
	"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"
)

func TestTokenHashTrigger(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,
	})
	rawToken := "existing-bearer-token-Ο€"
	var storedToken sql.NullString
	var storedHash []byte
	err := db.QueryRow(
		`INSERT INTO tokens(user_id, token, token_hash, creation_time, last_used_at, app)
		 VALUES($1, $2, $3, $4, $5, $6)
		 RETURNING token, token_hash`,
		userID, rawToken, bytes.Repeat([]byte{0xff}, sha256.Size), 1, 1, ente.Photos,
	).Scan(&storedToken, &storedHash)
	if err != nil {
		t.Fatalf("failed to insert token: %v", err)
	}

	expectedHash := sha256.Sum256([]byte(rawToken))
	if storedToken.Valid {
		t.Fatalf("raw token was stored: %q", storedToken.String)
	}
	if !bytes.Equal(storedHash, expectedHash[:]) {
		t.Fatalf("unexpected token hash: got %x want %x", storedHash, expectedHash)
	}

	rawToken = "updated-bearer-token"
	if err := db.QueryRow(
		`UPDATE tokens SET token = $1 WHERE user_id = $2 RETURNING token, token_hash`, rawToken, userID,
	).Scan(&storedToken, &storedHash); err != nil {
		t.Fatalf("failed to update token: %v", err)
	}
	if storedToken.Valid {
		t.Fatalf("updated raw token was stored: %q", storedToken.String)
	}
	expectedHash = sha256.Sum256([]byte(rawToken))
	if !bytes.Equal(storedHash, expectedHash[:]) {
		t.Fatalf("unexpected updated token hash: got %x want %x", storedHash, expectedHash)
	}

	explicitHash := sha256.Sum256([]byte("explicit-token-hash"))
	err = db.QueryRow(
		`INSERT INTO tokens(user_id, token_hash, creation_time, last_used_at, app)
		 VALUES($1, $2, $3, $4, $5)
		 RETURNING token, token_hash`,
		userID, explicitHash[:], 2, 2, ente.Photos,
	).Scan(&storedToken, &storedHash)
	if err != nil {
		t.Fatalf("failed to insert explicit token hash: %v", err)
	}
	if storedToken.Valid || !bytes.Equal(storedHash, explicitHash[:]) {
		t.Fatalf("explicit token hash changed: token=%q hash=%x", storedToken.String, storedHash)
	}
	if err := db.QueryRow(
		`UPDATE tokens SET token = NULL WHERE token_hash = $1 RETURNING token_hash`, explicitHash[:],
	).Scan(&storedHash); err != nil {
		t.Fatalf("failed to clear token: %v", err)
	}
	if !bytes.Equal(storedHash, explicitHash[:]) {
		t.Fatalf("clearing token changed hash: got %x want %x", storedHash, explicitHash)
	}
}

func TestUserAuthRepositoryRemoveOTTReturnsWhetherRowWasConsumed(t *testing.T) {
	testutil.WithServerRoot(t)

	db := testutil.RequireTestDB(t)
	if _, err := db.Exec(`TRUNCATE TABLE otts RESTART IDENTITY CASCADE`); err != nil {
		t.Fatalf("failed to reset otts: %v", err)
	}
	t.Cleanup(func() {
		if _, err := db.Exec(`TRUNCATE TABLE otts RESTART IDENTITY CASCADE`); err != nil {
			t.Errorf("failed to reset otts: %v", err)
		}
	})

	repo := &UserAuthRepository{DB: db}
	emailHash := "duplicate-verify-email-hash"
	ott := "123456"
	app := ente.Photos

	err := repo.AddOTT(emailHash, app, ott, time.Microseconds()+60*1000000)
	if err != nil {
		t.Fatalf("failed to add ott: %v", err)
	}

	removed, err := repo.RemoveOTT(emailHash, ott, app)
	if err != nil {
		t.Fatalf("first remove returned error: %v", err)
	}
	if !removed {
		t.Fatal("first remove should consume the ott")
	}

	removed, err = repo.RemoveOTT(emailHash, ott, app)
	if err != nil {
		t.Fatalf("second remove returned error: %v", err)
	}
	if removed {
		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)
	}
}

func TestAddLoginResultRejectsInvalidatedCredentials(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})
	keyAttributes := ente.KeyAttributes{
		KEKSalt: "old-salt", EncryptedKey: "old-key", KeyDecryptionNonce: "old-nonce",
		PublicKey: "public-key", EncryptedSecretKey: "secret-key", SecretKeyDecryptionNonce: "secret-nonce",
		MemLimit: 1, OpsLimit: 1,
	}
	if err := (&UserRepository{DB: db}).SetKeyAttributes(userID, keyAttributes); err != nil {
		t.Fatal(err)
	}
	if _, err := db.Exec(`INSERT INTO srp_auth(user_id, srp_user_id, salt, verifier) VALUES($1, '00000000-0000-0000-0000-000000000001', 'old-srp-salt', 'old-verifier')`, userID); err != nil {
		t.Fatal(err)
	}
	repo := &UserAuthRepository{DB: db}
	srpAuth, err := repo.GetSRPAuthEntity(context.Background(), userID)
	if err != nil {
		t.Fatal(err)
	}
	if _, err := db.Exec(`UPDATE key_attributes SET encrypted_key = 'new-key' WHERE user_id = $1`, userID); err != nil {
		t.Fatal(err)
	}

	err = repo.AddLoginResult(context.Background(), userID, srpAuth, &keyAttributes, ente.Photos, "token", "", "", "", "", 0, false)
	if !errors.Is(err, ente.ErrAuthenticationRequired) {
		t.Fatalf("stale key attributes returned %v", err)
	}
	if _, err = db.Exec(`UPDATE key_attributes SET encrypted_key = 'old-key' WHERE user_id = $1`, userID); err != nil {
		t.Fatal(err)
	}
	if _, err = db.Exec(`UPDATE srp_auth SET verifier = 'new-verifier' WHERE user_id = $1`, userID); err != nil {
		t.Fatal(err)
	}
	err = repo.AddLoginResult(context.Background(), userID, srpAuth, &keyAttributes, ente.Photos, "token", "", "", "", "", 0, false)
	if !errors.Is(err, ente.ErrInvalidPassword) {
		t.Fatalf("stale SRP returned %v", err)
	}
	var tokenCount int
	if err := db.QueryRow(`SELECT COUNT(*) FROM tokens WHERE user_id = $1`, userID).Scan(&tokenCount); err != nil || tokenCount != 0 {
		t.Fatalf("token count = %d, err = %v", tokenCount, err)
	}
	require.NoError(t, (&UserRepository{DB: db}).Delete(userID))
	err = repo.AddLoginResult(context.Background(), userID, srpAuth, &keyAttributes, ente.Photos, "token", "", "", "", "", 0, false)
	require.ErrorIs(t, err, ente.ErrUserDeleted)
}

func TestAddLoginResultOrdersSRPLoginWithEmailMFAUpdate(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})
	_, err := db.Exec(`INSERT INTO srp_auth(user_id, srp_user_id, salt, verifier) VALUES($1, $2, 'salt', 'verifier')`, userID, uuid.New())
	require.NoError(t, err)
	repo := &UserAuthRepository{DB: db}
	srpAuth, err := repo.GetSRPAuthEntity(t.Context(), userID)
	require.NoError(t, err)

	update, err := db.BeginTx(t.Context(), nil)
	require.NoError(t, err)
	t.Cleanup(func() { _ = update.Rollback() })
	_, err = update.ExecContext(t.Context(), `UPDATE users SET email_mfa = true WHERE user_id = $1`, userID)
	require.NoError(t, err)
	var updatePID int
	require.NoError(t, update.QueryRowContext(t.Context(), `SELECT pg_backend_pid()`).Scan(&updatePID))
	loginResult := make(chan error, 1)
	go func() {
		loginResult <- repo.AddLoginResult(t.Context(), userID, srpAuth, nil, ente.Photos, "srp-token", "", "", "", "", 0, true)
	}()
	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)))`, updatePID).Scan(&blocked))
		require.True(collect, blocked)
	}, 5*gotime.Second, 10*gotime.Millisecond)
	require.NoError(t, update.Commit())
	err = <-loginResult
	var apiError *ente.ApiError
	require.ErrorAs(t, err, &apiError)
	require.Equal(t, ente.ErrorCode("EMAIL_MFA_ENABLED"), apiError.Code)
	require.Equal(t, 409, apiError.HttpStatusCode)

	err = repo.AddLoginResult(t.Context(), userID, srpAuth, nil, ente.Photos, "", "", "", "", "srp-pending", time.Microseconds()+1000000, true)
	require.ErrorAs(t, err, &apiError)
	require.Equal(t, ente.ErrorCode("EMAIL_MFA_ENABLED"), apiError.Code)
	var issued int
	require.NoError(t, db.QueryRow(`SELECT COUNT(*) FROM tokens WHERE user_id = $1`, userID).Scan(&issued))
	require.Zero(t, issued)
	require.NoError(t, db.QueryRow(`SELECT COUNT(*) FROM two_factor_sessions WHERE user_id = $1`, userID).Scan(&issued))
	require.Zero(t, issued)

	require.NoError(t, repo.AddLoginResult(t.Context(), userID, srpAuth, nil, ente.Photos, "email-token", "", "", "", "", 0, false))
	require.NoError(t, db.QueryRow(`SELECT COUNT(*) FROM tokens WHERE user_id = $1`, userID).Scan(&issued))
	require.Equal(t, 1, issued)
}

func TestPasswordUpdateRollsBackRecoveryAuthorization(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})
	contactID := testutil.InsertUser(t, db, testutil.UserFixture{Email: "[email protected]", CreationTime: 1})
	require.NoError(t, (&UserRepository{DB: db}).SetKeyAttributes(userID, ente.KeyAttributes{
		KEKSalt: "old-salt", EncryptedKey: "old-key", KeyDecryptionNonce: "old-nonce",
		PublicKey: "public-key", EncryptedSecretKey: "secret-key", SecretKeyDecryptionNonce: "secret-nonce",
		MemLimit: 1, OpsLimit: 1,
	}))
	oldSRPUserID, recoveryID := uuid.New(), uuid.New()
	tokenHash := sha256.Sum256([]byte("auth-token"))
	browserTokenHash := []byte("space-token")
	_, err := db.Exec(`INSERT INTO srp_auth(user_id, srp_user_id, salt, verifier) VALUES($1, $2, 'old-srp-salt', 'old-verifier')`, userID, oldSRPUserID)
	require.NoError(t, err)
	_, err = db.Exec(`INSERT INTO tokens(user_id, token_hash, creation_time, app) VALUES($1, $2, 1, $3)`, userID, tokenHash[:], ente.Photos)
	require.NoError(t, err)
	_, err = db.Exec(`INSERT INTO emergency_recovery(id, user_id, emergency_contact_id, status) VALUES($1, $2, $3, $4)`, recoveryID, userID, contactID, ente.RecoveryStatusReady)
	require.NoError(t, err)
	_, err = db.Exec(`INSERT INTO space_browser_sessions(token_hash, user_id, session_wrap_key, expires_at) VALUES($1, $2, 'wrap-key', 1)`, browserTokenHash, userID)
	require.NoError(t, err)

	authorizationErr := errors.New("authorization failed")
	_, err = (&UserAuthRepository{DB: db}).InsertOrUpdateSRPAuthAndKeyAttr(t.Context(), userID,
		ente.UpdateKeysRequest{KEKSalt: "new-salt", EncryptedKey: "new-key", KeyDecryptionNonce: "new-nonce", MemLimit: 2, OpsLimit: 2},
		&ente.SRPSetupEntity{SRPUserID: uuid.New(), Salt: "new-srp-salt", Verifier: "new-verifier"}, true, nil, false,
		func(ctx context.Context, tx *sql.Tx) error {
			if _, err := tx.ExecContext(ctx, `UPDATE emergency_recovery SET status=$1 WHERE id=$2`, ente.RecoveryStatusRecovered, recoveryID); err != nil {
				return err
			}
			if _, err := tx.ExecContext(ctx, `DELETE FROM space_browser_sessions WHERE user_id=$1`, userID); err != nil {
				return err
			}
			return authorizationErr
		})
	require.ErrorIs(t, err, authorizationErr)

	var unchanged bool
	require.NoError(t, db.QueryRow(`SELECT
		EXISTS (SELECT FROM srp_auth WHERE user_id=$1 AND srp_user_id=$2 AND salt='old-srp-salt' AND verifier='old-verifier') AND
		EXISTS (SELECT FROM key_attributes WHERE user_id=$1 AND kek_salt='old-salt' AND encrypted_key='old-key' AND key_decryption_nonce='old-nonce' AND mem_limit=1 AND ops_limit=1) AND
		EXISTS (SELECT FROM tokens WHERE user_id=$1 AND token_hash=$3 AND is_deleted=FALSE) AND
		EXISTS (SELECT FROM emergency_recovery WHERE id=$4 AND status=$5) AND
		EXISTS (SELECT FROM space_browser_sessions WHERE token_hash=$6 AND user_id=$1)`,
		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%d@example.com", 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)
}