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 }