OWASP Java HTML Sanitizer

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

La dependencia existente es de JSR 305. Los otros archivos JAR solo son necesarios para el conjunto de pruebas. La dependencia de JSR 305 es una dependencia solo de compilación, necesaria únicamente para anotaciones.

Este código fue escrito teniendo en cuenta las mejores prácticas de seguridad, cuenta con un amplio conjunto de pruebas y ha pasado por una revisión de seguridad adversarial.

Primeros pasos

Getting Started incluye instrucciones sobre cómo empezar con o sin Maven.

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 h1s por divs con una clase específica:

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

Ten en cuenta que los elementos "a", "font", "img", "input" y "span" deben ser explícitamente incluidos en la lista blanca usando el método allowWithoutAttributes() si deseas que se permitan pasar a través del filtro cuando estos elementos no incluyan atributos.

Las políticas de atributos también permiten ejecutar código personalizado. Agregar una política de atributos no debilitará ninguna política predeterminada, como las comprobaciones de atributos style o URL.

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

Preprocesadores

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

new HtmlPolicyBuilder = new HtmlPolicyBuilder()
    // Use a preprocessor to be backwards compatible with the
    // <plaintext> element which 
    .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);
            }
          };
        }
    .allowElement("a")
    ...
    .build()

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

Telemetría

Cuando una política rechaza un elemento o atributo, notifica a un HtmlChangeListener.

Puedes usar esto para realizar un seguimiento de las tendencias de violaciones de políticas y detectar cuándo alguien está haciendo un esfuerzo para vulnerar tu seguridad.

PolicyFactory myPolicyFactory = ...;
// If you need to associate reports with some context, you can do so.
MyContextClass myContext = ...;

String sanitizedHtml = myPolicyFactory.sanitize(
    unsanitizedHtml,
    new HtmlChangeListener<MyContextClass>() {
      @Override
      public void discardedTag(MyContextClass context, String elementName) {
        // ...
      }
      @Override
      public void discardedAttributes(
          MyContextClass context, String elementName, String... attributeNames) {
        // ...
      }
    },
    myContext);

Nota: Si una cadena se sanitiza sin notificaciones de cambio, no es necesariamente seguro usar la cadena de entrada. Solo utiliza la salida del sanitizador.

java-html-sanitizer v20260921.1