Skip to content

armgit / ente

Public Imported from GitHub
0

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

Use opaque session identifiers

Neeraj Guptad115d57593f9
diff --git a/server/ente/user.go b/server/ente/user.go
index f371b5de3d..1e0c899f0b 100644
--- a/server/ente/user.go
+++ b/server/ente/user.go
@@ -231,6 +231,8 @@ type ProfileData struct {
type Session struct {
Token string `json:"token"`
+ TokenHash []byte `json:"-"`
+ IsCurrent bool `json:"isCurrent"`
CreationTime int64 `json:"creationTime"`
IP string `json:"ip"`
UA string `json:"ua"`
diff --git a/server/pkg/api/user.go b/server/pkg/api/user.go
index 5c5d7da591..f82969cf15 100644
--- a/server/pkg/api/user.go
+++ b/server/pkg/api/user.go
@@ -500,8 +500,8 @@ func (h *UserHandler) GetActiveSessions(c *gin.Context) {
func (h *UserHandler) TerminateSession(c *gin.Context) {
userID := auth.GetUserID(c.Request.Header)
- token := c.Query("token")
- err := h.UserController.TerminateSession(userID, token)
+ identifier := c.Query("token")
+ err := h.UserController.TerminateSessionByIdentifier(userID, auth.GetToken(c), identifier)
if err != nil {
handler.Error(c, stacktrace.Propagate(err, ""))
return
diff --git a/server/pkg/controller/user/sessions_test.go b/server/pkg/controller/user/sessions_test.go
new file mode 100644
index 0000000000..34f8553c8f
--- /dev/null
+++ b/server/pkg/controller/user/sessions_test.go
@@ -0,0 +1,97 @@
+package user
+
+import (
+ "database/sql"
+ "encoding/json"
+ "net/http"
+ "net/http/httptest"
+ "testing"
+ "time"
+
+ "github.com/ente/museum/ente"
+ "github.com/ente/museum/internal/testutil"
+ "github.com/ente/museum/pkg/controller/authsession"
+ "github.com/ente/museum/pkg/repo"
+ "github.com/ente/museum/pkg/utils/auth"
+ "github.com/gin-gonic/gin"
+ "github.com/patrickmn/go-cache"
+ "github.com/stretchr/testify/require"
+)
+
+func TestSessionIdentifiers(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})
+ userAuthRepo := &repo.UserAuthRepository{DB: db}
+ authCache := cache.New(time.Minute, time.Minute)
+ controller := &UserController{UserAuthRepo: userAuthRepo, Cache: authCache}
+ currentToken := "current-session-token"
+ otherToken := "other-session-token"
+ legacyToken := "legacy-session-token"
+ for _, token := range []string{currentToken, otherToken, legacyToken} {
+ require.NoError(t, userAuthRepo.AddToken(userID, ente.Photos, token, "127.0.0.1", "test"))
+ }
+
+ gin.SetMode(gin.TestMode)
+ ctx, _ := gin.CreateTestContext(httptest.NewRecorder())
+ ctx.Request = httptest.NewRequest("GET", "/users/sessions", nil)
+ ctx.Request.Header.Set("X-Auth-Token", currentToken)
+ ctx.Request.Header.Set("X-Client-Package", "io.ente.photos")
+ sessions, err := controller.GetActiveSessions(ctx, userID)
+ require.NoError(t, err)
+ require.Len(t, sessions, 3)
+
+ currentHash := auth.HashToken(currentToken)
+ otherHash := auth.HashToken(otherToken)
+ legacyHash := auth.HashToken(legacyToken)
+ currentIdentifier := encodeSessionTokenHash(currentHash[:])
+ otherIdentifier := encodeSessionTokenHash(otherHash[:])
+ legacyIdentifier := encodeSessionTokenHash(legacyHash[:])
+ identifiers := make(map[string]bool)
+ currentCount := 0
+ for i := range sessions {
+ identifiers[sessions[i].Token] = true
+ if sessions[i].IsCurrent {
+ currentCount++
+ require.Equal(t, currentIdentifier, sessions[i].Token)
+ }
+ }
+ require.Equal(t, 1, currentCount)
+ require.Equal(t, map[string]bool{
+ currentIdentifier: true,
+ otherIdentifier: true,
+ legacyIdentifier: true,
+ }, identifiers)
+ response, err := json.Marshal(sessions)
+ require.NoError(t, err)
+ require.NotContains(t, string(response), currentToken)
+ require.NotContains(t, string(response), otherToken)
+ require.NotContains(t, string(response), legacyToken)
+
+ _, _, _, err = authsession.Authenticate(userAuthRepo, authCache, currentHash[:], ente.Photos)
+ require.NoError(t, err)
+ _, _, _, err = authsession.Authenticate(userAuthRepo, authCache, otherHash[:], ente.Photos)
+ require.NoError(t, err)
+ identifierHash := auth.HashToken(otherIdentifier)
+ _, _, _, err = authsession.Authenticate(userAuthRepo, authCache, identifierHash[:], ente.Photos)
+ require.ErrorIs(t, err, sql.ErrNoRows)
+
+ for _, identifier := range []string{currentToken, currentIdentifier} {
+ err = controller.TerminateSessionByIdentifier(userID, currentToken, identifier)
+ var apiErr *ente.ApiError
+ require.ErrorAs(t, err, &apiErr)
+ require.Equal(t, http.StatusBadRequest, apiErr.HttpStatusCode)
+ }
+ _, _, _, err = authsession.Authenticate(userAuthRepo, authCache, currentHash[:], ente.Photos)
+ require.NoError(t, err)
+
+ require.NoError(t, controller.TerminateSessionByIdentifier(userID, currentToken, otherIdentifier))
+ _, _, _, err = authsession.Authenticate(userAuthRepo, authCache, otherHash[:], ente.Photos)
+ require.ErrorIs(t, err, sql.ErrNoRows)
+ require.NoError(t, controller.TerminateSessionByIdentifier(userID, currentToken, legacyToken))
+ _, _, _, err = authsession.Authenticate(userAuthRepo, authCache, legacyHash[:], ente.Photos)
+ require.ErrorIs(t, err, sql.ErrNoRows)
+}
diff --git a/server/pkg/controller/user/userauth.go b/server/pkg/controller/user/userauth.go
index 2aaf7c93ab..88ffa55102 100644
--- a/server/pkg/controller/user/userauth.go
+++ b/server/pkg/controller/user/userauth.go
@@ -1,6 +1,8 @@
package user
import (
+ "bytes"
+ "crypto/sha256"
"database/sql"
"encoding/base64"
"errors"
@@ -400,11 +402,17 @@ func (c *UserController) Logout(ctx *gin.Context) error {
}
func (c *UserController) GetActiveSessions(context *gin.Context, userID int64) ([]ente.Session, error) {
- tokens, err := c.UserAuthRepo.GetActiveSessions(userID, auth.GetApp(context))
+ sessions, err := c.UserAuthRepo.GetActiveSessions(userID, auth.GetApp(context))
if err != nil {
return nil, stacktrace.Propagate(err, "")
}
- return tokens, nil
+ 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 (
@@ -552,6 +560,37 @@ func (c *UserController) TerminateSession(userID int64, token string) error {
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")
diff --git a/server/pkg/repo/userauth.go b/server/pkg/repo/userauth.go
index cc31ecea98..f06c9e8ed0 100644
--- a/server/pkg/repo/userauth.go
+++ b/server/pkg/repo/userauth.go
@@ -251,7 +251,7 @@ func (repo *UserAuthRepository) markTokensDeleted(query string, args ...interfac
}
func (repo *UserAuthRepository) GetActiveSessions(userID int64, app ente.App) ([]ente.Session, error) {
- rows, err := repo.DB.Query(`SELECT token, creation_time, ip, user_agent, last_used_at FROM tokens WHERE user_id = $1 AND app = $2 AND is_deleted = false`, userID, app)
+ rows, err := repo.DB.Query(`SELECT token_hash, creation_time, ip, user_agent, last_used_at FROM tokens WHERE user_id = $1 AND app = $2 AND is_deleted = false`, userID, app)
if err != nil {
return nil, stacktrace.Propagate(err, "")
}
@@ -261,7 +261,7 @@ func (repo *UserAuthRepository) GetActiveSessions(userID int64, app ente.App) ([
var ip sql.NullString
var userAgent sql.NullString
var session ente.Session
- err := rows.Scan(&session.Token, &session.CreationTime, &ip, &userAgent, &session.LastUsedTime)
+ err := rows.Scan(&session.TokenHash, &session.CreationTime, &ip, &userAgent, &session.LastUsedTime)
if err != nil {
return nil, stacktrace.Propagate(err, "")
}