Méthode recommandée pour échapper au HTML en Java

Est - il un moyen recommandé pour échapper <, >, "et &caractères lors de la génération HTML dans le code Java simple? (À part faire manuellement ce qui suit, c'est-à-dire).

String source = "The less than sign (<) and ampersand (&) must be escaped before using them in HTML";
String escaped = source.replace("<", "&lt;").replace("&", "&amp;"); // ...

StringEscapeUtils d' Apache Commons Lang :

import static org.apache.commons.lang.StringEscapeUtils.escapeHtml;
// ...
String source = "The less than sign (<) and ampersand (&) must be escaped before using them in HTML";
String escaped = escapeHtml(source);

Pour la version 3 :

import static org.apache.commons.lang3.StringEscapeUtils.escapeHtml4;
// ...
String escaped = escapeHtml4(source);

Une alternative à Apache Commons: utilisez la méthode SpringHtmlUtils.htmlEscape(String input) .

Belle méthode courte:

public static String escapeHTML(String s) {
    StringBuilder out = new StringBuilder(Math.max(16, s.length()));
    for (int i = 0; i < s.length(); i++) {
        char c = s.charAt(i);
        if (c > 127 || c == '"' || c == '\'' || c == '<' || c == '>' || c == '&') {
            out.append("&#");
            out.append((int) c);
            out.append(';');
        } else {
            out.append(c);
        }
    }
    return out.toString();
}

Basé sur https://stackoverflow.com/a/8838023/1199155 (l'ampli y manque). Les quatre caractères cochés dans la clause if sont les seuls en dessous de 128, selon http://www.w3.org/TR/html4/sgml/entities.html

Il existe une version plus récente de la bibliothèque Apache Commons Lang et elle utilise un nom de package différent (org.apache.commons.lang3). Le StringEscapeUtilspossède maintenant différentes méthodes statiques pour échapper à différents types de documents ( http://commons.apache.org/proper/commons-lang/javadocs/api-3.0/index.html ). Donc, pour échapper à la chaîne HTML version 4.0:

import static org.apache.commons.lang3.StringEscapeUtils.escapeHtml4;

String output = escapeHtml4("The less than sign (<) and ampersand (&) must be escaped before using them in HTML");

Pour ceux qui utilisent Google Guava:

import com.google.common.html.HtmlEscapers;
[...]
String source = "The less than sign (<) and ampersand (&) must be escaped before using them in HTML";
String escaped = HtmlEscapers.htmlEscaper().escape(source);

Sur Android (API 16 ou supérieure), vous pouvez:

Html.escapeHtml(textToScape);

ou pour une API inférieure:

TextUtils.htmlEncode(textToScape);

Soyez prudent avec cela. Il existe un certain nombre de «contextes» différents dans un document HTML: à l'intérieur d'un élément, valeur d'attribut citée, valeur d'attribut non cotée, attribut URL, javascript, CSS, etc ... Vous devrez utiliser une méthode de codage différente pour chacun des ceux-ci pour empêcher le Cross-Site Scripting (XSS). Consultez la feuille de triche de prévention OWASP XSS pour plus de détails sur chacun de ces contextes. Vous pouvez trouver des méthodes d'échappement pour chacun de ces contextes dans la bibliothèque OWASP ESAPI - https://github.com/ESAPI/esapi-java-legacy .

À certaines fins, HtmlUtils :

import org.springframework.web.util.HtmlUtils;
[...]
HtmlUtils.htmlEscapeDecimal("&"); //gives &
HtmlUtils.htmlEscape("&"); //gives &

Bien que la réponse @dfa de org.apache.commons.lang.StringEscapeUtils.escapeHtmlsoit agréable et que je l'ai utilisée dans le passé, elle ne devrait pas être utilisée pour échapper les attributs HTML (ou XML) sinon le blanc sera normalisé (ce qui signifie que tous les caractères adjacents deviennent un seul espace).

Je le sais parce que des bogues ont été déposés contre ma bibliothèque (JATL) pour les attributs où les espaces blancs n'étaient pas préservés. J'ai donc une classe drop (copy n 'paste) (dont j'en ai volé une partie de JDOM) qui différencie l'échappement des attributs et du contenu des éléments .

Bien que cela n'ait peut-être pas eu autant d'importance dans le passé (échappement correct des attributs), cela devient de plus en plus intéressant compte tenu de l'utilisation de l'utilisation des data-attributs HTML5 .

org.apache.commons.lang3.StringEscapeUtils est désormais obsolète. Vous devez maintenant utiliser org.apache.commons.text.StringEscapeUtils par

    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-text</artifactId>
        <version>${commons.text.version}</version>
    </dependency>

La plupart des bibliothèques proposent d'échapper à tout ce qu'elles peuvent, y compris des centaines de symboles et des milliers de caractères non ASCII, ce qui n'est pas ce que vous voulez dans le monde UTF-8.

De plus, comme l'a noté Jeff Williams, il n'y a pas une seule option «d'échappement HTML», il existe plusieurs contextes.

En supposant que vous n'utilisez jamais d'attributs non cités et en gardant à l'esprit que différents contextes existent, il a écrit ma propre version:

private static final long BODY_ESCAPE =
        1L << '&' | 1L << '<' | 1L << '>';
private static final long DOUBLE_QUOTED_ATTR_ESCAPE =
        1L << '"' | 1L << '&' | 1L << '<' | 1L << '>';
private static final long SINGLE_QUOTED_ATTR_ESCAPE =
        1L << '"' | 1L << '&' | 1L << '\'' | 1L << '<' | 1L << '>';

// 'quot' and 'apos' are 1 char longer than '#34' and '#39' which I've decided to use
private static final String REPLACEMENTS = "&#34;&amp;&#39;&lt;&gt;";
private static final int REPL_SLICES = /*  |0,   5,   10,  15, 19, 23*/
        5<<5 | 10<<10 | 15<<15 | 19<<20 | 23<<25;
// These 5-bit numbers packed into a single int
// are indices within REPLACEMENTS which is a 'flat' String[]

private static void appendEscaped(
        StringBuilder builder,
        CharSequence content,
        long escapes // pass BODY_ESCAPE or *_QUOTED_ATTR_ESCAPE here
) {
    int startIdx = 0, len = content.length();
    for (int i = 0; i < len; i++) {
        char c = content.charAt(i);
        long one;
        if (((c & 63) == c) && ((one = 1L << c) & escapes) != 0) {
        // -^^^^^^^^^^^^^^^   -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
        // |                  | take only dangerous characters
        // | java shifts longs by 6 least significant bits,
        // | e. g. << 0b110111111 is same as >> 0b111111.
        // | Filter out bigger characters

            int index = Long.bitCount(SINGLE_QUOTED_ATTR_ESCAPE & (one - 1));
            builder.append(content, startIdx, i /* exclusive */)
                    .append(REPLACEMENTS,
                            REPL_SLICES >>> 5*index & 31,
                            REPL_SLICES >>> 5*(index+1) & 31);
            startIdx = i + 1;
        }
    }
    builder.append(content, startIdx, len);
}

Envisagez de copier-coller à partir de Gist sans limite de longueur de ligne .