原型链污染

首先深入了解javascript
JavaScript是一门非常灵活的语言，在某些方面比php都灵活，除了传统的SQL注入、代码执行等注入型漏洞外，也会有一些独有的安全问题，比如今天要说这个prototype污染。

1，JavaScript一切皆对象,
2，对象都有一个__proto__属性,指向它的类的``prototype`
3，类是通过函数来定义的,定义的这个函数又是这个类的constructor属性值
4，每个构造函数constructor都有一个原型对象prototype
5，JavaScript使用prototype链实现继承机制
6，子类是可以通过prototype链修改其父类属性,以及爷爷类的属性值的

原型链污染

0x01 prototype和__proto__分别是什么？

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

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

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

2，为了简化编写JavaScript代码，ECMAScript 6后增加了class语法
一个类必然有一些方法，类似属性this.bar，我们也可以将方法定义在构造函数内部：

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

(new Foo()).show()

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

3，加过我们想在创建类的时候只创建一次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访问原型的。

4，这个时候就要用__proto__
一个Foo类实例化出来的foo对象，可以通过foo.__proto__属性来访问Foo类的原型

foo.__proto__ == Foo.prototype

总结一下：
1，prototype是一个类的属性，所有类对象在实例化的时候就会拥有prototype中的属性和方法。
2，一个对象的_proto_属性，指向这个对象所在的类的prototype属性

0x02 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}`)

Son类继承了Father类的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链实现继承机制

0x03 原型链污染

由于_proto_是任何对象都有的属性，而js里万物皆对象，所以就会形成一条_proto_连起来的链条，递归访问_proto_必须最终到头，并且值是null
在一个应用中，如果攻击者控制并修改了一个对象的原型，呢么将可以影响所有和这个对象来自同一个类，父祖类的对象，这种攻击方式就是原型链污染。
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的原型foo.proto.bar = 2，而foo是一个Object类的实例，所以实际上是修改了Object这个类，给这个类增加了一个属性bar，值为2。后来，我们又用Object类创建了一个zoo对象let zoo = {}，zoo对象自然也有一个bar属性了。

0x04 什么时候会造成原型链污染

1, 看一下最简单的情况

obj[a][b] = value
obj[a][b][c] = value

如果控制了abc以及value就可以进行原型链污染攻击

2, 利用某些API来进行攻击
Object recursive merge

merge (target, source)
	foreach property of source
		if property exists and is an object on both the target and the source
			merge(target[property], source[property])
		else
			target[property] = source[property]

这种情况下,__proto__必须被视为key才能成功
对于下面这种

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]
        }
    }
}

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

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

//2. 
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)//2

仔细看这两种情况不一样
因为前面代码中 __proto__已经代表o2的原型了 ,没有被看成一个key
后面的代码中经过JSON.parse解析,__proto__就代表了一个key
4， Property definition by path

theFunction(object, path, value)

如果攻击者可以控制path,如path=proto.myValue.就可以进行污染
5， Object clone

function clone(obj) {
	return merge({}, obj);
}

参考博客：https://www.leavesongs.com/PENETRATION/javascript-prototype-pollution-attack.html#0x03
明天继续更新