OWASP Java HTML Sanitizer

Un HTML Sanitizer veloce e facile da configurare, scritto in Java, che ti consente di includere HTML creato da terze parti nella tua applicazione web proteggendoti da XSS.

Il JAR del sanitizer non ha dipendenze a runtime. La sua unica dipendenza a tempo di compilazione è spotbugs-annotations (scope provided, solo annotazioni); gli altri jar sono necessari solo alla suite di test.

Questo codice è stato scritto tenendo presenti le migliori pratiche di sicurezza, dispone di un'ampia suite di test ed è stato sottoposto a revisione di sicurezza avversariale.

Per iniziare

Per iniziare include istruzioni su come iniziare con o senza Maven.

Struttura del repository

La compilazione richiede JDK 11 o superiore. Dalla radice del repository, compila tutti i moduli Maven ed esegui i loro test con:

./mvnw clean verify

Il wrapper Maven fissa la versione Maven richiesta. Se selezioni un modulo con -pl, usa anche -am in modo che Maven compili i moduli da cui dipende.

owasp-java-html-sanitizer/ contiene la libreria pubblicata, i suoi test e il suo descrittore di modulo Java.
java8-shim/ e java10-shim/ implementano codice di compatibilità che viene incluso nel JAR della libreria.
examples/ contiene policy di esempio da leggere e copiare; è testato ma non pubblicato.
empiricism/ contiene gli esperimenti nel browser usati per generare le tabelle degli elementi HTML del sanitizer.
docs/ contiene la documentazione utente, di sicurezza e storica.

Policy precompilate

Puoi usare policy precompilate:

PolicyFactory policy = Sanitizers.FORMATTING.and(Sanitizers.LINKS);
String safeHTML = policy.sanitize(untrustedHTML);

Creare una policy

I test mostrano come configurare una tua policy:

PolicyFactory policy = new HtmlPolicyBuilder()
    .allowElements("a")
    .allowUrlProtocols("https")
    .allowAttributes("href").onElements("a")
    .requireRelNofollowOnLinks()
    .toFactory();
String safeHTML = policy.sanitize(untrustedHTML);

Policy personalizzate

Puoi scrivere policy personalizzate per fare cose come trasformare gli h1 in div con una determinata classe:

PolicyFactory policy = new HtmlPolicyBuilder()
    .allowElements("p")
    .allowElements(
        (String elementName, List<String> attrs) -> {
          // Add a class attribute.
          attrs.add("class");
          attrs.add("header-" + elementName);
          // Return elementName to include, null to drop.
          return "div";
        }, "h1", "h2", "h3", "h4", "h5", "h6")
    .toFactory();
String safeHTML = policy.sanitize(untrustedHTML);

Tieni presente che gli elementi "a", "font", "img", "input" e "span" devono essere esplicitamente inseriti nella whitelist utilizzando il metodo allowWithoutAttributes() se vuoi che siano consentiti dal filtro quando questi elementi non includono alcun attributo.

Le policy sugli attributi consentono anche l'esecuzione di codice personalizzato. L'aggiunta di una policy sugli attributi non indebolisce alcuna policy predefinita come i controlli sugli attributi style o sugli URL.

PolicyFactory myPolicy = new HtmlPolicyBuilder()
    .allowElements("div", "span")
    .allowAttributes("data-foo")
        .matching(
            (String elementName, String attributeName, String value) -> {
              // Return value for the attribute or null to drop.
              return value;
            })
        .onElements("div", "span")
    .toFactory();

Preprocessori

I preprocessori consentono di inserire testo e di apportare modifiche strutturali su larga scala.

PolicyFactory myPolicy = new HtmlPolicyBuilder()
    .withPreprocessor(
        (HtmlStreamEventReceiver r) -> {
          // Provide user with info about links before they click.
          // Before:                       <a href="https://example.com/...">
          // After:  (https://example.com) <a href="https://example.com/...">
          return new HtmlStreamEventReceiverWrapper(r) {
            @Override public void openTag(String elementName, List<String> attrs) {
              if ("a".equals(elementName)) {
                for (int i = 0, n = attrs.size(); i < n; i += 2) {
                  if ("href".equals(attrs.get(i))) {
                    String url = attrs.get(i + 1);
                    String origin;
                    try {
                      URI uri = new URI(url);
                      String scheme = uri.getScheme();
                      String authority = uri.getRawAuthority();
                      if (scheme == null && authority == null) {
                        origin = null;
                      } else {
                        origin = (scheme != null ? scheme + ":" : "")
                               + (authority != null ? "//" + authority : "");
                      }
                    } catch (URISyntaxException ex) {
                      origin = "about:invalid";
                    }
                    if (origin != null) {
                      text(" (" + origin + ") ");
                    }
                  }
                }
              }
              super.openTag(elementName, attrs);
            }
          };
        })
     .allowElements("a")
     .allowAttributes("href").onElements("a")
     .allowStandardUrlProtocols()
    ...
    .toFactory();

La pre-elaborazione avviene prima che venga applicata una policy, quindi non può influire sulla sicurezza dell'output.

java-html-sanitizer v20260921.1