原型链污染

原型对象

JavaScript中只有一种结构:对象。每个实例对象都有一个原型对象,而原型对象则引申出其对应的原型对象,经过一层层的链式调用,就构成了我们常说的"原型链"。
实例对象可以通过__proto__访问其原型对象:

>  let obj = {};
<· undefined
>  obj.__proto__;
<· {constructor: ƒ, __defineGetter__: ƒ, __defineSetter__: ƒ, hasOwnProperty: ƒ, __lookupGetter__: ƒ, …}

而经过不断的调用,最终的原型对象会调用到null,这将作为该原型链的最后一个环节,与之对应的,作为终点的null自然也是没有原型对象的。比如,我们继续在上面的例子中调用其原型对象:

>  obj.__proto__.__proto__;
<· null

在JavaScript中,可以用几种方式实现继承:原型链继承、借用构造函数继承、原型式继承,寄生式继承。

在Javascript中可以通过example.a.b或example.a[“b”]来对数组进行访问,example.a访问的是example对象下的a对象的b,而example.a[“b”]则是访问example对象下的a数组的下标为b的值。

由于对象是无序的,当使用第二种方式访问对象时,只能使用指明下标的方式去访问。

因此我们可以通过a[“proto”]的方式去访问其原型对象。

原型链污染攻击

prototype和__proto__

JavaScript中，我们如果要定义一个类，需要以定义“构造函数”的方式来定义：

function Foo() {
    this.bar = 1
}

new Foo()

Foo函数的内容，就是Foo类的构造函数，而this.bar就是Foo类的一个属性。

一个类必然有一些方法，类似属性this.bar，我们也可以将方法定义在构造函数内部：

function Foo() {
    this.bar = 1
    this.show = function() {
        console.log(this.bar)
    }
}
(new Foo()).show()

但这样写有一个问题，就是每当我们新建一个Foo对象时，this.show = function…就会执行一次，这个show方法实际上是绑定在对象上的，而不是绑定在“类”中。

我希望在创建类的时候只创建一次show方法，这时候就则需要使用原型（prototype）了：

function Foo() {
    this.bar = 1
}

Foo.prototype.show = function show() {
    console.log(this.bar)
}

let foo = new Foo()
foo.show()

我们可以认为原型prototype是类Foo的一个属性，而所有用Foo类实例化的对象，都将拥有这个属性中的所有内容，包括变量和方法。比如上图中的foo对象，其天生就具有foo.show()方法。

我们可以通过Foo.prototype来访问Foo类的原型，但Foo实例化出来的对象，是不能通过prototype访问原型的。这时候，就该__proto__登场了。

一个Foo类实例化出来的foo对象，可以通过foo.__proto__属性来访问Foo类的原型，也就是说：

foo.__proto__ == Foo.prototype

所以，总结一下：

1. prototype是一个类的属性，所有类对象在实例化的时候将会拥有prototype中的属性和方法
2. 一个对象的__proto__属性，指向这个对象所在的类的prototype属性

JavaScript原型链继承

所有类对象在实例化的时候将会拥有prototype中的属性和方法，这个特性被用来实现JavaScript中的继承机制。

比如：

function Father() {
    this.first_name = 'Donald'
    this.last_name = 'Trump'
}

function Son() {
    this.first_name = 'Melania'
}

Son.prototype = new Father()

let son = new Son()
console.log(`Name: ${son.first_name} ${son.last_name}`)

子类继承了父类的last_name属性，最后输出的是Name: Melania Trump。

总结一下，对于对象son，在调用son.last_name的时候，实际上JavaScript引擎会进行如下操作：

1. 在对象son中寻找last_name
2. 如果找不到，则在son.__proto__中寻找last_name
3. 如果仍然找不到，则继续在son.proto.__proto__中寻找last_name
4. 依次寻找，直到找到null结束。比如，Object.prototype的__proto__就是null

JavaScript的这个查找的机制，被运用在面向对象的继承中，被称作prototype继承链。

在编程中，我们需要牢记以下几点：

1. 每个构造函数(constructor)都有一个原型对象(prototype)
2. 对象的__proto__属性，指向类的原型对象prototype
3. JavaScript使用prototype链实现继承机制

原型链污染原理

之前，foo.__proto__指向的是Foo类的prototype。那么，如果我们修改了foo.__proto__中的值，是不是就可以修改Foo类呢？

做个简单的实验：

