Conteúdo do curso Lição 63 de 156 · Injeção de script (XSS)
Injeção de script (XSS)

Templates que fazem escape por padrão

Por que isso importa Raramente você vai colar HTML à mão. Sites reais usam templates, e bons sistemas de templates fazem o escape de todo valor para você. Seu trabalho é principalmente não desligar isso por acidente, e reconhecer as poucas chaves que o desligam.

Uma analogia: um carro que freia por você

Carros modernos freiam sozinhos se você está prestes a bater em algo. Você pode desligar o recurso, e às vezes há um bom motivo. Mas toda vez que ele está desligado, vale perguntar por quê. O escape automático é igual: ligado por padrão nas boas ferramentas, com alguns jeitos claramente nomeados de desligá-lo.

Template: um arquivo HTML com lacunas, como {{ name }}, que o servidor preenche para cada página. O motor de templates é o código que preenche as lacunas.

Escape automático: o motor de templates faz o escape de todo valor que coloca em uma lacuna, a menos que você diga que o valor já é seguro.

Django

Os templates do Django fazem o escape de todo {{ value }} por padrão: <, >, &, " e ', os mesmos cinco que você escapou à mão. As páginas dos cursos deste site são construídas assim.

{# safe: escaped automatically #}
<p>{{ review.text }}</p>
<input name="q" value="{{ query }}">

{# the dangerous switches: each one turns escaping off #}
{{ review.text|safe }}
{% autoescape off %}{{ review.text }}{% endautoescape %}

No código Python, mark_safe(text) diz ao Django "isto já é HTML, não faça o escape". Use-o só em texto que o seu próprio código escreveu. Quando precisar montar um pequeno pedaço de HTML em Python, use format_html, que faz o escape de todo valor que você passa:

from django.utils.html import format_html
from django.utils.safestring import mark_safe

bad = mark_safe(f"<b>{user_name}</b>")            # user_name is NOT escaped
good = format_html("<b>{}</b>", user_name)          # user_name IS escaped

Para passar dados ao JavaScript da sua página, use o filtro json_script em vez de colar valores em um bloco <script>. Ele escreve os dados como JSON de um jeito que não consegue fechar a tag de script antes da hora.

Jinja (e Flask)

O Jinja é outro motor de templates popular em Python. O padrão dele é diferente: um Environment() simples não faz o escape. Ligue-o, como o Flask faz para os templates .html:

from jinja2 import Environment, select_autoescape

env = Environment(autoescape=select_autoescape(["html", "htm", "xml"]))

# Jinja's dangerous switches: the |safe filter, Markup(text) in Python,
# and {% autoescape false %} blocks.

O que o escape automático ainda não consegue fazer

  • Atributos sem aspas: <div title={{ x }}> quebra com um único espaço. Sempre escreva title="{{ x }}".
  • Endereços de links: href="{{ url }}" passa pelo escape, mas um endereço javascript: não tem nada para escapar. Confira se os links começam com https:// ou http:// antes de guardá-los ou mostrá-los.
  • Dentro de blocos <script>: use json_script ou atributos data- em vez de lacunas de template.

Um hábito para a revisão de código

Procure no seu projeto por |safe, mark_safe, autoescape off, Markup( e, no código de front-end, innerHTML e dangerouslySetInnerHTML. Cada resultado deve ter ao lado um motivo de uma linha. Se o valor puder algum dia conter texto de visitante, é um bug esperando para acontecer.

Um equívoco comum

"Nosso framework faz o escape, então não podemos ter XSS." Os frameworks fazem o escape das lacunas. Eles não conseguem proteger um valor que você marcou como seguro, um endereço que você não conferiu nem um código de front-end que usa innerHTML. O próximo módulo acrescenta uma segunda camada, a Content Security Policy, para os erros que ainda escapam.

Quer ir mais fundo? A Web Security Academy gratuita da PortSwigger tem uma trilha completa de XSS com laboratórios de prática próprios, feitos para aprender com segurança.

Em outras linguagens

Os mesmos padrões, e as mesmas chaves perigosas, em outras stacks:

// React: text in JSX is escaped for you
<p>{review.text}</p>
// the switch that turns it off (the name is a warning on purpose)
<div dangerouslySetInnerHTML={{ __html: review.text }} />

// Go: html/template escapes for the context (text, attribute, URL, script)
import "html/template"           // escapes
// import "text/template"        // does NOT escape: never use it for HTML
tmpl := template.Must(template.New("p").Parse(`<p>{{.}}</p>`))
// the switch: template.HTML(text) marks text as already safe

// PHP (Twig) auto-escapes; {{ text|raw }} turns it off
// C# (Razor) auto-escapes @text; @Html.Raw(text) turns it off

Resumo

  • O Django faz o escape de todo valor de template por padrão; o Jinja só quando você o liga.
  • As chaves perigosas: |safe, mark_safe, autoescape off, Markup, dangerouslySetInnerHTML, o template.HTML do Go.
  • Use format_html para montar HTML em Python e json_script para entregar dados ao JavaScript.
  • O escape não confere endereços de links nem conserta atributos sem aspas: coloque aspas neles e permita só links http e https.

Viu um problema nesta lição? Reporte-o · Pergunte sobre esta lição

Este exercício abre em breve

Termine a lição anterior para que esta seja desbloqueada. O curso inteiro é gratuito, não precisa de conta, e você pode ler esta lição agora mesmo.