XSS prévention en JSP/Servlet application web

XSS peut être évité en JSP en utilisant JSTL <c:out> tag ou fn:escapeXml() EL de la fonction lors de la (re)affichage contrôlée par l'utilisateur d'entrée. Cela inclut les paramètres de la demande, en-têtes, les cookies, URL, corps, etc. Tout ce qui vous extraire de l'objet de requête. Aussi l'utilisateur à l'entrée contrôlée à partir de la précédente demande qui est stockée dans une base de données doit être échappés lors de l'affichage.

Par exemple:

<p><c:out value="${bean.userControlledValue}"></p>
<p><input name="foo" value="${fn:escapeXml(param.foo)}"></p>

Cela permettra d'échapper les caractères qui peuvent malform le rendu HTML comme <, >, ", ' et & en HTML/XML entités comme <, >, ", ' et &.

Notez que vous n'avez pas besoin d'échapper à la Java (Servlet) du code, puisqu'ils sont inoffensifs, là-bas. Certains peuvent opter pour leur échapper pendant demande de traitement (comme vous le faites dans le Servlet ou Filtre) au lieu de réponse de traitement (comme vous le faites dans JSP), mais de cette façon, vous pouvez risque que les données inutilement obtenir le double échappement (par exemple & devient & au lieu de & et, finalement, l'utilisateur final serait de voir & être présenté), ou que le DB-données stockées devient portables (par exemple, lors de l'exportation de données en JSON, CSV, XLS, PDF, etc qui ne nécessite pas de HTML échapper à tous). Vous aurez aussi perdre le contrôle social, parce que vous ne savez plus ce que l'utilisateur a effectivement rempli. Vous feriez comme étant un administrateur du site aiment vraiment de savoir quels utilisateurs/IPs sont en train de s'exécuter XSS, de sorte que vous pouvez facilement suivre et de prendre des mesures en conséquence. De s'échapper pendant le traitement de la demande devraient seulement être utilisés en tant que dernier recours, quand vous avez vraiment besoin de fixer une épave de train d'un mal développé web de l'héritage d'application dans le temps le plus court possible. Néanmoins, vous devriez en fin de compte réécrire vos fichiers JSP pour devenir XSS-fort.

Si vous souhaitez afficher de nouveau contrôlée par l'utilisateur saisie au format HTML dans lequel vous souhaitez autoriser uniquement un sous-ensemble de balises HTML comme <b>, <i>, <u>, etc, alors vous devez désinfecter l'entrée par une liste blanche. Vous pouvez utiliser un analyseur HTML comme Jsoup pour cela. Mais, beaucoup mieux est d'introduire un homme sympathique langage de balisage tel que Markdown (également utilisé ici sur Stack Overflow). Ensuite, vous pouvez utiliser un Abattement de l'analyseur comme CommonMark pour cela. Il a également builtin HTML désinfection des capacités. Voir aussi Je suis à la recherche d'un codeur HTML Java.

La seule préoccupation dans le côté serveur à l'égard des bases de données est L'injection SQL de prévention. Vous devez vous assurer que vous n'avez jamais à la chaîne concaténer contrôlée par l'utilisateur saisie directement dans le SQL ou requête JPQL et que vous êtes en utilisant des requêtes paramétrées dans tous les sens. Dans JDBC termes, cela signifie que vous devez utiliser PreparedStatement au lieu de Statement. En JPA termes, l'utilisation Requête.

---

Une autre solution serait de migrer à partir de JSP/Servlet Java EE du framework MVC JSF. Il a builtin XSS (et CSRF!) la prévention sur tous les lieux. Voir aussi CSRF, XSS et attaque par Injection SQL de prévention dans JSF.

J'ai eu beaucoup de chance avec OWASP Anti-Samy et un AspectJ conseiller sur tous mes Printemps Contrôleurs de blocs XSS d'entrer.

public class UserInputSanitizer {

    private static Policy policy;
    private static AntiSamy antiSamy;

    private static AntiSamy getAntiSamy() throws PolicyException  {
        if (antiSamy == null) {
            policy = getPolicy("evocatus-default");
            antiSamy = new AntiSamy();
        }
        return antiSamy;

    }

    public static String sanitize(String input) {
        CleanResults cr;
        try {
            cr = getAntiSamy().scan(input, policy);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return cr.getCleanHTML();
    }

    private static Policy getPolicy(String name) throws PolicyException {
        Policy policy = 
            Policy.getInstance(Policy.class.getResourceAsStream("/META-INF/antisamy/" + name + ".xml"));
        return policy;
    }

}

Vous pouvez obtenir le AspectJ conseiller de la cette stackoverflow post

Je pense que c'est une meilleure approche alors c:en particulier si vous faites beaucoup de javascript.

Je proposerais régulièrement des tests de vulnérabilités à l'aide d'un outil automatisé, et la fixation de tout ce qu'il trouve. Il est beaucoup plus facile de suggérer une bibliothèque pour les aider avec une vulnérabilité spécifique pour toutes les attaques XSS en général.

Skipfish est un outil open source de Google que j'ai étudié: il trouve beaucoup de choses, et semble valoir la peine de l'utiliser.

Mon opinion personnelle est que vous devriez éviter d'utiliser des JSP/ASP/PHP/etc pages. Au lieu de sortie à une API similaire à SAX (uniquement conçu pour vocation plutôt que sur le traitement). De cette façon, il y a une seule couche de créer ainsi formé de sortie.

Si vous voulez vous assurer que votre $ opérateur ne souffre pas de XSS hack vous pouvez mettre en œuvre ServletContextListener et faire quelques vérifications de là.

La solution complète à: http://pukkaone.github.io/2011/01/03/jsp-cross-site-scripting-elresolver.html

@WebListener
public class EscapeXmlELResolverListener implements ServletContextListener {
private static final Logger LOG = LoggerFactory.getLogger(EscapeXmlELResolverListener.class);
@Override
public void contextInitialized(ServletContextEvent event) {
LOG.info("EscapeXmlELResolverListener initialized ...");        
JspFactory.getDefaultFactory()
.getJspApplicationContext(event.getServletContext())
.addELResolver(new EscapeXmlELResolver());
}
@Override
public void contextDestroyed(ServletContextEvent event) {
LOG.info("EscapeXmlELResolverListener destroyed");
}
/**
* {@link ELResolver} which escapes XML in String values.
*/
public class EscapeXmlELResolver extends ELResolver {
private ThreadLocal<Boolean> excludeMe = new ThreadLocal<Boolean>() {
@Override
protected Boolean initialValue() {
return Boolean.FALSE;
}
};
@Override
public Object getValue(ELContext context, Object base, Object property) {
try {
if (excludeMe.get()) {
return null;
}
//This resolver is in the original resolver chain. To prevent
//infinite recursion, set a flag to prevent this resolver from
//invoking the original resolver chain again when its turn in the
//chain comes around.
excludeMe.set(Boolean.TRUE);
Object value = context.getELResolver().getValue(
context, base, property);
if (value instanceof String) {
value = StringEscapeUtils.escapeHtml4((String) value);
}
return value;
} finally {
excludeMe.remove();
}
}
@Override
public Class<?> getCommonPropertyType(ELContext context, Object base) {
return null;
}
@Override
public Iterator<FeatureDescriptor> getFeatureDescriptors(ELContext context, Object base){
return null;
}
@Override
public Class<?> getType(ELContext context, Object base, Object property) {
return null;
}
@Override
public boolean isReadOnly(ELContext context, Object base, Object property) {
return true;
}
@Override
public void setValue(ELContext context, Object base, Object property, Object value){
throw new UnsupportedOperationException();
}
}
}

De nouveau: on ne garde la $. Veuillez également consulter les autres réponses.