// foo是一个简单的JavaScript对象
let foo = {bar: 1}

// foo.bar 此时为1
console.log(foo.bar)

// 修改foo的原型（即Object）
foo.__proto__.bar = 2

// 由于查找顺序的原因，foo.bar仍然是1
console.log(foo.bar)

// 此时再用Object创建一个空的zoo对象
let zoo = {}

// 查看zoo.bar
console.log(zoo.bar)

虽然zoo是一个空对象{}，但zoo.bar的结果为2：

>	// foo是一个简单的JavaScript对象
	let foo = ibar: 1}
<·	undefined
>	// foo.bar 此时为1
	console.log(foo.bar)1
<·	undefined
>	//修改foo的原型（即0bject)
	foo._proto__.bar = 2
<·	2
>	//由于查找顺序的原因，foo.bar仍然是1
	console.log(foo.bar)
	1
<·	undefined
>	//此时再用0bject创建一个zoo对象
	let zo0 = {0}
<·	undefined
>	//查看zoo.bar
	console.log(zoo.bar)
	2
<·	undefined

原因：因为前面我们修改了foo的原型foo.proto.bar = 2，而foo是一个Object类的实例，所以实际上是修改了Object这个类，给这个类增加了一个属性bar，值为2。

后来，我们又用Object类创建了一个zoo对象let zoo = {}，zoo对象自然也有一个bar属性了。

那么，在一个应用中，如果攻击者控制并修改了一个对象的原型，那么将可以影响所有和这个对象来自同一个类、父祖类的对象。这种攻击方式就是原型链污染。

原型链会被污染的情况

想找可以被我们设置__proto__的值的情况，其实可以找找能够控制数组（对象）的“键名”的操作：

• 对象merge 结合 拼接
• 对象clone（其实内核就是将待操作的对象merge到一个空对象中） 复制

以对象merge为例，我们想象一个简单的merge函数：

function merge(target, source) {
    for (let key in source) {
        if (key in source && key in target) {
            merge(target[key], source[key])
        } else {
            target[key] = source[key]
        }
    }
}

在合并的过程中，存在赋值的操作target[key] = source[key]，那么，这个key如果是__proto__，是不是就可以原型链污染呢？

我们用如下代码实验一下：

let o1 = {}
let o2 = {a: 1, "__proto__": {b: 2}}
merge(o1, o2)
console.log(o1.a, o1.b)

o3 = {}
console.log(o3.b)

结果是，合并虽然成功了，但原型链没有被污染：

>	function merge(target, source) {
		for ( let key in source) {
			if (key in source &&_key in target) {
				merge(target [key] , source [key] )
			}else {
				target [key] = source [key]
			}
		}
	}
<·	undefined
>	let o1 = {}
	let o2 = {a: 1， "_proto_": {b: 2}merge(o1,o2)
	console.iog(o1.a，o1.b)
	1 2
<·	undefinedo
>	3 = {}
<·	{}
>	console.log(o3.b)
	undefined
<·	undefined

这是因为，我们用JavaScript创建o2的过程（let o2 = {a: 1, “proto”: {b: 2}}）中，__proto__已经代表o2的原型了，此时遍历o2的所有键名，你拿到的是[a, b]，__proto__并不是一个key，自然也不会修改Object的原型。

那么，如何让__proto__被认为是一个键名呢？

我们将代码改成如下：

let o1 = {}
let o2 = JSON.parse('{"a": 1, "__proto__": {"b": 2}}')
merge(o1, o2)
console.log(o1.a, o1.b)

o3 = {}
console.log(o3.b)

可见，新建的o3对象，也存在b属性，说明Object已经被污染：

>	function merge(target, source) {
		for ( let key in source) {
			if (key in source && key in target) {
				merge(target[key], source [key])
				} else {
					target [key] = source[key]
				}
			}
		}
	}
<·	undefined
>	let o1 = {}
	let o2= JSON.parse( '{"a"": 1, "_proto_": {"b": 2}}')
	merge(o1,o2)
	console.log(o1.a,o1.b)
	1 2
<	undefined
>	o3 ={}
<· {}
>	console.log(o3.b)
	2
<·	undefined

这是因为，JSON解析的情况下，__proto__会被认为是一个真正的“键名”，而不代表“原型”，所以在遍历o2的时候会存在这个键。

merge操作是最常见可能控制键名的操作，也最能被原型链攻击，很多常见的库都存在这个问题。