Tagged template literals were added to Javascript as part of ES 2015. While a fair bit has been written about them, I’m going to argue their significance is underappreciated and I’m hoping this post will help change that. In part, it’s significant because it strikes at the root of a problem people had otherwise resigned themselves to living with: SQL injection.
Just so we are clear, before ES 2015, combining query strings with untrusted user input to create a SQL injection was done via concatenation using the plus operator.
let query = 'select * from widgets where id = ' + id + ';'
As of ES 2015, you can create far more stylish SQL injections using backticks.
let query = `select * from widgets where id = ${id};`
By itself this addition is really only remarkable for not being included in the language sooner. The backticks are weird, but it gives us some much-needed multiline string support and a very Rubyish string interpolation syntax. It’s pairing this new syntax with another language feature known as tagged templates that has a real potential to make an impact on SQL injections.
> let id = 1 // define a function to use as a "tag" > sql = (strings, ...vars) => ({strings, vars}) [Function: sql] // pass our tag a template literal > sql`select * from widgets where id = ${id};` { strings: [ 'select * from widgets where id = ', ';' ], vars: [ 1 ] }
What you see above is just a function call, but it no longer works like other languages. Instead of doing the variable interpolation first and then calling the sql
function with select * from widgets where id = 1;
, the sql
function is called with an array of strings and the variables that are supposed to be interpolated.
You can see how different this is from the standard evaluation process by adding brackets to make this a standard function invocation. The string is interpolated before being passed to the sql
function, entirely loosing the distinction between the variable (which we probably don’t trust) and the string (that we probably do). The result is an injected string and an empty array of variables.
> sql(`select * from widgets where id = ${id};`) { strings: 'select * from widgets where id = 1;', vars: [] }
This loss of context is the heart of matter when it comes to SQL injection (or injection attacks generally). The moment the strings and variables are combined you have a problem on your hands.
So why not just use parameterized queries or something similar? It’s generally held that good code expresses the programmers intent. I would argue that our SQL injection example code perfectly expresses the programmers intent; they want the id
variable to be included in the query string. As a perfect expression of the programmers intent, this should be acknowledged as “good code”… as well as a horrendous security problem.
let query = sql(`select * from widgets where id = ${id};`)
When the clearest expression of a programmers intent is also a security problem what you have is a systemic issue which requires a systemic fix. This is why despite years of security education, developer shaming and “push left” pep-talks SQL injection stubbornly remains “the hack that will never go away”. It’s also why you find Mike Samuel from Google’s security team as the champion of the “Template Strings” proposal.
You can see the fruits of this labour by noticing library authors leveraging this to deliver a great developer experience while doing the right thing for security. Allan Plum, the driving force behind the Arangodb Javascript driver leveraging tagged template literals to let users query ArangoDB safely.
The aql
(Arango Query Language) function lets you write what would in any other language be an intent revealing SQL injection, safely returns an object with a query and some accompanying bindvars.
aql`FOR thing IN collection FILTER thing.foo == ${foo} RETURN thing` { query: 'FOR thing IN collection FILTER thing.foo == @value0 RETURN thing', bindVars: { value0: 'bar' } }
Mike Samuel himself has a number of node libraries that leverage Tagged Template Literals, among them one to safely handle shell commands.
sh`echo -- ${a} "${b}" 'c: ${c}'`
It’s important to point out that Tagged Template Literals don’t entirely solve SQL injections, since there are no guarantees that any particular tag function will do “the right thing” security-wise, but the arguments the tag function receives set library authors up for success.
Authors using them get to offer an intuitive developer experience rather than the clunkiness of prepared statements, even though the tag function may well be using them under the hood. The best experience is from safest thing; It’s a great example of creating a “pit of success” for people to fall into.
// Good security hinges on devs learning to write // stuff like this instead of stuff that makes sense. // Clunky prepared statement is clunky. const ps = new sql.PreparedStatement(/* [pool] */) ps.input('param', sql.Int) ps.prepare('select * from widgets where id = @id;', err => { // ... error checks ps.execute({id: 1}, (err, result) => { // ... error checks ps.unprepare(err => { // ... error checks }) }) })
It’s an interesting thought that Javascripts deficiencies seem to have become it’s strength. First Ryan Dahl filled out the missing IO pieces to create Node JS and now missing features like multiline string support provide an opportunity for some of the worlds most brilliant minds to insert cutting edge security features along-side these much needed fixes.
I’m really happy to finally see language level fixes for things that are clearly language level problems, and excited to see where Mike Samuel’s mission to “make the easiest way to express an idea in code a secure way to express that idea” takes Javascript next. It’s the only way I can see to make “the hack that will never go away” go away.