Files
pages/internal/server/external_resources.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

138 lines
4.2 KiB
Go

package server
import (
"encoding/base64"
"encoding/hex"
"encoding/json"
"errors"
"net/url"
"sort"
"strings"
)
const externalResourceApprovalsConfig = "external_resource_approvals_v1"
const maxExternalResourceApprovals = 128
type externalResourceApproval struct {
Kind string `json:"kind"`
URL string `json:"url"`
Integrity string `json:"integrity,omitempty"`
}
type externalResourcePolicy struct {
items []externalResourceApproval
byKind map[string]map[string]externalResourceApproval
}
func normalizeExternalResourceURL(raw string) (string, error) {
raw = strings.TrimSpace(raw)
if raw == "" || len(raw) > 2048 || strings.ContainsAny(raw, " \\\r\n\t") {
return "", errors.New("invalid external resource URL")
}
u, err := url.Parse(raw)
if err != nil || !u.IsAbs() || !strings.EqualFold(u.Scheme, "https") || u.Host == "" || u.User != nil || u.Fragment != "" {
return "", errors.New("external resources require an absolute HTTPS URL without credentials or fragments")
}
u.Scheme = "https"
u.Host = strings.ToLower(u.Host)
u.RawFragment = ""
return u.String(), nil
}
func normalizeExternalResourceIntegrity(raw string) (string, error) {
raw = strings.TrimSpace(raw)
if len(raw) == 64 {
decoded, err := hex.DecodeString(raw)
if err == nil && len(decoded) == 32 {
return "sha256-" + base64.StdEncoding.EncodeToString(decoded), nil
}
}
if !strings.HasPrefix(raw, "sha256-") {
return "", errors.New("SHA-256 integrity is required")
}
decoded, err := base64.StdEncoding.DecodeString(strings.TrimPrefix(raw, "sha256-"))
if err != nil || len(decoded) != 32 {
return "", errors.New("invalid SHA-256 integrity")
}
return "sha256-" + base64.StdEncoding.EncodeToString(decoded), nil
}
func normalizeExternalResourceApproval(item externalResourceApproval) (externalResourceApproval, error) {
item.Kind = strings.ToLower(strings.TrimSpace(item.Kind))
if item.Kind != "image" && item.Kind != "stylesheet" && item.Kind != "script" {
return externalResourceApproval{}, errors.New("invalid external resource kind")
}
var err error
item.URL, err = normalizeExternalResourceURL(item.URL)
if err != nil {
return externalResourceApproval{}, err
}
if item.Kind == "image" {
item.Integrity = ""
return item, nil
}
item.Integrity, err = normalizeExternalResourceIntegrity(item.Integrity)
if err != nil {
return externalResourceApproval{}, err
}
return item, nil
}
func newExternalResourcePolicy(items []externalResourceApproval) externalResourcePolicy {
p := externalResourcePolicy{byKind: map[string]map[string]externalResourceApproval{}}
seen := map[string]bool{}
for _, raw := range items {
item, err := normalizeExternalResourceApproval(raw)
if err != nil {
continue
}
key := item.Kind + "\x00" + item.URL
if seen[key] || len(p.items) >= maxExternalResourceApprovals {
continue
}
seen[key] = true
if p.byKind[item.Kind] == nil {
p.byKind[item.Kind] = map[string]externalResourceApproval{}
}
p.byKind[item.Kind][item.URL] = item
p.items = append(p.items, item)
}
sort.Slice(p.items, func(i, j int) bool {
if p.items[i].Kind == p.items[j].Kind {
return p.items[i].URL < p.items[j].URL
}
return p.items[i].Kind < p.items[j].Kind
})
return p
}
func (p externalResourcePolicy) approved(kind, rawURL string) (externalResourceApproval, bool) {
normalized, err := normalizeExternalResourceURL(rawURL)
if err != nil {
return externalResourceApproval{}, false
}
item, ok := p.byKind[kind][normalized]
return item, ok
}
func (s *Server) externalResourcePolicy(domainUUID string) externalResourcePolicy {
var items []externalResourceApproval
raw := strings.TrimSpace(s.getDomainConfig(externalResourceApprovalsConfig, domainUUID))
if raw != "" {
_ = json.Unmarshal([]byte(raw), &items)
}
return newExternalResourcePolicy(items)
}
func (s *Server) saveExternalResourceApprovals(domainUUID string, items []externalResourceApproval) error {
policy := newExternalResourcePolicy(items)
if len(policy.items) != len(items) {
return errors.New("invalid or duplicate external resource approval")
}
raw, err := json.Marshal(policy.items)
if err != nil {
return err
}
return s.store.SetConfigInDomain(domainUUID, externalResourceApprovalsConfig, string(raw))
}