Skip to content
KitploitKITPLOIT
OutilsBlog
Soumettre
OutilsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

··Flux·Contact·Confidentialité·© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
bluemonday — bluemonday : un assainisseur HTML rapide en golang (inspiré de l'OWASP Java HTML Sanitizer) pour nettoyer le contenu généré par les utilisateurs des XSS | Kitploit
Outils/GitHubGitHub/microcosm-cc/bluemonday
Outils DéfensifsAnalyse StatiqueAnalyse des VulnérabilitésAnalyse de CodeSécurité WebSécurité des API
GitHubmicrocosm-cc/bluemonday

bluemonday

bluemonday : un assainisseur HTML rapide en golang (inspiré de l'OWASP Java HTML Sanitizer) pour nettoyer le contenu généré par les utilisateurs des XSS

Voir le dépôt
3.7k1955il y a 1 anVérifié par Kitploit

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →
Partager

bluemonday GoDoc Sourcegraph

bluemonday est un assainisseur HTML implémenté en Go. Il est rapide et hautement configurable.

bluemonday prend en entrée du contenu généré par l'utilisateur non fiable et renvoie du HTML qui a été assaini en fonction d'une liste blanche d'éléments et d'attributs HTML approuvés, afin que vous puissiez inclure ce contenu en toute sécurité dans votre page web.

Si vous acceptez du contenu généré par l'utilisateur et que votre serveur utilise Go, vous avez besoin de bluemonday.

La politique par défaut pour le contenu généré par l'utilisateur (bluemonday.UGCPolicy().Sanitize()) transforme ceci :

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

En un inoffensif :

root@kitploit:~
Hello World

Et transforme ceci :

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

En ceci :

root@kitploit:~
XSS

Tout en permettant toujours ceci :

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

À passer presque inchangé (il a gagné un rel="nofollow", ce qui est une bonne chose pour le contenu généré par l'utilisateur) :

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

Il protège les sites contre les attaques XSS. Il existe de nombreux vecteurs d'attaque XSS et la meilleure façon d'atténuer le risque est d'assainir les entrées utilisateur par rapport à une liste connue et sûre d'éléments et d'attributs HTML.

Vous devez toujours exécuter bluemonday après tout autre traitement.

Si vous utilisez blackfriday ou Pandoc, bluemonday doit être exécuté après ces étapes. Cela garantit qu'aucun HTML non sécurisé n'est introduit plus tard dans votre processus.

bluemonday est fortement inspiré à la fois du OWASP Java HTML Sanitizer et du HTML Purifier.

Résumé technique

Basé sur une liste blanche, vous devez soit construire une politique décrivant les éléments et attributs HTML à autoriser (et les motifs regexp des attributs), soit utiliser l'une des politiques fournies qui représentent de bons réglages par défaut.

La politique contenant la liste blanche est appliquée à l'aide d'un analyseur rapide, non validant, en avant uniquement, basé sur des jetons, implémenté dans la bibliothèque Go net/html par l'équipe centrale de Go.

Nous nous attendons à recevoir du HTML bien formaté (éléments fermants pour chaque élément ouvrant applicable, imbrication correcte) et nous ne nous concentrons donc pas sur la réparation d'un HTML mal imbriqué ou incomplet. Nous nous concentrons simplement sur le fait que tous les éléments qui existent sont décrits dans la liste blanche de la politique et que les attributs et les liens sont sûrs pour une utilisation sur votre page web. GIGO s'applique ; si vous lui fournissez du mauvais HTML, bluemonday n'a pas pour mission de trouver comment le rendre à nouveau correct.

Est-ce prêt pour la production ?

Oui

Nous utilisons bluemonday en production après avoir migré depuis le OWASP Java HTML Sanitizer, largement utilisé et testé sur le terrain.

Nous passons notre vaste suite de tests (y compris les tests AntiSamy ainsi que des tests pour tout problème soulevé). Vérifiez s'il y a des problèmes non résolus pour voir si quelque chose peut vous bloquer.

Nous invitons les pull requests et les signalements de problèmes pour nous aider à garantir une protection complète contre diverses attaques via du contenu généré par l'utilisateur.

Utilisation

Installez avec go get github.com/microcosm-cc/bluemonday

Puis appelez-le :

root@kitploit:~
package main

import (
	"fmt"

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

func main() {
	// Faites cela une fois pour chaque politique unique et utilisez la politique pour la durée de vie du programme
	// La création/édition de politique n'est pas sûre à utiliser dans plusieurs goroutines
	p := bluemonday.UGCPolicy()

	// La politique peut ensuite être utilisée pour assainir beaucoup d'entrées et il est sûr d'utiliser la politique dans plusieurs goroutines
	html := p.Sanitize(
		`<a onblur="alert(secret)" href="http://www.google.com">Google</a>`,
	)

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

Nous offrons trois façons d'appeler Sanitize :

root@kitploit:~
p.Sanitize(string) string
p.SanitizeBytes([]byte) []byte
p.SanitizeReader(io.Reader) bytes.Buffer

Si vous êtes obsédé par les performances, p.SanitizeReader(r).Bytes() renverra un []byte sans effectuer de conversion inutile des entrées ou sorties. Bien que la différence soit si négligeable que vous ne devriez jamais avoir à vous en soucier.

Vous pouvez construire vos propres politiques :

root@kitploit:~
package main

import (
	"fmt"

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

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

	// Exiger que les URL soient analysables par net/url.Parse et soient soit :
	//   mailto: http:// ou https://
	p.AllowStandardURLs()

	// Nous n'autorisons que <p> et <a href="">
	p.AllowAttrs("href").OnElements("a")
	p.AllowElements("p")

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

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

Nous fournissons deux politiques par défaut :

  1. bluemonday.StrictPolicy() qui peut être considérée comme équivalente à la suppression de tous les éléments HTML et de leurs attributs car elle n'a rien dans sa liste blanche. Un exemple d'utilisation serait les titres de billets de blog où les balises HTML ne sont pas du tout attendues et si elles le sont, les éléments et le contenu des éléments doivent être supprimés. C'est une politique très stricte.
  2. bluemonday.UGCPolicy() qui autorise une large sélection d'éléments et d'attributs HTML sûrs pour le contenu généré par l'utilisateur. Notez que cette politique n'autorise pas les iframes, object, embed, styles, script, etc. Un exemple d'utilisation serait le corps de billets de blog où une variété de formatage est attendue ainsi que la possibilité de TABLEs et IMGs.

Construction de politique

L'essence de la construction d'une politique est de déterminer quels éléments et attributs HTML sont considérés comme sûrs pour votre scénario. OWASP fournit une antisèche de prévention XSS pour aider à expliquer les risques, mais essentiellement :

  1. Évitez tout ce qui n'est pas des éléments HTML standard
  2. Évitez les éléments script, style, iframe, object, embed, base qui permettent l'exécution de code par le client ou l'inclusion de contenu tiers pouvant exécuter du code
  3. Évitez tout ce qui n'est pas des attributs HTML simples avec des valeurs correspondant à une regexp

En gros, vous devez être capable de décrire quel HTML est acceptable pour votre scénario. Si vous n'êtes pas sûr de pouvoir décrire votre politique, envisagez d'utiliser l'une des politiques fournies comme bluemonday.UGCPolicy().

Pour créer une nouvelle politique :

root@kitploit:~
p := bluemonday.NewPolicy()

Pour ajouter des éléments à une politique, soit ajoutez simplement les éléments :

root@kitploit:~
p.AllowElements("b", "strong")

Soit en utilisant une regex :

Remarque : si un élément est ajouté par son nom comme ci-dessus, toute regex correspondante sera ignorée

Il est également recommandé de s'assurer que plusieurs motifs ne se chevauchent pas, car l'ordre d'exécution n'est pas garanti et peut entraîner l'omission de certaines règles.

root@kitploit:~
p.AllowElementsMatching(regex.MustCompile(`^my-element-`))

Ou ajoutez des éléments en vertu de l'ajout d'un attribut :

root@kitploit:~
// Notez le motif recommandé, voir la recommandation sur l'utilisation de .Matching() ci-dessous
p.AllowAttrs("nowrap").OnElements("td", "th")

Encore une fois, cela supporte également une alternative de correspondance par motif regex :

root@kitploit:~
p.AllowAttrs("nowrap").OnElementsMatching(regex.MustCompile(`^my-element-`))

Les attributs peuvent être ajoutés à tous les éléments :

root@kitploit:~
p.AllowAttrs("dir").Matching(regexp.MustCompile("(?i)rtl|ltr")).Globally()

Ou les attributs peuvent être ajoutés à des éléments spécifiques :

root@kitploit:~
// Pas le motif recommandé, voir la recommandation sur l'utilisation de .Matching() ci-dessous
p.AllowAttrs("value").OnElements("li")

Il est toujours recommandé qu'un attribut corresponde à un motif. Les XSS dans les attributs HTML sont très faciles autrement :

root@kitploit:~
// \p{L} correspond aux lettres unicode, \p{N} correspond aux nombres unicode
p.AllowAttrs("title").Matching(regexp.MustCompile(`[\p{L}\p{N}\s\-_',:\[\]!\./\\\(\)&]*`)).Globally()

Vous pouvez vous arrêter à tout moment et appeler .Sanitize() :

root@kitploit:~
// string htmlIn passé depuis un HTTP POST
htmlOut := p.Sanitize(htmlIn)

Et vous pouvez prendre n'importe quelle politique existante et l'étendre :

root@kitploit:~
p := bluemonday.UGCPolicy()
p.AllowElements("fieldset", "select", "option")

CSS en ligne

Bien qu'il soit possible de gérer le CSS en ligne en utilisant AllowAttrs avec une règle Matching, écrire une seule expression régulière monolithique pour traiter en toute sécurité tout le CSS en ligne que vous souhaitez autoriser n'est pas une tâche triviale. Au lieu d'essayer de le faire, vous pouvez autoriser l'attribut style sur le ou les éléments que vous désirez et utiliser des politiques de style pour contrôler et assainir les styles en ligne.

Il est fortement recommandé d'utiliser Matching (avec une expression régulière appropriée), MatchingEnum ou MatchingHandler pour vous assurer que chaque style correspond à vos besoins, mais des gestionnaires par défaut sont fournis pour la plupart des styles largement utilisés.

Semblable aux attributs, vous pouvez autoriser des propriétés CSS spécifiques à être définies en ligne :

root@kitploit:~
p.AllowAttrs("style").OnElements("span", "p")
// Autoriser la propriété 'color' avec des valeurs hexadécimales RVB(A) valides uniquement (sur tout élément autorisé avec un attribut 'style')
p.AllowStyles("color").Matching(regexp.MustCompile("(?i)^#([0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$")).Globally()

De plus, vous pouvez autoriser une propriété CSS à être définie uniquement à une valeur autorisée :

root@kitploit:~
p.AllowAttrs("style").OnElements("span", "p")
// Autoriser la propriété 'text-decoration' à être définie comme 'underline', 'line-through' ou 'none'
// uniquement sur les éléments 'span'
p.AllowStyles("text-decoration").MatchingEnum("underline", "line-through", "none").OnElements("span")

Ou vous pouvez spécifier des éléments basés sur une correspondance de motif regex :

root@kitploit:~
p.AllowAttrs("style").OnElementsMatching(regex.MustCompile(`^my-element-`))
// Autoriser la propriété 'text-decoration' à être définie comme 'underline', 'line-through' ou 'none'
// uniquement sur les éléments 'span'
p.AllowStyles("text-decoration").MatchingEnum("underline", "line-through", "none").OnElementsMatching(regex.MustCompile(`^my-element-`))

Si vous avez besoin d'une vérification plus spécifique, vous pouvez créer un gestionnaire qui prend une chaîne et renvoie un booléen pour valider les valeurs d'une propriété donnée. Le paramètre de chaîne a été converti en minuscules et les points de code Unicode ont été convertis.

root@kitploit:~
myHandler := func(value string) bool{
	// Validez votre entrée ici
	return true
}
p.AllowAttrs("style").OnElements("span", "p")
// Autoriser la propriété 'color' avec des valeurs validées par le gestionnaire (sur tout élément autorisé avec un attribut 'style')
p.AllowStyles("color").MatchingHandler(myHandler).Globally()

Liens

Les liens sont des bêtes difficiles à assainir en toute sécurité et aussi l'un des plus grands vecteurs d'attaque pour le contenu malveillant.

Il est possible de faire ceci :

root@kitploit:~
p.AllowAttrs("href").Matching(regexp.MustCompile(`(?i)mailto|https?`)).OnElements("a")

Mais cela ne vous protégera pas car l'expression régulière est insuffisante dans ce cas pour avoir empêché une valeur malformée de faire quelque chose d'inattendu.

Nous fournissons quelques options globales supplémentaires pour travailler en toute sécurité avec les liens.

RequireParseableURLs garantira que les URL sont analysables par le paquet net/url de Go :

root@kitploit:~
p.RequireParseableURLs(true)

Si vous avez activé les URL analysables, alors l'option suivante permettra AllowRelativeURLs. Par défaut, cela est désactivé (bluemonday est un outil de liste blanche... vous devez explicitement nous dire d'autoriser des choses) et lorsqu'il est désactivé, il empêchera toutes les URL relatives locales et relatives au schéma (c'est-à-dire href="localpage.html", href="../home.html" et même href="//www.google.com" sont relatives) :

root@kitploit:~
p.AllowRelativeURLs(true)

Si vous avez activé les URL analysables, vous pouvez alors autoriser les schémas (communément appelés protocoles en pensant à http et https) qui sont autorisés. Gardez à l'esprit que l'autorisation des URL relatives dans l'option ci-dessus permettra un schéma vide :

root@kitploit:~
p.AllowURLSchemes("mailto", "http", "https")

Que vous ayez activé ou non les URL analysables, vous pouvez forcer toutes les URL à avoir un attribut rel="nofollow". Cela sera ajouté s'il n'existe pas, mais seulement lorsque le href est valide :

root@kitploit:~
// Cela s'applique aux éléments "a" "area" "link" qui ont un attribut "href"
p.RequireNoFollowOnLinks(true)

De même, vous pouvez forcer toutes les URL à avoir "noreferrer" dans leur attribut rel.

root@kitploit:~
// Cela s'applique aux éléments "a" "area" "link" qui ont un attribut "href"
p.RequireNoReferrerOnLinks(true)

Nous fournissons une méthode de commodité qui applique tout ce qui précède, mais vous devrez toujours autoriser les éléments liables pour que les règles d'URL leur soient appliquées :

root@kitploit:~
p.AllowStandardURLs()
p.AllowAttrs("cite").OnElements("blockquote", "q")
p.AllowAttrs("href").OnElements("a", "area")
p.AllowAttrs("src").OnElements("img")

Une complexité supplémentaire concernant les liens est l'URI de données telle que définie dans RFC2397. L'URI de données permet aux images d'être servies en ligne en utilisant ce format :

root@kitploit:~
<img src="data:image/webp;base64,UklGRh4AAABXRUJQVlA4TBEAAAAvAAAAAAfQ//73v/+BiOh/AAA=">

Nous avons fourni un assistant pour vérifier le type MIME suivi du contenu en base64 des liens d'URI de données :

root@kitploit:~
p.AllowDataURIImages()

Cet assistant activera les images GIF, JPEG, PNG et WEBP.

Il convient de noter qu'il existe un risque de sécurité potentiel avec l'utilisation de liens d'URI de données. Vous ne devez activer les liens d'URI de données que si vous faites déjà confiance au contenu.

Nous avons également quelques fonctionnalités pour aider à traiter le contenu généré par l'utilisateur :

root@kitploit:~
p.AddTargetBlankToFullyQualifiedLinks(true)

Cela garantira que les liens d'ancrage <a href="" /> qui sont complètement qualifiés (la destination href inclut un nom d'hôte) recevront target="_blank" ajouté.

De plus, tout lien qui a target="_blank" après l'application de la politique verra également l'attribut rel ajusté pour ajouter noopener. Cela signifie qu'un lien peut commencer par <a href="//host/path"/> et finira par <a href="//host/path" rel="noopener" target="_blank">. Il est important de noter que l'ajout de noopener est une fonctionnalité de sécurité et non un problème. Il existe une fonctionnalité malheureuse des navigateurs selon laquelle une fenêtre de navigateur ouverte suite à target="_blank" peut toujours contrôler l'ouvreur (votre page web) et cela protège contre cela. Le contexte de cela peut être trouvé ici : https://dev.to/ben/the-targetblank-vulnerability-by-example

Aides à la construction de politique

Nous fournissons également quelques assistants pour simplifier la construction de politique :

root@kitploit:~

// Permet les attributs "dir", "id", "lang", "title" globalement
p.AllowStandardAttributes()

// Permet l'élément "img" et ses attributs standard
p.AllowImages()

// Permet les listes ordonnées et non ordonnées, ainsi que les listes de définitions
p.AllowLists()

// Permet les tableaux HTML et tous les éléments applicables et attributs non stylistiques
p.AllowTables()

Instructions invalides

Les éléments suivants sont invalides :

root@kitploit:~
// Cela ne dit pas où les attributs sont autorisés, vous devez ajouter
// .Globally() ou .OnElements(...)
// Cela sera ignoré sans erreur.
p.AllowAttrs("value")

// Cela ne dit pas où les attributs sont autorisés, vous devez ajouter
// .Globally() ou .OnElements(...)
// Cela sera ignoré sans erreur.
p.AllowAttrs(
	"type",
).Matching(
	regexp.MustCompile("(?i)^(circle|disc|square|a|A|i|I|1)$"),
)

Les deux exemples présentent le même problème : ils déclarent des attributs mais ne spécifient pas s'ils sont autorisés globalement ou seulement sur des éléments spécifiques (et quels éléments). Les attributs appartiennent à un ou plusieurs éléments, et la politique doit le déclarer.

Limitations

Nous n'incluons pas encore d'outils pour aider à autoriser et assainir le CSS. Ce qui signifie qu'à moins que vous ne souhaitiez faire le gros du travail dans une seule expression régulière (déconseillé), vous ne devez pas autoriser l'attribut "style" nulle part.

Dans le même thème, <script> et <style> sont considérés comme nuisibles. Ces éléments (et leur contenu) ne seront pas rendus par défaut et nécessitent que vous définissiez explicitement p.AllowUnsafe(true). Vous devez être conscient que l'autorisation de ces éléments va à l'encontre du but d'utiliser un assainisseur HTML, car vous autoriseriez explicitement soit JavaScript (et tout XSS écrit en clair) soit CSS (qui peut modifier un DOM pour insérer du JS), et de plus, les limitations de cette bibliothèque font qu'elle n'est pas consciente de la validité structurelle du HTML, ce qui peut permettre à ces éléments de contourner certains des mécanismes de sécurité intégrés dans le standard d'analyseur HTML WhatWG.

Ce n'est pas le travail de bluemonday de réparer votre mauvais HTML, c'est simplement le travail de bluemonday d'empêcher le HTML malveillant de passer. Si vous avez des éléments HTML mal appairés ou une imbrication non conforme, ceux-ci resteront. Mais si vous avez un HTML bien structuré, bluemonday ne le cassera pas.

À FAIRE

  • Étudier si les développeurs souhaitent mettre sur liste noire des éléments et attributs. Cela permettrait aux développeurs de prendre une politique existante (comme bluemonday.UGCPolicy()) qui encapsule 90 % de ce qu'ils recherchent mais en fait plus que nécessaire, et de supprimer les éléments supplémentaires qu'ils ne souhaitent pas pour la rendre à 100 % conforme à leurs besoins.
  • Étudier si les développeurs souhaitent un mode HTML de validation, dans lequel les éléments HTML sont non seulement transformés en un arbre équilibré (chaque balise de début a une balise de fin à la profondeur correcte) mais aussi que les éléments et les données de caractères n'apparaissent que dans leur contexte autorisé (c'est-à-dire qu'un élément table ne soit pas un descendant d'un caption, que colgroup, thead, tbody, tfoot et tr soient autorisés, et que les données de caractères ne soient pas autorisées).

Objectifs à long terme

  1. Ouvrir le code à une revue par les pairs contradictoire similaire aux Règles de base pour la revue d'attaque
  2. Lever des fonds et payer pour une revue de sécurité externe
Télécharger l’outil