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) { 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 }