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

O Google Caja é um tradutor fonte-a-fonte que "permite que você coloque HTML e JavaScript não confiáveis em linha em sua página e ainda esteja seguro."

A ADsafe torna seguro colocar o código de convidado (como publicidade com script de terceiros ou widgets) em qualquer página web. ADsafe define um subconjunto de JavaScript que é poderoso o suficiente para permitir que o código convidado para realizar interações valiosas, ao mesmo tempo, evitando danos ou intrusões maliciosas ou acidentais. O subconjunto ADsafe pode ser verificado mecanicamente por ferramentas como JSLint de modo que nenhuma inspeção humana é necessária para rever o código de segurança dos convidados. O subconjunto ADsafe também impõe boas práticas de codificação, aumentando a probabilidade de que o código do hóspede será executado corretamente.

Poderá ver um exemplo de como usar o ADsafe, olhando para os ficheiros template.html e template.js no repositório GitHub do projecto .

Criei uma biblioteca de caixa de areia chamada jsandbox que usa web workers para avaliar o código. Ele também tem um método de entrada para dar explicitamente dados de código sandbox que de outra forma não seria capaz de obter.

O seguinte é 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
      }
  });

EDIT : Embora eu não saiba de uma maneira de escapar da lista de brancos abaixo, eu iria executar o trabalhador a partir de uma caixa de areia <iframe> também, apenas no caso, e iria segundo js do @gronostaj.recomendação js se a exaustão da memória é uma preocupação.

Os Web workers fornecem uma maneira conveniente de criar outro contexto de script, que pode então ser agressivamente sandboxed sem afetar o pai.

Uma implementação com promessas:

function safeEval(untrustedCode) {
    return new Promise(function (resolve, reject) {
        var worker = new Worker('eval.js');

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

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

        worker.postMessage(untrustedCode);

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

eval.js (provavelmente vais querer. expandir a lista de brancos):

(function (global) {
    'use strict';

    var _postMessage = postMessage;
    var _addEventListener = addEventListener;

    (function () {
        var current = global;
        var keepProperties = [
            // required
            'Object', 'Function', 'Infinity', 'NaN', 'undefined',
            // 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);
    })();

    _addEventListener('message', function (e) {
        var f = new Function('', 'return (' + e.data + '\n);');
        _postMessage(f());
    });
})(this);

Nenhum acesso UI dos trabalhadores, pode ser terminado separadamente, não pode amarrar o UI ou o script de execução, e são padrão.

Acho que js.vale a pena mencionar aqui o js. É um interpretador JavaScript escrito em JavaScript.

Como mencionado em outras responses, é suficiente prender o código em sandboxed iframe (sem enviá-lo para o lado do servidor) e se comunicar com as mensagens. Eu sugeriria dar uma olhada em uma biblioteca pequena que eu criei principalmente por causa da 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 particular de funções para a caixa de areia onde o código não confiável é executado. E há também uma demo que executa o código enviado por um utilizador numa caixa de areia:

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

Todos os fornecedores do navegador e a especificação HTML5 estão a trabalhar para uma propriedade real da caixa de areia para permitir as iframes de caixa de areia -- mas ainda está limitada à granularidade da iframe.

Em geral, nenhum grau de Expressões Regulares, etc. pode sanitar de forma segura o usuário arbitrário fornecido JavaScript como ele degenera para o problema de parada: - /

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

Uma versão melhorada do Código sandbox dos trabalhadores da web de @RyanOHara, num ficheiro único (não é necessário nenhum ficheiro extra eval.js).

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);
    });
    }

Testa-o:

Https://jsfiddle.net/kp0cq6yw/

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

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

Deve produzir 6 (testado em cromado e Firefox).

Um interpretador de Javascript independente é mais provável que produza uma caixa de areia robusta do que uma versão enjaulada da implementação do navegador builtin. O Ryan já mencionou ... js.js , mas um projecto mais actualizado é O intérprete js. O docs cobre como expor várias funções ao intérprete, mas o seu alcance é muito limitado.

De onde vem este utilizador JavaScript?

Não há muito que possa fazer acerca de um código incorporado pelo utilizador na sua página e depois chamá-lo a partir do seu navegador (ver Greasemonkey, http://www.greasespot.net é algo que os navegadores fazem.

No entanto, se você armazenar o script em uma base de dados, em seguida, recuperá-lo e eval() ele, então você pode limpar o script antes de ser executado.

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

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

Isto tenta impedir que sejam executados os seguintes ensaios (não testados):

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

Existem muitas limitações que você teria que aplicar ao script de usuário inseguro. Infelizmente, não há nenhum' recipiente de caixa de areia ' disponível para JavaScript.

1) suponha que tem um código para executar:

var sCode = "alert(document)";

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

Estas duas linhas quando executadas falharão, porque a função" alerta " não está disponível na "caixa de areia"

2) e agora quer expor um membro do objecto window com a sua funcionalidade:

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

Você pode embrulhar o código do utilizador numa função que redefine os objectos proibidos como parâmetros -- estes seriam então undefined quando chamados:

(function (alert) {

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

}) ();

Claro, os atacantes inteligentes podem contornar isto inspeccionando o DOM Javascript e encontrando um objecto não sobreposto que contém uma referência à janela.

Outra ideia é digitalizar o código do utilizador usando uma ferramenta como jslint . Certifique-se de que está definido para não ter variáveis predefinidas (ou: apenas variáveis que deseja), e então, se quaisquer globals são definidos ou acessados, não deixe o script do Usuário ser usado. Novamente, pode ser vulnerável a caminhar no DOM -- objetos que o usuário pode construir usando literais podem ter referências implícitas ao objeto da janela que pode ser acessado para escapar da caixa de areia.

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);
            }
        }
    };
}

Embora os objectos globais ainda sejam acessíveis, aqueles que devem permanecer desconhecidos do Código Sandbox devem ser definidos como proxies na caixa de areia::objecto de âmbito.