JavaScript是一门十分灵敏的言语，我感觉在某些方面或许比PHP愈加灵敏。所以，除了传统的SQL注入、代码履行等注入型漏洞外，也会有一些独有的安全问题，比方今日要说这个prototype污染。
0×01 prototype和proto别离是什么？
JavaScript中，咱们假如要界说一个类，需求以界说“结构函数”的办法来界说：
function Foo() {
    this.bar = 1
}
new Foo()
Foo函数的内容，便是Foo类的结构函数，而this.bar便是Foo类的一个特点。
为了简化编写JavaScript代码，ECMAScript 6后增加了class语法，但class其实仅仅一个语法糖。
一个类必定有一些办法，相似特点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特点
0×02 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承继链。
以上便是最根底的JavaScript面向目标编程，咱们并不深入研究更细节的内容，只需紧记以下几点即可：
1.每个结构函数(constructor)都有一个原型目标(prototype)
2.目标的proto特点，指向类的原型目标prototype
3.JavaScript运用prototype链完成承继机制
0×03 原型链污染是什么
之一章中提到，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特点了。
那么，在一个使用中，假如攻击者操控并修正了一个目标的原型，那么将能够影响一切和这个目标来自同一个类、父祖类的目标。这种攻击办法便是原型链污染。
0×04 哪些状况下原型链会被污染？
在实践使用中，哪些状况下或许存在原型链能被攻击者修正的状况呢？

[1] [2]  黑客接单网