HTML and escaping
Bond.html sends the text as it is. If a value that a client sent is put in it, the client writes part of your page: a name like <script>...</script> runs in the browser of everyone who sees the page (cross-site scripting, XSS). Escape the value.
Bond.escape(text) is HTML.escape of std/html: it replaces &, <, >, " and ' with &, <, >, " and '. Escape every value that you interpolate into HTML, at the place where you write it, not before: a value escaped early is escaped twice or not at all by the next function that touches it.
import Bond from "pkg/bond/bond"
import Testing from "pkg/bond/testing"
def greet(conn: Bond.Conn) -> Result[Bond.Conn]
name = try Bond.query(conn, "name")
return ok(Bond.html(conn, 200, "<p>Hello, #{Bond.escape(name)}</p>"))
end
def page_not_found(conn: Bond.Conn) -> Result[Bond.Conn]
return ok(Bond.html(conn, 404, "<h1>Nothing at #{Bond.escape(conn.path)}</h1>"))
end
def main() -> Void
app = Bond.app() |> Bond.get("/greet", &greet) |> Bond.not_found(&page_not_found)
puts(Testing.text(Testing.request(app, "GET", "/greet?name=Ana")).unwrap!)
puts(Testing.text(Testing.request(app, "GET", "/greet?name=%3Cscript%3Ealert(1)%3C%2Fscript%3E")).unwrap!)
puts(Testing.text(Testing.request(app, "GET", "/greet?name=%22+onmouseover%3D%22x")).unwrap!)
puts(Testing.text(Testing.request(app, "GET", "/<b>")).unwrap!)
end<p>Hello, Ana</p>
<p>Hello, <script>alert(1)</script></p>
<p>Hello, " onmouseover="x</p>
<h1>Nothing at /<b></h1>Templates #
An EAG template (<<~EAG, its page) writes the page as text with tags, and its <%= value %> inserts the value as it is. A first line <%@ escape &Bond.escape %> gives the template an escaper: every <%= %> is then escaped, in the text and in a quoted attribute, so a handler cannot forget one. <%== value %> is the raw form, for markup that you wrote yourself (there is no Bond.raw): never put a value of the client in it. The file needs import EAG from "std/eag".
import EAG from "std/eag"
import Bond from "pkg/bond/bond"
import Testing from "pkg/bond/testing"
def profile(conn: Bond.Conn) -> Result[Bond.Conn]
name = try Bond.query(conn, "name")
badge = "<b>member</b>"
page = <<~EAG
<%@ escape &Bond.escape %>
<h1 title='<%= name %>'>Hello, <%= name %></h1>
<p><%== badge %></p>
EAG
return ok(Bond.html(conn, 200, page))
end
def main() -> Void
app = Bond.app() |> Bond.get("/profile", &profile)
puts(Testing.text(Testing.request(app, "GET", "/profile?name=%3Cscript%3Ealert(1)%3C%2Fscript%3E")).unwrap!)
end<h1 title='<script>alert(1)</script>'>Hello, <script>alert(1)</script></h1>
<p><b>member</b></p>The directive does not make every value safe: the rules below (a URL, an event attribute, JSON in a <script>) hold in a template too. For partials and a layout, see Views.
What comes from the client #
Treat as client text every value from the query, form, cookie and JSON readers (maps, lists and every string in a struct from Bond.json_body too), Bond.param, Bond.request_header and conn.body. conn.path is the raw path, not decoded or checked: escape it too. So are values from your own database that a client wrote (a comment, a user name): escape at the output, not at the input.
What Bond.escape is for #
It is right for text between tags, and for a value inside a quoted attribute (<input value="#{Bond.escape(value)}">), since it escapes both quotes. It is not enough in the places below.
- An attribute without quotes, or the text of a
<style>: do not put a client value there. - An event attribute such as
onclick: the HTML parser decodes'back to'before the JavaScript runs, so an escaped value still ends the string in the script. Put the value in adata-attribute and read it from a script. - A URL in
href,srcor a redirect: escaping does not stopjavascript:alert(1). A local URL starts with/, its second character is not/or\(//evil.comand/\evil.comgo to another site), and it has no control character (a browser drops a tab or newline inside a URL). Otherwise accept only anhttps://address that your app allows. Still escape the value in the quoted attribute.Bond.redirectchecks nothing, so apply the rule to a target that a client gave (?next=...) first, as the sample below does: see Redirects. - JSON in a page:
Bond.escapeis wrong inside a<script>, which does not decode entities. Encode the value withJSON.encode(JSON.from(value))and replace<with\u003c, so</script>cannot end the script. In adata-x="..."attribute, useBond.escape(JSON.encode(JSON.from(value))).
import Bond from "pkg/bond/bond"
import Testing from "pkg/bond/testing"
def local_url?(target: String) -> Bool
if not target.start_with?("/")
return false
end
second = target.slice(1, 1)
if second == "/" or second == "\\"
return false
end
controls = target.split("").select do |ch| ch.code < 32 end
return controls.empty?
end
def script_json(value: String) -> String
return JSON.encode(JSON.from(value)).replace("<", "\\u003c")
end
def go(conn: Bond.Conn) -> Result[Bond.Conn]
target = Bond.query(conn, "next").unwrap_or("/")
if not local_url?(target)
return ok(Bond.redirect(conn, "/"))
end
return ok(Bond.redirect(conn, target))
end
def page(conn: Bond.Conn) -> Result[Bond.Conn]
name = try Bond.query(conn, "name")
link = Bond.query(conn, "next").unwrap_or("/")
body = "<script>var name = #{script_json(name)};</script>"
data = "<p data-name=\"#{Bond.escape(JSON.encode(JSON.from(name)))}\"></p>"
anchor = "<a href=\"#{Bond.escape(link)}\">next</a>"
return ok(Bond.html(conn, 200, "#{body}\n#{data}\n#{anchor}"))
end
def main() -> Void
app = Bond.app() |> Bond.get("/go", &go) |> Bond.get("/page", &page)
for target in ["/done", "//evil.com", "%2F%5Cevil.com", "javascript:alert(1)"]
response = Testing.request(app, "GET", "/go?next=#{target}")
locations = response.headers.select do |h| h.name == "location" end
puts("#{target} #{locations.map do |h| h.value end}")
end
puts(Testing.text(Testing.request(app, "GET", "/page?name=%3C%2Fscript%3E%22&next=%22%3E")).unwrap!)
end/done ["/done"]
//evil.com ["/"]
%2F%5Cevil.com ["/"]
javascript:alert(1) ["/"]
<script>var name = "\u003c/script>\"";</script>
<p data-name=""</script>\"""></p>
<a href="">">next</a>Never HTML.unescape a client value and then put it in a page.
What Bond writes itself #
Bond puts no value of the client into an answer of its own. The 404, 405 and 500 have fixed texts, and so has each 400 of query, form and json_body (the name in the text is the one in your code). They and the message of Bond.bad_request are text/plain, which a browser does not show as markup. The handlers you give to Bond.not_found and Bond.on_error are your code: the rules of this page apply to them. Bond.static serves files as they are: a .html file of the folder is as safe as you wrote it.