Files
pages/internal/store/task_dav_credentials.go
T
Anya Tokugawa 19e12f96a8
Build and publish container images / images (push) Successful in 13m39s
Release container images / release (push) Successful in 18s
Add private CardDAV synchronization and contact revision recovery
2026-11-02 08:41:15 +09:00

184 lines
8.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 == "contacts" && compat {
return TaskDAVCredential{}, "", ErrTaskInvalid
}
if scope != "tasks" && scope != "calendar" && scope != "all" && scope != "contacts" {
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)
}
if scope == "contacts" {
secret = "pw_contactdav_" + 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 {
if scope == "contacts" {
_, err = tx.ExecContext(ctx, `INSERT INTO organizer_contact_credentials VALUES(?)`, c.ID)
} else {
_, 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,CASE WHEN EXISTS(SELECT 1 FROM organizer_contact_credentials WHERE credential_id=id) THEN 'contacts' ELSE COALESCE((SELECT scope FROM organizer_dav_scopes WHERE credential_id=id),'tasks') END,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 ((?='contacts' AND EXISTS(SELECT 1 FROM organizer_contact_credentials WHERE credential_id=id)) OR (? IN ('tasks','calendar') AND NOT EXISTS(SELECT 1 FROM organizer_contact_credentials WHERE credential_id=id) AND COALESCE((SELECT scope FROM organizer_dav_scopes WHERE credential_id=id),'tasks') IN (?, 'all'))))`, id, domain, actor, time.Now().UnixMilli(), write, scope, scope, 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_") || strings.HasPrefix(secret, "pw_contactdav_")) {
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,CASE WHEN EXISTS(SELECT 1 FROM organizer_contact_credentials WHERE credential_id=c.id) THEN 'contacts' ELSE COALESCE(s.scope,'tasks') END 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 strings.HasPrefix(secret, "pw_contactdav_") && scope != "contacts" {
return "", false, "", ErrAccessDenied
}
if requested != "" && scope != requested && !(scope == "all" && (requested == "tasks" || requested == "calendar")) {
return "", false, "", ErrAccessDenied
}
if err = taskActor(ctx, s.DB, domain, actor, false); err != nil {
return "", false, "", err
}
return actor, write && state == "active", scope, nil
}