OWASP Java HTML Sanitizer

Un Sanitizer de HTML rápido y fácil de configurar, escrito en Java, que te permite incluir HTML creado por terceros en tu aplicación web mientras te protege contra XSS.

El JAR del sanitizer no tiene dependencias en tiempo de ejecución. Su única dependencia en tiempo de compilación es spotbugs-annotations (ámbito provided, solo anotaciones); los demás jars solo son necesarios para la suite de pruebas.

Este código fue escrito teniendo en cuenta las mejores prácticas de seguridad, cuenta con una extensa suite de pruebas y ha sido sometido a revisión de seguridad adversarial.

Primeros pasos

Primeros pasos incluye instrucciones sobre cómo empezar con o sin Maven.

Estructura del repositorio

La compilación requiere JDK 11 o superior. Desde la raíz del repositorio, compila todos los módulos de Maven y ejecuta sus pruebas con:

./mvnw clean verify

El wrapper de Maven fija la versión de Maven requerida. Si seleccionas un módulo con -pl, usa también -am para que Maven compile los módulos de los que depende.

owasp-java-html-sanitizer/ contiene la biblioteca publicada, sus pruebas y su descriptor de módulo Java.
java8-shim/ y java10-shim/ implementan código de compatibilidad que se incluye en el JAR de la biblioteca.
examples/ contiene políticas de ejemplo para leer y copiar; se prueba pero no se publica.
empiricism/ contiene los experimentos de navegador usados para generar las tablas de elementos HTML del sanitizador.
docs/ contiene documentación de usuario, de seguridad e histórica.

Políticas preempaquetadas

Puedes usar políticas preempaquetadas:

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

Creación de una política

Las pruebas muestran cómo configurar tu propia política:

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

Políticas personalizadas

Puedes escribir políticas personalizadas para hacer cosas como cambiar los h1 por div con una determinada clase:

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);

Tenga en cuenta que los elementos "a", "font", "img", "input" y "span" deben incluirse explícitamente en la lista blanca mediante el método allowWithoutAttributes() si desea que se permitan a través del filtro cuando estos elementos no incluyen ningún atributo.

Las políticas de atributos también permiten ejecutar código personalizado. Añadir una política de atributos no debilitará ninguna política predeterminada como las comprobaciones de atributos style o de 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();

Preprocesadores

Los preprocesadores permiten insertar texto y realizar cambios estructurales a gran escala.

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();

El preprocesamiento ocurre antes de que se aplique una política, por lo que no puede afectar la seguridad de la salida.

java-html-sanitizer v20260921.1