introduccion - spring mvc conceptos

¿Cómo evito que las personas hagan XSS en Spring MVC?

Question

¿Qué debo hacer para evitar XSS en Spring MVC? En este momento, simplemente estoy colocando todos los lugares en los que publico el texto del usuario en etiquetas JSTL <c:out> o funciones fn:escapeXml() , pero esto parece propenso a errores ya que podría perder un lugar.

¿Hay una forma sistemática fácil de prevenir esto? Tal vez como un filtro o algo? Estoy recopilando información especificando los parámetros de @RequestParam en mis métodos de controlador.

Answer 1

¿Cómo está recogiendo la información del usuario en primer lugar? Esta pregunta / respuesta puede ayudar si está usando un FormController :

Spring: escapando la entrada cuando se vincula al comando

Answer 2

Cuando intenta evitar XSS, es importante pensar en el contexto. Como ejemplo, cómo y qué escaparse es muy diferente si está superando los datos dentro de una variable en un fragmento de JavaScript en lugar de generar datos en una etiqueta HTML o un atributo HTML.

Tengo un ejemplo de esto aquí: http://erlend.oftedal.no/blog/?blogid=91

También puede consultar la Hoja de referencia de prevención de XSS de OWASP: http://www.owasp.org/index.php/XSS_%28Cross_Site_Scripting%29_Prevention_Cheat_Sheet

Así que la respuesta corta es, asegúrese de escapar de la salida como lo sugiere Tendayi Mawushe, pero tenga especial cuidado cuando está sacando datos en atributos HTML o javascript.

Answer 3

En Spring puede escapar del html de las páginas JSP generadas por las etiquetas <form> . Esto cierra muchas avenidas para ataques XSS, y se puede hacer automáticamente de tres maneras:

Para toda la aplicación en el archivo web.xml :

<context-param>
<param-name>defaultHtmlEscape</param-name>
<param-value>true</param-value>
</context-param>

Para todos los formularios en una página determinada en el archivo en sí:

<spring:htmlEscape defaultHtmlEscape="true" />

Para cada formulario:

<form:input path="someFormField" htmlEscape="true" />

Answer 4

En lugar de confiar únicamente en <c:out /> , también se debe usar una biblioteca antixss, que no solo codificará sino que también desinfectará las secuencias de comandos maliciosas en la entrada. Una de las mejores bibliotecas disponibles es OWASP Antisamy , es altamente flexible y se puede configurar (utilizando archivos de políticas xml) según los requisitos.

Por ejemplo, si una aplicación solo admite el ingreso de texto, se puede utilizar el archivo de política más genérico proporcionado por OWASP que desinfecta y elimina la mayoría de las etiquetas html. Del mismo modo, si la aplicación admite editores html (como tinymce) que necesitan todo tipo de etiquetas html, se puede usar una política más flexible, como el archivo de política de eBay.

Answer 5

Prueba XSSFilter .

Answer 6

Siempre verifique manualmente los métodos, las etiquetas que usa y asegúrese de que siempre escapen (una vez) al final. Los marcos tienen muchos errores y diferencias en este aspecto.

Una descripción general: http://www.gablog.eu/online/node/91

Answer 7

