Files
2026-11-15 05:47:14 +09:00

341 lines
11 KiB
Go

package server
import (
"context"
"crypto/tls"
"crypto/x509"
"encoding/json"
"errors"
"fmt"
"io"
"log"
"net"
"net/http"
"net/netip"
"net/url"
"strings"
"time"
"pageswiki/internal/calendar"
"pageswiki/internal/store"
)
const calendarSyncType = "calendar.source.sync"
const calendarSweepType = "calendar.source.sweep"
var errCalendarSourceBlocked = errors.New("calendar source address blocked: only public HTTPS endpoints are allowed")
var errCalendarSourceDNS = errors.New("calendar source DNS lookup failed")
// Return only a classified cause, never URL.Error (which can contain tokens).
func calendarSourceRequestError(err error) error {
if errors.Is(err, errCalendarSourceBlocked) {
return errCalendarSourceBlocked
}
if errors.Is(err, errCalendarSourceDNS) {
return errCalendarSourceDNS
}
var cert *tls.CertificateVerificationError
var unknown x509.UnknownAuthorityError
if errors.As(err, &cert) || errors.As(err, &unknown) {
return errors.New("external calendar TLS certificate verification failed")
}
var network net.Error
if errors.Is(err, context.DeadlineExceeded) || (errors.As(err, &network) && network.Timeout()) {
return errors.New("external calendar request timed out")
}
return errors.New("external calendar connection failed (no reachable address, TLS handshake or redirect failure)")
}
type calendarSyncPayload struct {
Domain string `json:"domain"`
Calendar string `json:"calendar"`
Force bool `json:"force,omitempty"`
}
func validCalendarSourceURL(raw string) bool {
u, e := url.Parse(raw)
if e != nil || len(raw) > 4096 || u.Scheme != "https" || u.Hostname() == "" || u.User != nil || u.Fragment != "" || (u.Port() != "" && u.Port() != "443") {
return false
}
host := strings.TrimSuffix(strings.ToLower(u.Hostname()), ".")
if host == "localhost" || strings.HasSuffix(host, ".localhost") {
return false
}
if ip, err := netip.ParseAddr(host); err == nil && !publicCalendarIP(ip) {
return false
}
return true
}
func publicCalendarIP(ip netip.Addr) bool {
ip = ip.Unmap()
if !ip.IsGlobalUnicast() || ip.IsPrivate() || ip.IsLoopback() || ip.IsLinkLocalUnicast() {
return false
}
for _, cidr := range []string{"0.0.0.0/8", "100.64.0.0/10", "192.0.0.0/24", "192.0.2.0/24", "198.18.0.0/15", "198.51.100.0/24", "203.0.113.0/24", "240.0.0.0/4", "2001:db8::/32", "64:ff9b::/96", "64:ff9b:1::/48", "2002::/16"} {
if netip.MustParsePrefix(cidr).Contains(ip) {
return false
}
}
return true
}
// DNS is checked at dial time and the approved address is pinned for this
// connection. No proxy environment or alternate-port bypass is permitted.
func calendarSourceClient() *http.Client {
tr := &http.Transport{TLSHandshakeTimeout: 10 * time.Second, ResponseHeaderTimeout: 25 * time.Second, DisableKeepAlives: true}
tr.DialContext = func(ctx context.Context, network, address string) (net.Conn, error) {
host, port, e := net.SplitHostPort(address)
if e != nil || port != "443" {
return nil, errCalendarSourceBlocked
}
ips, e := net.DefaultResolver.LookupNetIP(ctx, "ip", host)
if e != nil || len(ips) == 0 {
return nil, errCalendarSourceDNS
}
for _, ip := range ips {
if !publicCalendarIP(ip) {
return nil, errCalendarSourceBlocked
}
}
// Try all validated addresses rather than failing on an unreachable
// first IPv6/IPv4 address. Never re-resolve after the safety check.
for _, ip := range ips {
var conn net.Conn
conn, e = (&net.Dialer{Timeout: 2 * time.Second}).DialContext(ctx, "tcp", net.JoinHostPort(ip.String(), port))
if e == nil {
return conn, nil
}
if ctx.Err() != nil {
return nil, ctx.Err()
}
}
return nil, e
}
return &http.Client{Transport: tr, Timeout: 45 * time.Second, CheckRedirect: func(req *http.Request, via []*http.Request) error {
if len(via) >= 3 || !validCalendarSourceURL(req.URL.String()) {
return errors.New("calendar source redirect blocked")
}
req.Header.Del("Referer")
return nil
}}
}
func fetchCalendarSource(ctx context.Context, client *http.Client, c calendar.Calendar) ([]calendar.Event, string, string, bool, error) {
if c.Source == nil || !validCalendarSourceURL(c.Source.URL) {
return nil, "", "", false, errors.New("invalid calendar source URL")
}
req, e := http.NewRequestWithContext(ctx, "GET", c.Source.URL, nil)
if e != nil {
return nil, "", "", false, errors.New("invalid calendar source URL")
}
req.Header.Set("Accept", "text/calendar")
req.Header.Set("User-Agent", "PagesWiki-Calendar/1")
if c.Source.ETag != "" {
req.Header.Set("If-None-Match", c.Source.ETag)
}
if c.Source.Modified != "" {
req.Header.Set("If-Modified-Since", c.Source.Modified)
}
response, e := client.Do(req)
if e != nil {
return nil, "", "", false, calendarSourceRequestError(e)
}
defer response.Body.Close()
if response.StatusCode == 304 {
if c.Source.Success == 0 {
return nil, "", "", false, errors.New("unexpected 304 before initial synchronization")
}
return nil, "", "", true, nil
}
if response.StatusCode != 200 {
return nil, "", "", false, errors.New("external calendar returned HTTP " + http.StatusText(response.StatusCode))
}
body, e := io.ReadAll(io.LimitReader(response.Body, calendar.MaxFeed+1))
if e != nil {
return nil, "", "", false, errors.New("external calendar body could not be read")
}
now := time.Now().UTC().Truncate(24 * time.Hour)
events, e := calendar.ParseExternalFeed(body, now.AddDate(0, 0, -90), now.AddDate(0, 0, 275))
if e != nil {
e = fmt.Errorf("ICS validation stage failed: %w", e)
}
return events, response.Header.Get("ETag"), response.Header.Get("Last-Modified"), false, e
}
func (s *Server) ensureCalendarSweep() error {
return s.store.EnsureBuiltinEventDefinition(store.EventDefinition{UUID: calendarSweepType, Name: "Calendar source synchronization", EventType: calendarSweepType, EventKey: calendarSweepType, Payload: "{}", ScheduleKind: "interval", IntervalSeconds: 60, Enabled: true, Priority: -10, MaxAttempts: 1})
}
func (s *Server) enqueueCalendarSource(domain, id string, force bool) (bool, error) {
b, _ := json.Marshal(calendarSyncPayload{Domain: domain, Calendar: id, Force: force})
return s.store.EnqueueEventWithOptions("", calendarSyncType, domain+":"+id, string(b), time.Now(), -10, 1)
}
func (s *Server) sweepCalendarSources() error {
repo, e := s.calendars()
if e != nil {
return e
}
domains, e := s.store.ListDomains()
if e != nil {
return e
}
for _, d := range domains {
if !d.Enabled || !s.systemExtensionEnabled(d.UUID, "organizer.calendar") {
continue
}
cs, e := repo.Sources(d.UUID)
if e != nil {
return e
}
for _, c := range cs {
if c.Source.Enabled && c.Source.Next <= time.Now().UnixMilli() {
if _, e = s.enqueueCalendarSource(d.UUID, c.ID, false); e != nil {
return e
}
}
}
}
return nil
}
func (s *Server) runCalendarSource(job *store.EventJob) error {
var p calendarSyncPayload
if e := json.Unmarshal([]byte(job.Payload), &p); e != nil {
return e
}
if !s.systemExtensionEnabled(p.Domain, "organizer.calendar") {
return nil
}
repo, e := s.calendars()
if e != nil {
return e
}
c, e := repo.SourceCalendar(p.Domain, p.Calendar)
if e != nil {
return e
}
if !c.Source.Enabled || (!p.Force && c.Source.Next > time.Now().UnixMilli()) {
return nil
}
active, e := s.store.ActiveDomainMember(context.Background(), p.Domain, c.Owner)
if e != nil {
return e
}
if !active {
return errors.New("calendar source owner is inactive")
}
ctx, cancel := context.WithTimeout(context.Background(), 50*time.Second)
defer cancel()
client := calendarSourceClient()
if c.Source.Credential != "" {
user, password, err := s.store.OpenCalendarCredential(p.Domain, c.ID, c.Source.Credential)
if err != nil {
return errors.New("calendar credential unavailable")
}
client.Transport = calendarAuthTransport{base: client.Transport, origin: c.Source.URL, user: user, password: password}
}
var events []calendar.Event
var etag, modified string
var unchanged bool
var syncErr error
var resources map[string]calendar.RemoteResource
if c.Source.Kind == "caldav" {
events, resources, syncErr = fetchCalDAVSource(ctx, client, repo, p.Domain, c)
} else {
events, etag, modified, unchanged, syncErr = fetchCalendarSource(ctx, client, c)
}
if syncErr != nil {
// Deliberately omit source URL, credentials, UID, summary and body.
log.Printf("calendar source synchronization failed domain=%s calendar=%s protocol=%s stage=fetch-validate: %v", p.Domain, p.Calendar, c.Source.Kind, syncErr)
}
if s.store.EventCancellationRequested(job.UUID) {
return errors.New("calendar synchronization cancelled")
}
if e = repo.ApplySource(ctx, p.Domain, c, events, etag, modified, unchanged, syncErr, resources); e != nil {
return e
}
return syncErr
}
func (s *Server) handleCalendarSource(w http.ResponseWriter, r *http.Request, repo *calendar.Repository, domain, id, actor string, active bool) {
if !active {
calendarError(w, calendar.ErrForbidden)
return
}
c, e := repo.Get(domain, id, actor)
if e != nil {
calendarError(w, e)
return
}
if c.Owner != actor {
calendarError(w, calendar.ErrForbidden)
return
}
switch r.Method {
case "PUT":
var body struct {
Kind string `json:"kind"`
Username string `json:"username"`
Password string `json:"password"`
ClearCredential bool `json:"clear_credential"`
URL string `json:"url"`
IntervalSeconds int64 `json:"interval_seconds"`
Enabled bool `json:"enabled"`
Version string `json:"version"`
}
if !decodeCalendarJSON(w, r, &body) {
return
}
body.URL = strings.TrimSpace(body.URL)
if !validCalendarSourceURL(body.URL) {
writeEventJSON(w, 422, map[string]string{"error": "Use a public HTTPS ICS URL (port 443, no URL username/password)."})
return
}
if body.Kind == "" {
body.Kind = "ics"
}
credential := ""
if c.Source != nil && c.Source.URL == body.URL && !body.ClearCredential {
credential = c.Source.Credential
}
if body.Username != "" || body.Password != "" {
if body.Username == "" || body.Password == "" || strings.Contains(body.Username, ":") || len(body.Username) > 256 || len(body.Password) > 4096 {
writeEventJSON(w, 422, map[string]string{"error": "Supply both username and password (username must not contain a colon)."})
return
}
credential, e = s.store.SealCalendarCredential(domain, id, body.Username, body.Password)
if e != nil {
calendarError(w, e)
return
}
}
c, e = repo.SetSource(r.Context(), domain, id, actor, body.Version, calendar.Source{Kind: body.Kind, Credential: credential, URL: body.URL, IntervalSeconds: body.IntervalSeconds, Enabled: body.Enabled})
if e != nil {
calendarError(w, e)
return
}
if body.Enabled {
if _, e = s.enqueueCalendarSource(domain, id, true); e != nil {
calendarError(w, e)
return
}
s.wakeEventScheduler()
}
c.Months = nil
c.Source.HasCredential = c.Source.Credential != ""
c.Source.Credential = ""
c.Source.Resources = nil
writeEventJSON(w, 200, c)
case "POST":
if c.Source == nil || !c.Source.Enabled {
writeEventJSON(w, 409, map[string]string{"error": "Enable a source first"})
return
}
queued, e := s.enqueueCalendarSource(domain, id, true)
if e != nil {
calendarError(w, e)
return
}
s.wakeEventScheduler()
writeEventJSON(w, 202, map[string]bool{"queued": queued})
default:
w.Header().Set("Allow", "PUT, POST")
w.WriteHeader(405)
}
}