172 lines
5.9 KiB
Go
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
|
|
}
|