Come faccio a impedire alle persone di fare XSS in Spring MVC?

Question

Cosa devo fare per evitare XSS in Spring MVC? In questo momento sto solo mettendo tutti i luoghi in cui il testo utente uscita I in tag JSTL <c:out> o funzioni fn:escapeXml(), ma questo sembra soggetto a errori come potrei mancare un posto.

C'è un modo sistematico semplice per evitare questo? Forse come un filtro o qualcosa del genere? Sto raccogliendo ingresso specificando i parametri @RequestParam sui miei metodi del controller.

Answer 1

In primavera si può sfuggire alla html dalle pagine JSP generate da tag <form>. Questo chiude fuori un sacco di strade per attacchi XSS, e può essere fatto automaticamente in tre modi:

Per l'intera applicazione nel file web.xml:

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

Per tutte le forme in una determinata pagina nel file stesso:

<spring:htmlEscape defaultHtmlEscape="true" /> 

Per ciascuna forma:

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

Answer 2

XSSFilter .

Answer 3

Uso Hibernate Validator via @Valid per tutti gli oggetti di ingresso (vincolanti e @RequestBody json, consulta https : //dzone.com/articles/spring-31-valid-requestbody). Così @org.hibernate.validator.constraints.SafeHtml è una buona soluzione per me.

Sospensione SafeHtmlValidator dipende org.jsoup, quindi è necessario per aggiungere un altro dipendenze del progetto:

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

Per User di fagioli con il campo

@NotEmpty
@SafeHtml
protected String name;

per tentativo di aggiornamento con valore <script>alert(123)</script> controller

@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) {

è gettato BindException per il legame e MethodArgumentNotValidException per @RequestBody con il messaggio di default:

name may have unsafe html content

Validator funziona pure per il legame, come prima persistente. Apps potrebbero essere testati a http://topjava.herokuapp.com/

Answer 4

Quando si sta cercando di evitare XSS, è importante pensare al contesto. Per fare un esempio di come e cosa fuga è molto diversa se si sta ouputting dati all'interno di una variabile in un frammento di javascript in contrasto con l'emissione dei dati in un tag HTML o un attributo HTML.

Ho un esempio di questo qui: http://erlend.oftedal.no/blog /? blogid = 91

cassa anche il foglio OWASP XSS Prevenzione cheat: http: //www.owasp .org / index.php / XSS_% 28Cross_Site_Scripting% 29_Prevention_Cheat_Sheet

Quindi, la risposta breve è, assicuratevi di fuggire output come suggerito da Tendayi Mawushe, ma prestare particolare attenzione quando si è l'emissione dei dati in attributi HTML o JavaScript.

Answer 5

Come stai raccogliendo l'input dell'utente, in primo luogo? Questa domanda / risposta può aiutare se si sta utilizzando un FormController:

Spring: fuoriuscita ingresso quando associa comandare

Answer 6

Controllare sempre manualmente i metodi, le etichette in uso, e fare in modo che essi sempre scappano (una volta) alla fine. Frameworks hanno molti bug e le differenze in questo aspetto.

Una panoramica: http://www.gablog.eu/online/node/91

Answer 7

Invece di basarsi solo su <c:out />, una libreria AntiXSS dovrebbe anche essere usato, che non solo la codifica ma anche sterilizzare script dannoso in ingresso. Uno dei migliori libreria disponibile è Antisamy , è altamente flessibile e può essere configurato (utilizzando i file dei dati XML) secondo il requisito.

Per esempio Se un'applicazione supporta solo l'immissione di testo allora la maggior parte generica file dei criteri fornito da OWASP può essere utilizzato, che disinfetta ed elimina la maggior parte dei tag html. Allo stesso modo se montatori supporto applicazioni HTML (come tinymce) che richiedono tutti i tipi di tag html, una politica più flessibile può essere utilizzato come file nofollow politica ebay

Answer 8

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

  

soluzione al problema XSS è filtrare tutti i campi di testo nella forma   al momento della presentazione del modulo.

    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 ...............");
            }

        }

La seconda classe nome in codice RequestWrapper.java è:

pacchetto 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;
    }

  

L'unica cosa rimasta è la voce XML nel file 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>

Il / * indica che per ogni richiesta effettuata dal browser, si chiamerà     Classe CrossScriptingFilter. Che analizzare tutte le componenti / elementi venuti dalla richiesta &     sostituirà tutti i tag javascript messi da hacker con stringa vuota cioè