É possível sandbox JavaScript em execução no navegador?

Gostaria de saber se é possível sandbox JavaScript em execução no navegador para impedir o acesso a recursos que normalmente estão disponíveis para o código JavaScript em execução em uma página HTML.

Por exemplo, digamos que desejo fornecer uma API JavaScript para os usuários finais, para que eles definam manipuladores de eventos a serem executados quando "eventos interessantes" acontecerem, mas não quero que esses usuários acessem as propriedades e funções do windowobjeto. Eu sou capaz de fazer isso?

No caso mais simples, digamos que eu queira impedir que os usuários liguem alert. Algumas abordagens em que consigo pensar são:

• Redefina window.alertglobalmente. Eu não acho que isso seria uma abordagem válida, porque outro código em execução na página (ou seja, coisas não criadas pelos usuários em seus manipuladores de eventos) pode querer usar alert.
• Envie o código do manipulador de eventos ao servidor para processar. Não tenho certeza de que enviar o código ao servidor para processar seja a abordagem correta, porque os manipuladores de eventos precisam ser executados no contexto da página.

Talvez uma solução em que o servidor processe a função definida pelo usuário e gere um retorno de chamada a ser executado no cliente funcionaria? Mesmo que essa abordagem funcione, existem maneiras melhores de resolver esse problema?

O Google Caja é um tradutor fonte a fonte que "permite inserir HTML e JavaScript de terceiros não confiáveis ​​na sua página e ainda assim estar seguro".

Dê uma olhada no ADsafe de Douglas Crockford :

O ADsafe torna seguro colocar código de convidado (como anúncios ou widgets com script de terceiros) em qualquer página da web. O ADsafe define um subconjunto de JavaScript que é poderoso o suficiente para permitir que o código de convidado execute interações valiosas, ao mesmo tempo em que evita danos ou invasões maliciosas ou acidentais. O subconjunto ADsafe pode ser verificado mecanicamente por ferramentas como JSLint, para que nenhuma inspeção humana seja necessária para revisar o código do hóspede por segurança. O subconjunto ADsafe também aplica boas práticas de codificação, aumentando a probabilidade de o código convidado ser executado corretamente.

Você pode ver um exemplo de como usar o ADsafe observando os arquivos template.htmle template.jsno repositório GitHub do projeto .

Criei uma biblioteca de sandbox chamada jsandbox que usa web workers para sandbox o código avaliado. Ele também possui um método de entrada para fornecer explicitamente dados de código em área restrita que de outra forma não seria possível obter.

A seguir, um exemplo da API:

jsandbox
    .eval({
      code    : "x=1;Math.round(Math.pow(input, ++x))",
      input   : 36.565010597564445,
      callback: function(n) {
          console.log("number: ", n); // number: 1337
      }
  }).eval({
      code   : "][];.]\\ (*# ($(! ~",
      onerror: function(ex) {
          console.log("syntax error: ", ex); // syntax error: [error object]
      }
  }).eval({
      code    : '"foo"+input',
      input   : "bar",
      callback: function(str) {
          console.log("string: ", str); // string: foobar
      }
  }).eval({
      code    : "({q:1, w:2})",
      callback: function(obj) {
          console.log("object: ", obj); // object: object q=1 w=2
      }
  }).eval({
      code    : "[1, 2, 3].concat(input)",
      input   : [4, 5, 6],
      callback: function(arr) {
          console.log("array: ", arr); // array: [1, 2, 3, 4, 5, 6]
      }
  }).eval({
      code    : "function x(z){this.y=z;};new x(input)",
      input   : 4,
      callback: function(x) {
          console.log("new x: ", x); // new x: object y=4
      }
  });

Eu acho que vale a pena mencionar o js.js aqui. É um intérprete de JavaScript escrito em JavaScript.

É cerca de 200 vezes mais lento que o JS nativo, mas sua natureza o torna um ambiente de sandbox perfeito. Outra desvantagem é seu tamanho - quase 600 kb, o que pode ser aceitável para desktops em alguns casos, mas não para dispositivos móveis.

