Files
pages/internal/store/task_dav_credentials.go
T
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

171 lines
7.9 KiB
Go

package store
import (
"context"
"crypto/rand"
"crypto/sha256"
"crypto/subtle"
"database/sql"
"encoding/base64"
"github.com/google/uuid"
"strings"
"time"
)
type TaskDAVCredential struct {
ID string `json:"id"`
Label string `json:"label"`
Write bool `json:"write"`
CreatedMS int64 `json:"created_ms"`
ExpiresMS int64 `json:"expires_ms"`
Scope string `json:"scope"`
CalendarAccessCompat bool `json:"calendar_access_compat"`
}
func taskDAVSecretHash(secret string) string {
sum := sha256.Sum256([]byte(secret))
return base64.RawURLEncoding.EncodeToString(sum[:])
}
func (s *Store) CreateTaskDAVCredential(ctx context.Context, domain, actor, label string, write bool, days int) (TaskDAVCredential, string, error) {
return s.CreateDAVCredential(ctx, domain, actor, label, write, days, "tasks")
}
func (s *Store) CreateDAVCredential(ctx context.Context, domain, actor, label string, write bool, days int, scope string, compatibility ...bool) (TaskDAVCredential, string, error) {
compat := len(compatibility) == 1 && compatibility[0]
if scope != "tasks" && scope != "calendar" && scope != "all" {
return TaskDAVCredential{}, "", ErrTaskInvalid
}
label = strings.TrimSpace(label)
if label == "" || len(label) > 100 || strings.ContainsAny(label, "\r\n\x00") || days < 1 || days > 365 {
return TaskDAVCredential{}, "", ErrTaskInvalid
}
tx, err := s.DB.BeginTx(ctx, nil)
if err != nil {
return TaskDAVCredential{}, "", err
}
defer tx.Rollback()
if _, err = tx.ExecContext(ctx, `UPDATE domain_memberships SET state=state WHERE domain_uuid=? AND principal_uuid=?`, domain, actor); err != nil {
return TaskDAVCredential{}, "", err
}
if err = taskActor(ctx, tx, domain, actor, write); err != nil {
return TaskDAVCredential{}, "", err
}
var count int
if err = tx.QueryRowContext(ctx, `SELECT count(*) FROM organizer_dav_credentials WHERE domain_uuid=? AND owner_uuid=? AND expires_ms>?`, domain, actor, time.Now().UnixMilli()).Scan(&count); err != nil {
return TaskDAVCredential{}, "", err
}
if count >= 20 {
return TaskDAVCredential{}, "", ErrTaskDAVLimit
}
if _, err = tx.ExecContext(ctx, `DELETE FROM organizer_dav_credentials WHERE domain_uuid=? AND owner_uuid=? AND expires_ms<=?`, domain, actor, time.Now().UnixMilli()); err != nil {
return TaskDAVCredential{}, "", err
}
raw := make([]byte, 32)
if _, err = rand.Read(raw); err != nil {
return TaskDAVCredential{}, "", err
}
secret := "pw_taskdav_" + base64.RawURLEncoding.EncodeToString(raw)
if scope != "tasks" {
// Older binaries reject shared/calendar credentials on rollback instead
// of accidentally interpreting them as task-only authority.
secret = "pw_dav_" + base64.RawURLEncoding.EncodeToString(raw)
}
now := time.Now()
c := TaskDAVCredential{ID: uuid.NewString(), Label: label, Write: write, CreatedMS: now.UnixMilli(), ExpiresMS: now.Add(time.Duration(days) * 24 * time.Hour).UnixMilli(), Scope: scope}
c.CalendarAccessCompat = compat
_, err = tx.ExecContext(ctx, `INSERT INTO organizer_dav_credentials(id,domain_uuid,owner_uuid,label,secret_hash,write_access,created_ms,expires_ms) VALUES(?,?,?,?,?,?,?,?)`, c.ID, domain, actor, c.Label, taskDAVSecretHash(secret), write, c.CreatedMS, c.ExpiresMS)
if err == nil {
_, err = tx.ExecContext(ctx, `INSERT INTO organizer_dav_scopes(credential_id,scope) VALUES(?,?)`, c.ID, scope)
}
if err == nil && compat {
_, err = tx.ExecContext(ctx, `INSERT INTO organizer_dav_compat(credential_id) VALUES(?)`, c.ID)
}
if err == nil {
err = tx.Commit()
}
return c, secret, err
}
func (s *Store) ListTaskDAVCredentials(ctx context.Context, domain, actor string) ([]TaskDAVCredential, error) {
if err := taskActor(ctx, s.DB, domain, actor, false); err != nil {
return nil, err
}
rows, err := s.DB.QueryContext(ctx, `SELECT id,label,write_access,created_ms,expires_ms,COALESCE((SELECT scope FROM organizer_dav_scopes WHERE credential_id=id),'tasks'),EXISTS(SELECT 1 FROM organizer_dav_compat WHERE credential_id=id) FROM organizer_dav_credentials WHERE domain_uuid=? AND owner_uuid=? ORDER BY created_ms DESC LIMIT 100`, domain, actor)
if err != nil {
return nil, err
}
defer rows.Close()
out := []TaskDAVCredential{}
for rows.Next() {
var c TaskDAVCredential
if err = rows.Scan(&c.ID, &c.Label, &c.Write, &c.CreatedMS, &c.ExpiresMS, &c.Scope, &c.CalendarAccessCompat); err != nil {
return nil, err
}
out = append(out, c)
}
return out, rows.Err()
}
// Discovery compatibility is opt-in per authenticated credential. It does not
// grant a scope or write authority, and is not applied to normal Wiki sessions.
func (s *Store) DAVCalendarAccessCompat(ctx context.Context, domain, actor, id string) (bool, error) {
var enabled bool
err := s.DB.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM organizer_dav_compat f JOIN organizer_dav_credentials c ON c.id=f.credential_id WHERE c.id=? AND c.domain_uuid=? AND c.owner_uuid=? AND c.expires_ms>?)`, id, domain, actor, time.Now().UnixMilli()).Scan(&enabled)
return enabled, err
}
func (s *Store) RevokeTaskDAVCredential(ctx context.Context, domain, actor, id string) error {
if err := taskActor(ctx, s.DB, domain, actor, false); err != nil {
return err
}
_, err := s.DB.ExecContext(ctx, `DELETE FROM organizer_dav_credentials WHERE domain_uuid=? AND owner_uuid=? AND id=?`, domain, actor, id)
return err
}
func taskDAVCredentialAllowed(ctx context.Context, q interface {
QueryRowContext(context.Context, string, ...any) *sql.Row
}, domain, actor, id string, write bool) error {
return davCredentialAllowed(ctx, q, domain, actor, id, write, "tasks")
}
func davCredentialAllowed(ctx context.Context, q interface {
QueryRowContext(context.Context, string, ...any) *sql.Row
}, domain, actor, id string, write bool, scope string) error {
var yes bool
if err := q.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM organizer_dav_credentials WHERE id=? AND domain_uuid=? AND owner_uuid=? AND expires_ms>? AND (?=0 OR write_access=1) AND COALESCE((SELECT scope FROM organizer_dav_scopes WHERE credential_id=id),'tasks') IN (?, 'all'))`, id, domain, actor, time.Now().UnixMilli(), write, scope).Scan(&yes); err != nil {
return err
}
if !yes {
return ErrAccessDenied
}
return taskActor(ctx, q, domain, actor, write)
}
// The Basic username is the credential ID, not an account password/login name.
func (s *Store) AuthenticateTaskDAV(ctx context.Context, domain, id, secret string) (string, bool, error) {
actor, write, _, err := s.AuthenticateDAV(ctx, domain, id, secret, "tasks")
return actor, write, err
}
func (s *Store) CheckDAVCredential(ctx context.Context, domain, actor, id string, write bool, scope string) error {
return davCredentialAllowed(ctx, s.DB, domain, actor, id, write, scope)
}
// An empty requested scope is discovery only; callers must filter collections.
func (s *Store) AuthenticateDAV(ctx context.Context, domain, id, secret, requested string) (string, bool, string, error) {
if len(secret) > 128 || !(strings.HasPrefix(secret, "pw_taskdav_") || strings.HasPrefix(secret, "pw_dav_")) {
return "", false, "", ErrAccessDenied
}
var actor, hash, state, scope string
var write bool
err := s.DB.QueryRowContext(ctx, `SELECT c.owner_uuid,c.secret_hash,c.write_access,p.state,COALESCE(s.scope,'tasks') FROM organizer_dav_credentials c JOIN principals p ON p.uuid=c.owner_uuid LEFT JOIN organizer_dav_scopes s ON s.credential_id=c.id WHERE c.id=? AND c.domain_uuid=? AND c.expires_ms>?`, id, domain, time.Now().UnixMilli()).Scan(&actor, &hash, &write, &state, &scope)
if err != nil || subtle.ConstantTimeCompare([]byte(hash), []byte(taskDAVSecretHash(secret))) != 1 {
return "", false, "", ErrAccessDenied
}
if requested != "" && scope != "all" && scope != requested {
return "", false, "", ErrAccessDenied
}
if err = taskActor(ctx, s.DB, domain, actor, false); err != nil {
return "", false, "", err
}
return actor, write && state == "active", scope, nil
}