345 lines
12 KiB
Go
345 lines
12 KiB
Go
package server
|
|
|
|
import (
|
|
"context"
|
|
"crypto/rand"
|
|
"crypto/sha256"
|
|
"encoding/base64"
|
|
"fmt"
|
|
stdhtml "html"
|
|
"io"
|
|
"net/http"
|
|
"net/url"
|
|
pathpkg "path"
|
|
"regexp"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/microcosm-cc/bluemonday"
|
|
"golang.org/x/net/html"
|
|
"golang.org/x/net/html/atom"
|
|
)
|
|
|
|
const htmlProjectionVersion = "controlled-v3"
|
|
const maxProjectionInput = 1 << 20
|
|
const maxProjectionOutput = 4 << 20
|
|
|
|
var projectionMacroRE = regexp.MustCompile(`\{\{(?:csv:[^}]*|children[^}]*|(?:city-breadcrumbs|spot-pages|quartier|street|spot|nearby|city)(?:\s+[^}]*)?)\}\}`)
|
|
var languageClassRE = regexp.MustCompile(`^language-[a-zA-Z0-9_+-]{1,40}$`)
|
|
|
|
func projectionPolicy(generated bool) *bluemonday.Policy {
|
|
p := bluemonday.NewPolicy()
|
|
p.AllowStandardURLs()
|
|
p.RequireNoReferrerOnLinks(true)
|
|
p.AllowElements("p", "br", "hr", "div", "span", "h1", "h2", "h3", "h4", "h5", "h6", "blockquote", "pre", "code", "b", "strong", "i", "em", "u", "s", "del", "ins", "sub", "sup", "small", "mark", "abbr", "kbd", "samp", "var", "ul", "ol", "li", "dl", "dt", "dd", "table", "thead", "tbody", "tfoot", "tr", "th", "td", "caption", "colgroup", "col", "figure", "figcaption", "details", "summary", "section", "article")
|
|
p.AllowAttrs("href").OnElements("a")
|
|
p.AllowAttrs("title", "lang", "dir").Globally()
|
|
p.AllowAttrs("id").Matching(regexp.MustCompile(`^[^\s]{1,256}$`)).Globally()
|
|
p.AllowAttrs("class").Matching(languageClassRE).OnElements("code")
|
|
p.AllowAttrs("src", "alt").OnElements("img")
|
|
p.AllowAttrs("width", "height", "colspan", "rowspan", "span", "start", "value").Matching(regexp.MustCompile(`^[0-9]{1,4}$`)).OnElements("img", "td", "th", "col", "colgroup", "ol", "li")
|
|
p.AllowAttrs("open").Matching(regexp.MustCompile(`^(open)?$`)).OnElements("details")
|
|
if generated {
|
|
// Only the server's macro renderer can introduce these attributes. The
|
|
// authored pass does not allow data-*, arbitrary classes, forms or IDs
|
|
// outside the document namespace after tree normalization.
|
|
p.AllowElements("nav")
|
|
p.AllowAttrs("class", "role", "aria-label").Globally()
|
|
p.AllowAttrs("data-children-path", "data-children-exclude", "data-children-src").OnElements("section")
|
|
p.AllowAttrs("loading", "referrerpolicy").OnElements("img")
|
|
}
|
|
return p
|
|
}
|
|
|
|
var authoredHTMLPolicy = projectionPolicy(false)
|
|
var generatedHTMLPolicy = projectionPolicy(true)
|
|
|
|
func projectionFallback(body, message string) string {
|
|
if len(body) > 64<<10 {
|
|
body = body[:64<<10]
|
|
}
|
|
return `<p class="projection-warning" role="status">` + stdhtml.EscapeString(message) + `</p><pre>` + stdhtml.EscapeString(body) + `</pre>`
|
|
}
|
|
|
|
func projectionInputOK(ctx context.Context, body string) bool {
|
|
if len(body) > maxProjectionInput {
|
|
return false
|
|
}
|
|
z := html.NewTokenizer(strings.NewReader(body))
|
|
z.SetMaxBuf(maxProjectionInput)
|
|
depth := 0
|
|
for count := 0; count < 16384; count++ {
|
|
if count%128 == 0 && ctx.Err() != nil {
|
|
return false
|
|
}
|
|
switch z.Next() {
|
|
case html.ErrorToken:
|
|
return z.Err() == io.EOF
|
|
case html.StartTagToken:
|
|
name, _ := z.TagName()
|
|
switch string(name) {
|
|
case "br", "hr", "img", "meta", "link", "input", "wbr", "source", "area", "base", "embed", "param", "track", "col":
|
|
default:
|
|
depth++
|
|
}
|
|
if depth > 128 {
|
|
return false
|
|
}
|
|
case html.EndTagToken:
|
|
if depth > 0 {
|
|
depth--
|
|
}
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func documentAnchor(id string) string { return fmt.Sprintf("pw-doc-%x", sha256.Sum256([]byte(id))) }
|
|
|
|
// extractApprovedExternalActiveResources runs before the authored allowlist,
|
|
// which intentionally knows nothing about script or link elements. An
|
|
// approved element becomes unpredictable text; its canonical server-authored
|
|
// tag is restored only after the generated-output allowlist has also run.
|
|
func extractApprovedExternalActiveResources(body string, policy externalResourcePolicy) (string, map[string]string) {
|
|
var seed [18]byte
|
|
if _, err := rand.Read(seed[:]); err != nil {
|
|
return body, nil
|
|
}
|
|
prefix := "PWEXT-" + base64.RawURLEncoding.EncodeToString(seed[:]) + "-"
|
|
fragments := map[string]string{}
|
|
var output strings.Builder
|
|
z := html.NewTokenizer(strings.NewReader(body))
|
|
z.SetMaxBuf(maxProjectionInput)
|
|
skippingApprovedScript := false
|
|
for {
|
|
tokenType := z.Next()
|
|
if tokenType == html.ErrorToken {
|
|
break
|
|
}
|
|
if skippingApprovedScript {
|
|
if tokenType == html.EndTagToken {
|
|
token := z.Token()
|
|
if strings.EqualFold(token.Data, "script") {
|
|
skippingApprovedScript = false
|
|
}
|
|
}
|
|
continue
|
|
}
|
|
if tokenType != html.StartTagToken && tokenType != html.SelfClosingTagToken {
|
|
output.Write(z.Raw())
|
|
continue
|
|
}
|
|
token := z.Token()
|
|
name := strings.ToLower(token.Data)
|
|
attrs := map[string]string{}
|
|
for _, attr := range token.Attr {
|
|
attrs[strings.ToLower(attr.Key)] = attr.Val
|
|
}
|
|
kind, resourceURL := "", ""
|
|
switch name {
|
|
case "script":
|
|
kind, resourceURL = "script", attrs["src"]
|
|
case "link":
|
|
if strings.EqualFold(strings.TrimSpace(attrs["rel"]), "stylesheet") {
|
|
kind, resourceURL = "stylesheet", attrs["href"]
|
|
}
|
|
}
|
|
approval, approved := policy.approved(kind, resourceURL)
|
|
if !approved {
|
|
output.Write(z.Raw())
|
|
continue
|
|
}
|
|
placeholder := prefix + fmt.Sprint(len(fragments))
|
|
var node *html.Node
|
|
if kind == "script" {
|
|
node = &html.Node{Type: html.ElementNode, Data: "script", DataAtom: atom.Script, Attr: []html.Attribute{
|
|
{Key: "src", Val: approval.URL}, {Key: "integrity", Val: approval.Integrity},
|
|
{Key: "crossorigin", Val: "anonymous"}, {Key: "defer", Val: "defer"},
|
|
}}
|
|
if tokenType == html.StartTagToken {
|
|
skippingApprovedScript = true
|
|
}
|
|
} else {
|
|
node = &html.Node{Type: html.ElementNode, Data: "link", DataAtom: atom.Link, Attr: []html.Attribute{
|
|
{Key: "rel", Val: "stylesheet"}, {Key: "href", Val: approval.URL},
|
|
{Key: "integrity", Val: approval.Integrity}, {Key: "crossorigin", Val: "anonymous"},
|
|
}}
|
|
}
|
|
var fragment strings.Builder
|
|
if html.Render(&fragment, node) != nil {
|
|
output.Write(z.Raw())
|
|
continue
|
|
}
|
|
fragments[placeholder] = fragment.String()
|
|
output.WriteString(placeholder)
|
|
}
|
|
return output.String(), fragments
|
|
}
|
|
|
|
// safeHTMLProjection is the only authored-HTML display boundary. It never
|
|
// writes Documents/Revisions and never fetches an external resource. Canonical
|
|
// Markdown conversion deliberately does not call it.
|
|
func (s *Server) safeHTMLProjection(r *http.Request, body, path string, expand bool) string {
|
|
ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second)
|
|
defer cancel()
|
|
r = r.WithContext(ctx)
|
|
fallback := func() string {
|
|
return projectionFallback(body, translate(s.getLocale(s.domainUUIDForRequest(r)), "viewer.html_projection_unavailable"))
|
|
}
|
|
if !projectionInputOK(r.Context(), body) {
|
|
return fallback()
|
|
}
|
|
resourcePolicy := s.externalResourcePolicy(s.domainUUIDForRequest(r))
|
|
body, externalFragments := extractApprovedExternalActiveResources(body, resourcePolicy)
|
|
safe := authoredHTMLPolicy.Sanitize(body)
|
|
root := &html.Node{Type: html.ElementNode, Data: "div", DataAtom: atom.Div}
|
|
nodes, err := html.ParseFragment(strings.NewReader(safe), root)
|
|
if err != nil {
|
|
return fallback()
|
|
}
|
|
var output strings.Builder
|
|
macros, count := 0, 0
|
|
csvCount := 0
|
|
csvResults := map[string]string{}
|
|
var emit func(*html.Node, int, bool) bool
|
|
emit = func(n *html.Node, depth int, literal bool) bool {
|
|
count++
|
|
if count > 16384 || depth > 128 || output.Len() > maxProjectionOutput || r.Context().Err() != nil {
|
|
return false
|
|
}
|
|
if n.Type == html.TextNode {
|
|
if !expand || literal {
|
|
output.WriteString(stdhtml.EscapeString(n.Data))
|
|
return true
|
|
}
|
|
at := 0
|
|
for _, loc := range projectionMacroRE.FindAllStringIndex(n.Data, 33) {
|
|
if ctx.Err() != nil {
|
|
return false
|
|
}
|
|
macros++
|
|
if macros > 32 {
|
|
return false
|
|
}
|
|
output.WriteString(stdhtml.EscapeString(n.Data[at:loc[0]]))
|
|
macro := n.Data[loc[0]:loc[1]]
|
|
expanded := macro
|
|
// Dispatch exactly one macro. A failed City macro must never
|
|
// be reparsed as a nested children request on its raw text.
|
|
if isAnonymousProjection(r) {
|
|
expanded = s.expandPublicMacro(r, macro, path)
|
|
} else if strings.HasPrefix(macro, "{{csv:") {
|
|
if cached, ok := csvResults[macro]; ok {
|
|
expanded = cached
|
|
} else if csvCount < 4 {
|
|
csvCount++
|
|
expanded = s.expandCSVMacro(r, macro)
|
|
csvResults[macro] = expanded
|
|
}
|
|
} else if strings.HasPrefix(macro, "{{children") {
|
|
expanded = s.expandChildrenMacros(macro, path)
|
|
} else {
|
|
expanded = s.expandCityMacrosContext(ctx, macro, path, s.domainUUIDForRequest(r), s.pathReadFilter(r))
|
|
}
|
|
if expanded == macro {
|
|
// Failed/unresolved macros are still authored text. Do not
|
|
// promote decoded entities into trusted generated elements.
|
|
output.WriteString(stdhtml.EscapeString(macro))
|
|
} else {
|
|
if output.Len()+len(expanded) > maxProjectionOutput {
|
|
return false
|
|
}
|
|
output.WriteString(expanded)
|
|
}
|
|
at = loc[1]
|
|
}
|
|
output.WriteString(stdhtml.EscapeString(n.Data[at:]))
|
|
return true
|
|
}
|
|
if n.Type != html.ElementNode {
|
|
return true
|
|
}
|
|
attrs := n.Attr[:0]
|
|
for _, a := range n.Attr {
|
|
switch a.Key {
|
|
case "id":
|
|
a.Val = documentAnchor(a.Val)
|
|
case "href":
|
|
if strings.HasPrefix(a.Val, "#") {
|
|
a.Val = "#" + documentAnchor(strings.TrimPrefix(a.Val, "#"))
|
|
}
|
|
case "src":
|
|
u, e := url.Parse(a.Val)
|
|
if e != nil || strings.ContainsAny(a.Val, "\\\r\n\t") {
|
|
continue
|
|
}
|
|
if u.IsAbs() || u.Host != "" {
|
|
approval, ok := resourcePolicy.approved("image", a.Val)
|
|
if !ok || n.Data != "img" {
|
|
continue
|
|
}
|
|
a.Val = approval.URL
|
|
attrs = append(attrs, a)
|
|
continue
|
|
}
|
|
u.Path = pathpkg.Clean(u.Path)
|
|
// Images are passive read projections, not arbitrary authenticated
|
|
// GETs against editors, login flows or management endpoints.
|
|
if !strings.HasPrefix(u.Path, "/v/raw/") && !strings.HasPrefix(u.Path, "/_/obj/") && !strings.HasPrefix(u.Path, "/static/") && !strings.HasPrefix(u.Path, "/o/path:/system/static/") {
|
|
continue
|
|
}
|
|
u.RawPath = ""
|
|
a.Val = u.String()
|
|
}
|
|
attrs = append(attrs, a)
|
|
}
|
|
n.Attr = attrs
|
|
if n.Data == "img" {
|
|
n.Attr = append(n.Attr, html.Attribute{Key: "loading", Val: "lazy"}, html.Attribute{Key: "referrerpolicy", Val: "no-referrer"})
|
|
}
|
|
// Render a shallow element to let net/html escape its attributes; never
|
|
// interpolate authored attributes into the macro output context.
|
|
shallow := &html.Node{Type: html.ElementNode, Data: n.Data, DataAtom: n.DataAtom, Attr: n.Attr}
|
|
var tag strings.Builder
|
|
if html.Render(&tag, shallow) != nil {
|
|
return false
|
|
}
|
|
opening := tag.String()
|
|
closing := "</" + n.Data + ">"
|
|
void := !strings.HasSuffix(opening, closing)
|
|
if !void {
|
|
opening = strings.TrimSuffix(opening, closing)
|
|
}
|
|
output.WriteString(opening)
|
|
for child := n.FirstChild; child != nil; child = child.NextSibling {
|
|
if !emit(child, depth+1, literal || n.Data == "code" || n.Data == "pre" || n.Data == "a") {
|
|
return false
|
|
}
|
|
}
|
|
if !void {
|
|
output.WriteString(closing)
|
|
}
|
|
return true
|
|
}
|
|
for _, n := range nodes {
|
|
if !emit(n, 0, false) {
|
|
return fallback()
|
|
}
|
|
}
|
|
if output.Len() > maxProjectionOutput {
|
|
return fallback()
|
|
}
|
|
projected := output.String()
|
|
if expand && !isAnonymousProjection(r) {
|
|
projected = s.renderDiagramsInHTML(r, path, projected)
|
|
}
|
|
// A second allowlist pass guards all generated URL/HTML output too. Active
|
|
// external resources only exist as random text at this boundary, so macro
|
|
// output cannot manufacture an approved script or stylesheet tag.
|
|
projected = generatedHTMLPolicy.Sanitize(projected)
|
|
for token, fragment := range externalFragments {
|
|
projected = strings.ReplaceAll(projected, token, fragment)
|
|
}
|
|
return projected
|
|
}
|