Conforme mencionado em outras respostas, basta prender o código no iframe em área restrita (sem enviá-lo para o servidor) e se comunicar com as mensagens. Sugiro dar uma olhada em uma pequena biblioteca que criei principalmente devido à necessidade de fornecer alguma API para o código não confiável, assim como descrito na pergunta: há uma oportunidade de exportar o conjunto específico de funções diretamente para a sandbox onde o código não confiável é executado. E também há uma demonstração que executa o código enviado por um usuário em uma sandbox:

http://asvd.github.io/jailed/demos/web/console/

Todos os fornecedores de navegadores e a especificação HTML5 estão trabalhando em direção a uma propriedade de área restrita real para permitir iframes em área restrita - mas ainda é limitado à granularidade de iframe.

Em geral, nenhum grau de expressões regulares etc. pode limpar com segurança o usuário arbitrário, desde que o JavaScript se degenere no problema de interrupção: - /

Uma versão aprimorada do código da caixa de areia dos trabalhadores da Web do @ RyanOHara, em um único arquivo (nenhum eval.jsarquivo extra é necessário).

function safeEval(untrustedCode)
    {
    return new Promise(function (resolve, reject)
    {

    var blobURL = URL.createObjectURL(new Blob([
        "(",
        function ()
            {
            var _postMessage = postMessage;
            var _addEventListener = addEventListener;

            (function (obj)
                {
                "use strict";

                var current = obj;
                var keepProperties = [
                    // required
                    'Object', 'Function', 'Infinity', 'NaN', 'undefined', 'caches', 'TEMPORARY', 'PERSISTENT', 
                    // optional, but trivial to get back
                    'Array', 'Boolean', 'Number', 'String', 'Symbol',
                    // optional
                    'Map', 'Math', 'Set',
                ];

                do {
                    Object.getOwnPropertyNames(current).forEach(function (name) {
                        if (keepProperties.indexOf(name) === -1) {
                            delete current[name];
                        }
                    });

                    current = Object.getPrototypeOf(current);
                }
                while (current !== Object.prototype);
                })(this);

            _addEventListener("message", function (e)
            {
            var f = new Function("", "return (" + e.data + "\n);");
            _postMessage(f());
            });
            }.toString(),
        ")()"], {type: "application/javascript"}));

    var worker = new Worker(blobURL);

    URL.revokeObjectURL(blobURL);

    worker.onmessage = function (evt)
        {
        worker.terminate();
        resolve(evt.data);
        };

    worker.onerror = function (evt)
        {
        reject(new Error(evt.message));
        };

    worker.postMessage(untrustedCode);

    setTimeout(function () {
        worker.terminate();
        reject(new Error('The worker timed out.'));
        }, 1000);
    });
    }

Teste-o:

https://jsfiddle.net/kp0cq6yw/

var promise = safeEval("1+2+3");

promise.then(function (result) {
      alert(result);
      });

Deve sair 6(testado no Chrome e Firefox).

De uma maneira feia, mas talvez isso funcione para você, peguei todas as globais e as redefinii no escopo da sandbox e também adicionei o modo estrito para que elas não possam obter o objeto global usando uma função anônima.

function construct(constructor, args) {
  function F() {
      return constructor.apply(this, args);
  }
  F.prototype = constructor.prototype;
  return new F();
}
// Sanboxer 
function sandboxcode(string, inject) {
  "use strict";
  var globals = [];
  for (var i in window) {
    // <--REMOVE THIS CONDITION
    if (i != "console")
    // REMOVE THIS CONDITION -->
    globals.push(i);
  }
  globals.push('"use strict";\n'+string);
  return construct(Function, globals).apply(inject ? inject : {});
}
sandboxcode('console.log( this, window, top , self, parent, this["jQuery"], (function(){return this;}()));'); 
// => Object {} undefined undefined undefined undefined undefined undefined 
console.log("return of this", sandboxcode('return this;', {window:"sanboxed code"})); 
// => Object {window: "sanboxed code"}

https://gist.github.com/alejandrolechuga/9381781

É provável que um intérprete Javascript independente produza uma sandbox robusta do que uma versão em gaiola da implementação do navegador interno. Ryan já mencionou js.js , mas um projeto mais atualizado é o JS-Interpreter . Os documentos abordam como expor várias funções ao intérprete, mas seu escopo é muito limitado.

