Files
summercms/modules/postcard/safety.go
Jakub Zych 1d481bb02d fix(35): CR-02 check raw-text element and comment content as markup
The tokenizer-only walk read noscript, title, textarea, style, xmp and the
other raw-text elements as one text token and never looked inside, so an
unencoded javascript: link in <noscript> or <svg><title> passed the check
and was sent. A mail client renders with scripting off and parses svg
children as markup, so the raw content of those elements, and comment
data (Outlook conditional comments), is now checked again as markup;
nesting deeper than eight levels is refused.
2026-11-14 17:30:07 +01:00

215 lines
7.6 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 dangerousScheme matches anywhere in it.
var urlListAttributes = map[string]bool{
"srcset": true,
"ping": true,
"archive": true,
"values": true,
}
// hasDangerousScheme reports whether a decoded URL attribute value starts
// with javascript:, vbscript: or data:, after every ASCII whitespace and
// control character is removed and the value is lower-cased, the way
// browsers read it ("java\tscript:" is javascript:).
func hasDangerousScheme(val string) bool {
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)
}
v := b.String()
return strings.HasPrefix(v, "javascript:") || strings.HasPrefix(v, "vbscript:") || strings.HasPrefix(v, "data:")
}
// 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] && dangerousScheme.MatchString(a.Val),
key == "style" && dangerousScheme.MatchString(a.Val),
t.Data == "meta" && key == "content" && dangerousScheme.MatchString(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 && dangerousScheme.MatchString(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 dangerousScheme.MatchString(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
}
}
}
}