原型链污染攻击（初级理解）

一、prototype和__proto__分别是什么？

JS中，若定义一个类，则需要“构造函数”的方式来定义：

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方法实际上是绑定在对象上，而不是绑定在“类”上。

此时，则需要使用原型（prototype）：使其绑定在原型“类”的属性上； Foo.prototype.show = function show( ) { }

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访问原型的。一个Foo类实例化出来的foo对象，可以通过foo.**__proto__属性**来访问Foo类的原型： foo.__proto__ == Foo.prototype == foo.constructor.prototype

foo = new Foo()
Foo {bar: 1}
foo.__proto__ == Foo.prototype
//true

总结一下： 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}`)

上代码，Son类继承了Father类的last_name属性，最后输出的是Name: Melania Trump。

总结一下: 对于对象son，在调用son.last_name的时候，实际上JS过程如下： 1. 在对象son中寻找last_name; 2. 如果找不到，则son.__proto__中寻找last_name； 3. 如果仍然找不到，则继续在son.__proto__.__proto__中寻找last_name； 4. 依次寻找，直到找到null结束。比如：Object.prototype的__proto__就是null；

重点牢记：

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的原型foo.proto.bar = 2，而foo是一个Object类的实例，所以实际上是修改了Object这个类，给这个类增加了一个属性bar，值为2。
后来，我们又用Object类创建了一个zoo对象let zoo = {}，zoo对象自然也有一个bar属性了。

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

四、那些情况下原型链会被污染？

能够去设置__proto__的值，就可以进行污染！ 其实找找能够**控制数组（对象）的“键名”**的操作即可：

- 对象merge 结合 拼接;
- 对象clone（其实内核就是将待操作的对象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]
        }
    }
}

实例一：
var x = {
    age: 11,
    num:1
}
var y = {
    age:12,
    num:120
}
merge(x,y);
console.info(x)
console.log(y)
///
{age: 11, num: 1}
{age: 12, num: 120}

实例二：
var x = {
    age: 11
}
var y = {
    age:12,
    num:120
}
merge(x,y);
console.info(x)
console.log(y)

{age: 11, num: 120}
{age: 12, num: 120}

上代码：
实例一：若x和y实例对象都一致，则merge不会做出任何改变，直接输出对象应有的值；
实例二：若x和y实例对象不一致，正如x缺少num，则merge会做出改变将y的num也传到x处从而让x输出的时候也学习到num；

断点调试过程：实例二！
断点进入后，target = (age: 11), source = (age: 12, num: 120)，往下走 key为age 进入for循环，判断key是否在target和source，是的话就进入到merge，由于merge是递归状态则需要回到source，此时
此时for循环到else结束第一次循环；

第二次循环开始，target = (age: 11), source = (age: 12, num: 120)，往下走 key为num进入for循环，然而只有source存在num，target不存在，不符合条件，则进入到else，因为source的num为120，则赋值与target，最终 x 上也存在了num:120的属性。

在合并的过程中，存在赋值的操作target[key] = source[key]，那么，这个key如果是__proto__？
注意: proto= Object.prototype

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

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

显然，合并是成功了，但是原型链并没有被污染，o3并没有赋值到，__proto__属性并没有生效。
原因：在于用JS创建o2的过程中，__proto__已经代表o2的原型了，并不是一个key，因此也不会起到任何作用；

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

JSON.parse：把JSON对象转换成JS；

实例四：
通过JSON格式去解析！
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已经被污染了；
原因：JSON解析的情况下，__proto__会被认为是一个真正的“键名”，而不代表“原型”，所以在遍历o2的时候会存在这个键。

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

走过路过别错过，感谢点赞支持！