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 (whitespace may follow the colon of a script URL, so // "javascript: Acme" matches), or a data URL: data: at a scheme boundary, // then an optional MIME type and the ";" or "," every data URL has // ("data:text/html,x", "data:,x"). A boundary is the start of the text or a // character that cannot belong to a URL scheme, so "Metadata: Weekly" does // not match; nor do "Big Data: Summit" and "Data:Lab", which are no data // URLs. var scriptURLText = regexp.MustCompile(`(?i)(?:^|[^a-z0-9+.\-])(?:(?:javascript|vbscript):|data:\s*(?:[a-z]+/[a-z0-9.+\-]+\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, or when it holds // a script URL: javascript: or vbscript: at a scheme boundary, or a data: // URL. Escaped text is never markup, so "Big Data: Summit", "Data:Lab", // "Online=Shop" and "Shop onclick=x" are safe; "javascript: Acme" and // "data:text/html,x" are 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 "© " 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 "

© 2000 " + esc + "

" + 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 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: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 (