Files
pages/internal/store/adapter_sessions.go
Anya Tokugawa c1175d389f Implement Knowledge City platform, organizer and DAV integration
Capture accumulated application, UI, CLI, regression tests and design documentation changes, including task project mapping and default CalDAV list naming.

Keep deployment data, backups, local credentials and build artifacts out of Git. Move the Compose enrollment token to an ignored local environment file.
2026-09-27 14:44:43 +09:00

172 lines
6.3 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 {
_, err := s.DB.Exec(`CREATE TABLE IF NOT EXISTS adapter_sessions (
ticket_hash TEXT PRIMARY KEY, session_hash TEXT NOT NULL DEFAULT '',
domain_uuid TEXT NOT NULL, plugin_id TEXT NOT NULL, object_uuid TEXT NOT NULL,
principal_uuid TEXT NOT NULL DEFAULT '',
base_revision_uuid TEXT NOT NULL, ticket_expires_at_ms INTEGER NOT NULL,
session_expires_at_ms INTEGER NOT NULL DEFAULT 0, exchanged_at_ms INTEGER NOT NULL DEFAULT 0,
created_at_ms INTEGER NOT NULL
)`)
if err != nil {
return err
}
_, _ = s.DB.Exec(`ALTER TABLE adapter_sessions ADD COLUMN root_path TEXT NOT NULL DEFAULT ''`)
_, _ = s.DB.Exec(`ALTER TABLE adapter_sessions ADD COLUMN principal_uuid TEXT NOT NULL DEFAULT ''`)
_, err = s.DB.Exec(`CREATE UNIQUE INDEX IF NOT EXISTS idx_adapter_session_hash
ON adapter_sessions(session_hash) WHERE session_hash != ''`)
return err
}
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) {
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) {
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) {
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) {
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) {
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
}