Utilizo Hibernate Validator a través de @Valid para todos los objetos de entrada (binding y @RequestBody json, consulte https://dzone.com/articles/spring-31-valid-requestbody ). Así que @org.hibernate.validator.constraints.SafeHtml es una buena solución para mí.

Hibernate SafeHtmlValidator depende de org.jsoup , por lo que es necesario agregar una dependencia de proyecto más:

<dependency>
<groupId>org.jsoup</groupId>
<artifactId>jsoup</artifactId>
<version>1.10.1</version>
</dependency>

Para bean User con campo

@NotEmpty
@SafeHtml
protected String name;

para intento de actualización con valor <script>alert(123)</script> en el controlador

@PutMapping(value = "/{id}", consumes = MediaType.APPLICATION_JSON_VALUE)
public void update(@Valid @RequestBody User user, @PathVariable("id") int id)

o

@PostMapping
public void createOrUpdate(@Valid User user) {

se lanza BindException para enlace y MethodArgumentNotValidException para @RequestBody con mensaje predeterminado:

name may have unsafe html content

Validator funciona también para enlace, como antes persistiendo. Las aplicaciones se pueden probar en http://topjava.herokuapp.com/

Answer 8

**To avoid XSS security threat in spring application**

La solución al problema de XSS es filtrar todos los campos de texto en el formulario en el momento de enviar el formulario.

 It needs XML entry in the web.xml file & two simple classes.
java code :-
The code for the first class named CrossScriptingFilter.java is :
package com.filter;
import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import org.apache.log4j.Logger;
public class CrossScriptingFilter implements Filter {
private static Logger logger = Logger.getLogger(CrossScriptingFilter.class);
private FilterConfig filterConfig;
public void init(FilterConfig filterConfig) throws ServletException {
this.filterConfig = filterConfig;
}
public void destroy() {
this.filterConfig = null;
}
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
logger.info("Inlter CrossScriptingFilter ...............");
chain.doFilter(new RequestWrapper((HttpServletRequest) request), response);
logger.info("Outlter CrossScriptingFilter ...............");
}
}

El código de segunda clase llamado RequestWrapper.java es:

paquete com.filter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import org.apache.log4j.Logger;
public final class RequestWrapper extends HttpServletRequestWrapper {
private static Logger logger = Logger.getLogger(RequestWrapper.class);
public RequestWrapper(HttpServletRequest servletRequest) {
super(servletRequest);
}
public String[] getParameterValues(String parameter) {
logger.info("InarameterValues .. parameter .......");
String[] values = super.getParameterValues(parameter);
if (values == null) {
return null;
}
int count = values.length;
String[] encodedValues = new String[count];
for (int i = 0; i < count; i++) {
encodedValues[i] = cleanXSS(values[i]);
}
return encodedValues;
}
public String getParameter(String parameter) {
logger.info("Inarameter .. parameter .......");
String value = super.getParameter(parameter);
if (value == null) {
return null;
}
logger.info("Inarameter RequestWrapper ........ value .......");
return cleanXSS(value);
}
public String getHeader(String name) {
logger.info("Ineader .. parameter .......");
String value = super.getHeader(name);
if (value == null)
return null;
logger.info("Ineader RequestWrapper ........... value ....");
return cleanXSS(value);
}
private String cleanXSS(String value) {
// You''ll need to remove the spaces from the html entities below
logger.info("InnXSS RequestWrapper ..............." + value);
//value = value.replaceAll("<", "& lt;").replaceAll(">", "& gt;");
//value = value.replaceAll("//(", "& #40;").replaceAll("//)", "& #41;");
//value = value.replaceAll("''", "& #39;");
value = value.replaceAll("eval//((.*)//)", "");
value = value.replaceAll("[///"///'][//s]*javascript:(.*)[///"///']", "/"/"");
value = value.replaceAll("(?i)<script.*?>.*?<script.*?>", "");
value = value.replaceAll("(?i)<script.*?>.*?</script.*?>", "");
value = value.replaceAll("(?i)<.*?javascript:.*?>.*?</.*?>", "");
value = value.replaceAll("(?i)<.*?//s+on.*?>.*?</.*?>", "");
//value = value.replaceAll("<script>", "");
//value = value.replaceAll("</script>", "");
logger.info("OutnXSS RequestWrapper ........ value ......." + value);
return value;
}

Lo único que queda es la entrada XML en el archivo web.xml:

 <filter>
<filter-name>XSS</filter-name>
<display-name>XSS</display-name>
<description></description>
<filter-class>com.filter.CrossScriptingFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>XSS</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

El / * indica que por cada solicitud hecha desde el navegador, llamará a la clase CrossScriptingFilter. Lo cual analizará todos los componentes / elementos provenientes de la solicitud y reemplazará todas las etiquetas de javascript colocadas por el pirata informático con cadena vacía, es decir,