bluemonday

bluemonday é um sanitizador HTML implementado em Go. É rápido e altamente configurável.

bluemonday recebe conteúdo gerado por utilizadores não confiáveis como entrada e devolve HTML que foi sanitizado com base numa lista de permissões de elementos e atributos HTML aprovados, para que possa incluir o conteúdo com segurança na sua página web.

Se aceita conteúdo gerado por utilizadores e o seu servidor usa Go, você precisa do bluemonday.

A política padrão para conteúdo gerado por utilizadores (bluemonday.UGCPolicy().Sanitize()) transforma isto:

Hello <STYLE>.XSS{background-image:url("javascript:alert('XSS')");}</STYLE><A CLASS=XSS></A>World

Num inofensivo:

Hello World

E transforma isto:

<a href="javascript:alert('XSS1')" onmouseover="alert('XSS2')">XSS<a>

Nisto:

XSS

Enquanto ainda permite isto:

<a href="http://www.google.com/">
  <img src="https://ssl.gstatic.com/accounts/ui/logo_2x.png"/>
</a>

Passe quase inalterado (ganhou um rel="nofollow" que é algo bom para conteúdo gerado por utilizadores):

<a href="http://www.google.com/" rel="nofollow">
  <img src="https://ssl.gstatic.com/accounts/ui/logo_2x.png"/>
</a>

Protege sites de ataques XSS. Existem muitos vetores para um ataque XSS e a melhor forma de mitigar o risco é sanitizar a entrada do utilizador contra uma lista segura conhecida de elementos e atributos HTML.

Deve sempre executar o bluemonday após qualquer outro processamento.

Se utiliza blackfriday ou Pandoc, o bluemonday deve ser executado após esses passos. Isso garante que nenhum HTML inseguro seja introduzido posteriormente no seu processo.

bluemonday é fortemente inspirado tanto pelo OWASP Java HTML Sanitizer quanto pelo HTML Purifier.

Resumo Técnico

Baseado em lista de permissões, você precisa construir uma política descrevendo os elementos e atributos HTML a permitir (e os padrões regexp dos atributos), ou usar uma das políticas fornecidas que representam boas predefinições.

A política que contém a lista de permissões é aplicada usando um analisador rápido, não validante, apenas para a frente, baseado em tokens, implementado na biblioteca Go net/html pela equipa central do Go.

Esperamos receber HTML bem formatado (elementos de fecho para cada elemento de abertura aplicável, aninhamento correto) e, portanto, não nos concentramos em reparar HTML mal aninhado ou incompleto. Focamo-nos simplesmente em garantir que quaisquer elementos que existam estão descritos na lista de permissões da política e que os atributos e links são seguros para uso na sua página web. GIGO aplica-se; se fornecer HTML ruim, o bluemonday não tem a tarefa de descobrir como torná-lo bom novamente.

Está pronto para produção?

Sim

Estamos a usar bluemonday em produção após migrar do amplamente utilizado e testado OWASP Java HTML Sanitizer.

Estamos a passar no nosso extenso conjunto de testes (incluindo testes AntiSamy, bem como testes para quaisquer problemas levantados). Verifique se há problemas não resolvidos para ver se algo pode ser um bloqueador para si.

Convidamos pull requests e issues para nos ajudar a garantir que oferecemos proteção abrangente contra vários ataques através de conteúdo gerado por utilizadores.

Uso

Instale usando go get github.com/microcosm-cc/bluemonday

Depois chame:

package main

import (
	"fmt"

	"github.com/microcosm-cc/bluemonday"
)

func main() {
	// Faça isso uma vez para cada política única e use a política durante a vida do programa
	// A criação/edição de políticas não é segura para uso em múltiplas goroutines
	p := bluemonday.UGCPolicy()

	// A política pode então ser usada para sanitizar muitas entradas e é seguro usar a política em múltiplas goroutines
	html := p.Sanitize(
		`<a onblur="alert(secret)" href="http://www.google.com">Google</a>`,
	)

	// Saída:
	// <a href="http://www.google.com" rel="nofollow">Google</a>
	fmt.Println(html)
}

Oferecemos três formas de chamar Sanitize:

p.Sanitize(string) string
p.SanitizeBytes([]byte) []byte
p.SanitizeReader(io.Reader) bytes.Buffer

Se é obcecado por desempenho, p.SanitizeReader(r).Bytes() devolverá um []byte sem realizar qualquer conversão desnecessária das entradas ou saídas. Embora a diferença seja tão insignificante que nunca deverá precisar se preocupar.

Pode construir as suas próprias políticas:

package main

import (
	"fmt"

	"github.com/microcosm-cc/bluemonday"
)

func main() {
	p := bluemonday.NewPolicy()

	// Exigir que os URLs sejam analisáveis por net/url.Parse e que sejam:
	//   mailto: http:// ou https://
	p.AllowStandardURLs()

	// Só permitimos <p> e <a href="">
	p.AllowAttrs("href").OnElements("a")
	p.AllowElements("p")

	html := p.Sanitize(
		`<a onblur="alert(secret)" href="http://www.google.com">Google</a>`,
	)

	// Saída:
	// <a href="http://www.google.com">Google</a>
	fmt.Println(html)
}

Fornecemos duas políticas padrão:

1. bluemonday.StrictPolicy() que pode ser considerada equivalente a remover todos os elementos HTML e seus atributos, pois não tem nada na sua lista de permissões. Um cenário de uso exemplo seriam títulos de posts de blog onde tags HTML não são esperadas e, se estiverem, os elementos e o conteúdo dos elementos devem ser removidos. Esta é uma política muito rigorosa.
2. bluemonday.UGCPolicy() que permite uma ampla seleção de elementos e atributos HTML que são seguros para conteúdo gerado por utilizadores. Note que esta política não permite iframes, object, embed, styles, script, etc. Um cenário de uso exemplo seriam corpos de posts de blog onde é esperada uma variedade de formatação, juntamente com a possibilidade de TABLEs e IMGs.

Construção de Políticas

A essência da construção de uma política é determinar quais elementos e atributos HTML são considerados seguros para o seu cenário. A OWASP fornece uma folha de dicas de prevenção de XSS para ajudar a explicar os riscos, mas essencialmente:

1. Evite qualquer coisa além dos elementos HTML padrão
2. Evite elementos script, style, iframe, object, embed, base que permitem a execução de código pelo cliente ou a inclusão de conteúdo de terceiros que pode executar código
3. Evite qualquer coisa além de atributos HTML simples com valores correspondentes a uma regexp

Basicamente, deve ser capaz de descrever qual HTML é adequado para o seu cenário. Se não tem confiança de que pode descrever a sua política, considere usar uma das políticas fornecidas, como bluemonday.UGCPolicy().

Para criar uma nova política:

p := bluemonday.NewPolicy()

Para adicionar elementos a uma política, adicione apenas os elementos:

p.AllowElements("b", "strong")

Ou usando uma regex:

Nota: se um elemento for adicionado pelo nome como mostrado acima, qualquer regex correspondente será ignorada

Também é recomendado garantir que múltiplos padrões não se sobreponham, pois a ordem de execução não é garantida e pode resultar em algumas regras serem ignoradas.

p.AllowElementsMatching(regex.MustCompile(`^my-element-`))