Files
pages/internal/store/adapter_sessions.go
T
2026-11-15 05:47:14 +09:00

172 lines
5.9 KiB
Go

package store
import (
"crypto/rand"
"crypto/sha256"
"database/sql"
"encoding/base64"
"encoding/hex"
"errors"
"time"
)
var (
ErrAdapterTicketInvalid = errors.New("adapter launch ticket is invalid or expired")
ErrAdapterSessionInvalid = errors.New("adapter session is invalid or expired")
ErrRevisionConflict = errors.New("document changed after the hosted editor session started")
)
type AdapterSession struct {
PrincipalUUID string
DomainUUID string
PluginID string
ObjectUUID string
BaseRevisionUUID string
RootPath string
SessionHash string
ExpiresAtMS int64
}
func adapterSecret(prefix string) (string, string, error) {
raw := make([]byte, 32)
if _, err := rand.Read(raw); err != nil {
return "", "", err
}
token := prefix + base64.RawURLEncoding.EncodeToString(raw)
hash := sha256.Sum256([]byte(token))
return token, hex.EncodeToString(hash[:]), nil
}
func (s *Store) EnsureAdapterSessionsSchema() error {
return s.ensureSchemaComponent("adapter-sessions")
}
func (s *Store) IssueAdapterTicket(domainUUID, pluginID, objectUUID, revisionUUID, rootPath string) (string, error) {
return s.issueAdapterTicket("", domainUUID, pluginID, objectUUID, revisionUUID, rootPath)
}
func (s *Store) IssueAdapterTicketForPrincipal(principalUUID, domainUUID, pluginID, objectUUID, revisionUUID, rootPath string) (string, error) {
return s.issueAdapterTicket(principalUUID, domainUUID, pluginID, objectUUID, revisionUUID, rootPath)
}
func (s *Store) issueAdapterTicket(principalUUID, domainUUID, pluginID, objectUUID, revisionUUID, rootPath string) (string, error) {
if !s.SupportsHostedEditors() {
return "", ErrBackendFeatureUnavailable
}
token, hash, err := adapterSecret("pwa_t_")
if err != nil {
return "", err
}
now := time.Now().UnixMilli()
_, _ = s.DB.Exec(`DELETE FROM adapter_sessions WHERE
(ticket_expires_at_ms < ? AND exchanged_at_ms=0) OR
(session_expires_at_ms > 0 AND session_expires_at_ms < ?)`, now, now)
_, err = s.DB.Exec(`INSERT INTO adapter_sessions
(ticket_hash,domain_uuid,plugin_id,object_uuid,principal_uuid,base_revision_uuid,root_path,ticket_expires_at_ms,created_at_ms)
VALUES(?,?,?,?,?,?,?,?,?)`, hash, domainUUID, pluginID, objectUUID, principalUUID, revisionUUID, rootPath, now+60_000, now)
return token, err
}
func secretHash(token string) string {
hash := sha256.Sum256([]byte(token))
return hex.EncodeToString(hash[:])
}
func (s *Store) ExchangeAdapterTicket(ticket string) (string, *AdapterSession, error) {
if !s.SupportsHostedEditors() {
return "", nil, ErrBackendFeatureUnavailable
}
tx, err := s.DB.Begin()
if err != nil {
return "", nil, err
}
defer tx.Rollback()
now := time.Now().UnixMilli()
var session AdapterSession
var exchanged int64
err = tx.QueryRow(`SELECT principal_uuid,domain_uuid,plugin_id,object_uuid,base_revision_uuid,root_path,
ticket_expires_at_ms,exchanged_at_ms FROM adapter_sessions WHERE ticket_hash=?`,
secretHash(ticket)).Scan(&session.PrincipalUUID, &session.DomainUUID, &session.PluginID, &session.ObjectUUID,
&session.BaseRevisionUUID, &session.RootPath, &session.ExpiresAtMS, &exchanged)
if errors.Is(err, sql.ErrNoRows) || err == nil && (exchanged != 0 || session.ExpiresAtMS < now) {
return "", nil, ErrAdapterTicketInvalid
}
if err != nil {
return "", nil, err
}
token, hash, err := adapterSecret("pwa_s_")
if err != nil {
return "", nil, err
}
session.SessionHash = hash
session.ExpiresAtMS = now + int64((8*time.Hour)/time.Millisecond)
result, err := tx.Exec(`UPDATE adapter_sessions SET session_hash=?,session_expires_at_ms=?,
exchanged_at_ms=? WHERE ticket_hash=? AND exchanged_at_ms=0`, hash, session.ExpiresAtMS,
now, secretHash(ticket))
if err != nil {
return "", nil, err
}
count, _ := result.RowsAffected()
if count != 1 {
return "", nil, ErrAdapterTicketInvalid
}
if err := tx.Commit(); err != nil {
return "", nil, err
}
return token, &session, nil
}
func (s *Store) GetAdapterSession(token string) (*AdapterSession, error) {
if !s.SupportsHostedEditors() {
return nil, ErrBackendFeatureUnavailable
}
var session AdapterSession
err := s.DB.QueryRow(`SELECT principal_uuid,domain_uuid,plugin_id,object_uuid,base_revision_uuid,root_path,
session_hash,session_expires_at_ms FROM adapter_sessions WHERE session_hash=?`,
secretHash(token)).Scan(&session.PrincipalUUID, &session.DomainUUID, &session.PluginID, &session.ObjectUUID,
&session.BaseRevisionUUID, &session.RootPath, &session.SessionHash, &session.ExpiresAtMS)
if errors.Is(err, sql.ErrNoRows) || err == nil && session.ExpiresAtMS < time.Now().UnixMilli() {
return nil, ErrAdapterSessionInvalid
}
return &session, err
}
func (s *Store) SaveHostedRevision(session *AdapterSession, payload []byte, message string) (*Revision, error) {
if !s.SupportsHostedEditors() {
return nil, ErrBackendFeatureUnavailable
}
return s.SaveHostedRevisionAt(session, session.ObjectUUID, session.BaseRevisionUUID, payload, message)
}
func (s *Store) SaveHostedRevisionAt(session *AdapterSession, objectUUID, baseRevisionUUID string, payload []byte, message string) (*Revision, error) {
if !s.SupportsHostedEditors() {
return nil, ErrBackendFeatureUnavailable
}
s.revisionWriteMu.Lock()
defer s.revisionWriteMu.Unlock()
base, err := s.GetRevision(baseRevisionUUID)
if err != nil {
return nil, err
}
if base.ObjectUUID != objectUUID {
return nil, ErrAdapterSessionInvalid
}
latest, err := s.GetLatestRevisionForLanguages(objectUUID, []string{base.Language})
if err != nil {
return nil, err
}
if latest.UUID != baseRevisionUUID {
return nil, ErrRevisionConflict
}
revision, err := s.saveRevisionContentUnlocked(objectUUID, payload, message,
base.Language, base.ContentType, base.Filename)
if err == nil && objectUUID == session.ObjectUUID {
_, err = s.DB.Exec(`UPDATE adapter_sessions SET base_revision_uuid=? WHERE session_hash=?`,
revision.UUID, session.SessionHash)
if err == nil {
session.BaseRevisionUUID = revision.UUID
}
}
return revision, err
}