目录
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、protptype是一个类的属性,所有类对象在实例化的时候将会拥有prototype中的属性和方法
2、一个对象的__proto__属性,指向这个对象所有的类的prototype属性
__proto__属性指向谁?
__proto__的指向取决于对象创建时的实现方式。以下图表列出了三种常见方式创建对象后,__proto__分别指向谁
1、字面量方式
/*1、字面量方式*/
var a = {};
console.log(a.__proto__); //Object {}
console.log(a.__proto__ === a.constructor.prototype); //true
2、构造器方式
/*2、构造器方式*/
var A = function(){};
var a = new A();
console.log(a.__proto__); //A {}
console.log(a.__proto__ === a.constructor.prototype); //true
3、Object.create方式
/*3、Object.create()方式*/
var a1 = {a:1}
var a2 = Object.create(a1);
console.log(a2.__proto__); //Object {a: 1}
console.log(a.__proto__ === a.constructor.prototype); //false(此处即为图1中的例外情况)
所以到底什么是原型链?
由于__proto__是任何对象都有的属性,而js里万物皆对象,所以会形成一条__proto__连起来的链条,递归访问__proto__必须最终到头,并且值是null。
当js引擎查找对象的属性时,先查找对象本身是否存在该属性,如果不存在,会在原型链上查找,但不会查找自身的prototype。
什么是原型链的继承?
所有类对象在实例化的时候将会拥有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
2、如果依然找不到,则继续在son.__proto__.__proto__中寻找last_name
4、依次寻找,直到找到null结束。比如,Object.perototype的__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原型foo.__proto__.bar = 2,而foo是一个Object类的实例,所以实际上是修改了Object这个类,给这个类增加一个属性bar,值为2。
后来,我们又用Object类创建了一个zoo对象let zoo = { },zoo对象自然也有一个bat属性了。
那么,在一个应用中,如果攻击者控制并修改了一个原型对象,那么将可以影响所有和这个对象来自同一个类、父祖类的对象。这种攻击方式称之为原型链污染。
哪种情况下原型链会被污染?
在实际应用中,哪些情况下可能存在原型链能被攻击者修改的情况呢?
我们思考一下,哪些情况下我们可以设置__proto__的值呢?
其实找到能操控数组(对象)的"键名"的操作即可:
1、对象merge(实际就是拼接,将两个数组拼接在一起)
2、对象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)
结果是,虽然合并成功了,但是原型链并没有被污染:
这是因为,我们用JavaScript创建o2的过程(let o2 = {a: 1,"__proto__": {b: 2}})中,__proto__已经代表o2的原型了,此时遍历o2的所有键名,你拿到的是[a, b],__peoto__并不是一个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已经被污染
为什么这次能够污染呢?
这是因为,JOSN格式解析的情况下,__proto__会被认为是一个真正的"键名",而不是代表"原型",所以在便利o2的时候会存在这个键。
merge操作是最常见可能控制键名的操作,也最能被原型链攻击,很多常见的库都存在这个问题。