Files
summercms/modules/postcard/safety.go
Jakub Zych baba524caf fix(35): WR-01 strip whitespace before the list, meta, CSS and comment scheme checks
Single-URL attributes removed ASCII whitespace and control characters
before looking for a scheme, the list-valued, meta content, style and
comment checks did not, so values="java	script:..." and a tab-split
meta refresh passed. The stripping is factored out as stripURLSpace and
used by every scheme check.
2026-11-14 17:32:14 +01:00

230 lines
8.1 KiB
Go

package postcard
import (
"html"
"regexp"
"strings"
xhtml "golang.org/x/net/html"
)
// scriptURLText finds a script URL in text: javascript: or vbscript: at a
// scheme boundary, or data: at a scheme boundary directly followed by a
// non-space character (a data URL). A boundary is the start of the text or a
// character that cannot belong to a URL scheme, so "Metadata: Weekly" and
// "Big Data: Summit" do not match.
var scriptURLText = regexp.MustCompile(`(?i)(?:^|[^a-z0-9+.\-])(?:(?:javascript|vbscript):|data:\S)`)
// UnsafeText reports whether a text that a layout prints, such as the site
// name of the built-in layouts, must be kept out of mail. A text is unsafe
// when, HTML-escaped as html/template prints text, it fails the rendered-HTML
// safety checks in the places the built-in layouts print it (for example
// event-handler-shaped text such as "Shop onclick=x", or "Online=Shop" after
// the footer's "© <year> "), or when it holds a script URL: javascript: or
// vbscript: at a scheme boundary, or a data: URL. "Big Data: Summit" is safe;
// "javascript: Acme" is not.
func UnsafeText(s string) bool {
return validateHTML(printContext(html.EscapeString(s))) != nil || scriptURLText.MatchString(s)
}
// printContext is the markup the built-in layouts print an escaped site name
// in: after "© <year> " in the footer paragraph, in the header's span and in
// the logo's alt attribute. A text is checked there, not on its own, so a
// check that depends on what precedes the text (a whitespace-prefixed
// handler) sees what a send renders.
func printContext(esc string) string {
return "<p>© 2000 " + esc + "</p><span>" + esc + "</span><img alt=\"" + esc + "\">"
}
// urlAttributes are the attributes that hold one URL. Their decoded value is
// refused when it starts with a script or data scheme.
var urlAttributes = map[string]bool{
"action": true,
"background": true,
"cite": true,
"codebase": true,
"data": true,
"dynsrc": true,
"formaction": true,
"href": true,
"icon": true,
"longdesc": true,
"lowsrc": true,
"manifest": true,
"poster": true,
"profile": true,
"src": true,
"usemap": true,
"xlink:href": true,
// SVG animation targets can set an href.
"from": true,
"to": true,
"by": true,
}
// urlListAttributes hold several URLs (or values that can be URLs). Their
// decoded value is refused when containsDangerousScheme finds a scheme
// anywhere in it.
var urlListAttributes = map[string]bool{
"srcset": true,
"ping": true,
"archive": true,
"values": true,
}
// stripURLSpace removes every ASCII whitespace and control character
// (U+0000 to U+0020 and U+007F) from val and lower-cases it, the way
// browsers read a URL ("java\tscript:" is javascript:).
func stripURLSpace(val string) string {
var b strings.Builder
b.Grow(len(val))
for i := 0; i < len(val); i++ {
c := val[i]
if c <= 0x20 || c == 0x7f {
continue
}
if 'A' <= c && c <= 'Z' {
c += 'a' - 'A'
}
b.WriteByte(c)
}
return b.String()
}
// hasDangerousScheme reports whether a decoded URL attribute value starts
// with javascript:, vbscript: or data:, once stripURLSpace has removed
// whitespace and control characters.
func hasDangerousScheme(val string) bool {
v := stripURLSpace(val)
return strings.HasPrefix(v, "javascript:") || strings.HasPrefix(v, "vbscript:") || strings.HasPrefix(v, "data:")
}
// containsDangerousScheme reports whether dangerousScheme matches anywhere
// in a decoded value (a URL list, CSS, meta content or a comment) once
// stripURLSpace has removed whitespace and control characters, so a
// tab-split "java&#9;script:" is found as in a single-URL attribute.
func containsDangerousScheme(val string) bool {
return dangerousScheme.MatchString(stripURLSpace(val))
}
// rawTextElements are the elements whose content x/net/html's tokenizer
// reads as one text token (raw text or RCDATA). A mail client may parse that
// content as markup: it renders with scripting off, so noscript content is
// markup, and title, textarea, style, xmp and the like are foreign elements
// with markup children inside svg or math. unsafeMarkup checks their content
// as markup too.
var rawTextElements = map[string]bool{
"iframe": true,
"noembed": true,
"noframes": true,
"noscript": true,
"plaintext": true,
"script": true,
"style": true,
"textarea": true,
"title": true,
"xmp": true,
}
// unsafeMarkup checks the markup of rendered HTML: event-handler attributes
// and javascript:, vbscript: or data: URLs. It reads doc with x/net/html's
// tokenizer, which lower-cases attribute names and decodes character
// references in attribute values, so href="javascript&#58;x" is read as a
// mail client reads it.
//
// URL schemes are looked for only where a URL can be: single-URL attributes
// (urlAttributes, by prefix), list-valued attributes (urlListAttributes),
// style attributes, the content of meta elements, the text of style
// elements and comments (anywhere in the value). Text content is not a URL,
// so prose such as "metadata:" or "Big Data: Summit" is not checked. Any
// attribute whose name starts with "on" is an event handler, with or
// without whitespace before it.
//
// The content of a raw-text element (rawTextElements) and of a comment is
// checked again as markup, because a mail client may read it so (noscript
// with scripting off, title or textarea in svg, Outlook's conditional
// comments). Each nested check reads a strictly shorter text, so the
// recursion ends; markup nested deeper than maxMarkupDepth is refused.
func unsafeMarkup(doc string) error {
return unsafeMarkupAt(doc, 0)
}
// maxMarkupDepth is how deep raw-text elements and comments may nest inside
// each other. Mail markup needs one or two levels (a style element, an
// Outlook conditional comment); a deeper document is refused rather than
// read again and again.
const maxMarkupDepth = 8
func unsafeMarkupAt(doc string, depth int) error {
if depth > maxMarkupDepth {
return &unsafeError{msg: "rendered HTML nests raw-text elements or comments too deeply", snippet: snippetAt(doc, []int{0, min(len(doc), 48)})}
}
z := xhtml.NewTokenizer(strings.NewReader(doc))
offset := 0
inStyle := false
// rawTag is the raw-text element whose content the next text token is.
rawTag := ""
for {
tt := z.Next()
if tt == xhtml.ErrorToken {
return nil
}
raw := string(z.Raw())
start := offset
offset += len(raw)
loc := []int{start, offset}
t := z.Token()
inRaw := rawTag != ""
rawTag = ""
switch tt {
case xhtml.StartTagToken, xhtml.SelfClosingTagToken:
for _, a := range t.Attr {
key := a.Key
if a.Namespace != "" {
key = a.Namespace + ":" + a.Key
}
switch {
case strings.HasPrefix(key, "on"):
return &unsafeError{msg: "rendered HTML contains event handlers", snippet: snippetAt(doc, loc)}
case urlAttributes[key] && hasDangerousScheme(a.Val),
urlListAttributes[key] && containsDangerousScheme(a.Val),
key == "style" && containsDangerousScheme(a.Val),
t.Data == "meta" && key == "content" && containsDangerousScheme(a.Val):
return &unsafeError{msg: "rendered HTML contains a dangerous URL scheme", snippet: snippetAt(doc, loc)}
}
}
// The tokenizer reads the content of a raw-text element as text
// even after a self-closing start tag (<style/>), as browsers do.
if rawTextElements[t.Data] {
rawTag = t.Data
}
if t.Data == "style" {
inStyle = true
}
case xhtml.EndTagToken:
if t.Data == "style" {
inStyle = false
}
case xhtml.TextToken:
if inStyle && containsDangerousScheme(t.Data) {
return &unsafeError{msg: "rendered HTML contains a dangerous URL scheme", snippet: snippetAt(doc, loc)}
}
// The raw source, not the decoded text: RCDATA (title,
// textarea) is decoded by the tokenizer, and &lt;a&gt; in it is
// text to every reader.
if inRaw {
if err := unsafeMarkupAt(raw, depth+1); err != nil {
return err
}
}
case xhtml.CommentToken:
if containsDangerousScheme(t.Data) {
return &unsafeError{msg: "rendered HTML contains a dangerous URL scheme", snippet: snippetAt(doc, loc)}
}
if err := unsafeMarkupAt(t.Data, depth+1); err != nil {
return err
}
}
}
}