A partir de 2019, o vm2 parecerá a solução mais popular e a mais atualizada regularmente para esse problema.

Com o NISP, você poderá fazer uma avaliação em área restrita. Embora a expressão que você escreve não seja exatamente um JS, você escreverá expressões-s. Ideal para DSLs simples que não exigem programação extensa.

1) Suponha que você tenha um código para executar:

var sCode = "alert(document)";

Agora, suponha que você queira executá-lo em uma sandbox:

new Function("window", "with(window){" + sCode + "}")({});

Essas duas linhas quando executadas falharão, porque a função "alert" não está disponível na "sandbox"

2) E agora você deseja expor um membro do objeto de janela com a sua funcionalidade:

new Function("window", "with(window){" + sCode + "}")({
    'alert':function(sString){document.title = sString}
});

Na verdade, você pode adicionar aspas escapando e fazer outro polimento, mas acho que a ideia é clara.

De onde vem esse JavaScript do usuário?

Não há muito o que fazer sobre um usuário incorporar código à sua página e chamá-lo pelo navegador (consulte Greasemonkey, http://www.greasespot.net/ ). É apenas algo que os navegadores fazem.

No entanto, se você armazenar o script em um banco de dados, recuperá-lo e eval (), poderá limpar o script antes de executá-lo.

Exemplos de código que remove todas as janelas. e documento. referências:

 eval(
  unsafeUserScript
    .replace(/\/\/.+\n|\/\*.*\*\/, '') // Clear all comments
    .replace(/\s(window|document)\s*[\;\)\.]/, '') // removes window. or window; or window)
 )

Isso tenta impedir que o seguinte seja executado (não testado):

window.location = 'http://mydomain.com';
var w = window  ;

Existem muitas limitações que você teria que aplicar ao script de usuário não seguro. Infelizmente, não há 'container sandbox' disponível para JavaScript.

Eu tenho trabalhado em uma sandbox js simplista para permitir que os usuários criem applets para o meu site. Embora eu ainda enfrente alguns desafios ao permitir o acesso ao DOM (parentNode simplesmente não me deixa manter as coisas seguras = /), minha abordagem foi apenas redefinir o objeto de janela com alguns de seus membros úteis / inofensivos e depois avaliar () o usuário código com essa janela redefinida como o escopo padrão.

Meu código "principal" é assim ... (não estou mostrando isso totalmente;)

function Sandbox(parent){

    this.scope = {
        window: {
            alert: function(str){
                alert("Overriden Alert: " + str);
            },
            prompt: function(message, defaultValue){
                return prompt("Overriden Prompt:" + message, defaultValue);
            },
            document: null,
            .
            .
            .
            .
        }
    };

    this.execute = function(codestring){

        // here some code sanitizing, please

        with (this.scope) {
            with (window) {
                eval(codestring);
            }
        }
    };
}

Então, eu posso instalar uma Sandbox e usar sua execute () para executar o código. Além disso, todas as novas variáveis ​​declaradas no código eval'd acabam vinculadas ao escopo execute (), portanto, não haverá nomes conflitantes nem interferindo no código existente.

Embora os objetos globais ainda sejam acessíveis, aqueles que devem permanecer desconhecidos no código da área restrita devem ser definidos como proxies no objeto Sandbox :: scope.

Espero que funcione para voce.

Você pode agrupar o código do usuário em uma função que redefine objetos proibidos como parâmetros - estes seriam undefinedchamados quando:

(function (alert) {

alert ("uh oh!"); // User code

}) ();

Obviamente, invasores inteligentes podem contornar isso inspecionando o DOM Javascript e localizando um objeto não substituído que contém uma referência à janela.

Outra idéia é escanear o código do usuário usando uma ferramenta como jslint . Certifique-se de que ele esteja definido para não ter variáveis ​​predefinidas (ou: apenas variáveis ​​desejadas) e, se quaisquer globais estiverem configurados ou acessados, não permita que o script do usuário seja usado. Novamente, pode ser vulnerável a andar pelo DOM - objetos que o usuário pode construir usando literais podem ter referências implícitas ao objeto de janela que pode ser acessado para escapar da sandbox.