เป็นไปได้ที่จะใช้ Sandbox JavaScript ในเบราว์เซอร์หรือไม่?

ฉันสงสัยว่าเป็นไปได้ที่แซนด์บ็อกซ์ JavaScript จะทำงานในเบราว์เซอร์เพื่อป้องกันการเข้าถึงฟีเจอร์ที่ปกติแล้วพร้อมใช้งานกับโค้ด JavaScript ที่ทำงานในหน้า HTML

ตัวอย่างเช่นสมมติว่าฉันต้องการให้ JavaScript API สำหรับผู้ใช้ปลายทางเพื่อให้พวกเขากำหนดตัวจัดการเหตุการณ์ให้ทำงานเมื่อ "เหตุการณ์ที่น่าสนใจ" เกิดขึ้น แต่ฉันไม่ต้องการให้ผู้ใช้เหล่านั้นเข้าถึงคุณสมบัติและฟังก์ชั่นของwindowวัตถุ ฉันสามารถทำสิ่งนี้ได้หรือไม่?

alertในกรณีที่ง่ายที่สุดสมมติว่าผมต้องการที่จะป้องกันไม่ให้ผู้ใช้โทร สองวิธีที่ฉันคิดได้คือ:

• กำหนดใหม่window.alertทั่วโลก ฉันไม่คิดว่าเรื่องนี้จะเป็นวิธีการที่ถูกต้องเพราะรหัสอื่น ๆ ที่ทำงานในหน้า (สิ่งเช่นไม่ประพันธ์โดยผู้ใช้ในจัดการเหตุการณ์ของพวกเขา) alertอาจต้องการที่จะใช้
• ส่งรหัสตัวจัดการเหตุการณ์ไปยังเซิร์ฟเวอร์เพื่อประมวลผล ฉันไม่แน่ใจว่าการส่งรหัสไปยังเซิร์ฟเวอร์เพื่อประมวลผลเป็นวิธีการที่ถูกต้องเนื่องจากตัวจัดการเหตุการณ์จำเป็นต้องทำงานในบริบทของหน้าเว็บ

อาจเป็นทางออกที่เซิร์ฟเวอร์ประมวลผลฟังก์ชั่นที่ผู้ใช้กำหนดและสร้างการติดต่อกลับที่จะดำเนินการกับลูกค้าหรือไม่ แม้ว่าวิธีการนี้จะได้ผลดีกว่าในการแก้ปัญหานี้หรือไม่?

Google Cajaเป็นนักแปลที่มาจากแหล่งที่ "อนุญาตให้คุณใส่ HTML และ JavaScript ของบุคคลที่สามที่ไม่น่าเชื่อถือไว้ในหน้าของคุณและยังคงปลอดภัย"

ไปดูADsafe ของ Douglas Crockford :

ADsafe ทำให้การใส่รหัสแขก (เช่นโฆษณาหรือวิดเจ็ตของบุคคลที่สาม) บนหน้าเว็บใด ๆ ปลอดภัย ADsafe กำหนดชุดย่อยของ JavaScript ที่มีประสิทธิภาพมากพอที่จะอนุญาตให้โค้ดผู้เยี่ยมชมทำการโต้ตอบที่มีค่าในขณะเดียวกันก็ป้องกันการเสียหายหรือการบุกรุก ชุดย่อย ADsafe สามารถตรวจสอบโดยใช้กลไกโดยเครื่องมืออย่าง JSLint เพื่อไม่ให้มีการตรวจสอบบุคคลที่จำเป็นในการตรวจสอบรหัสผู้เข้าพักเพื่อความปลอดภัย ชุดย่อย ADsafe ยังบังคับใช้การเข้ารหัสที่ดีเพิ่มโอกาสที่รหัสแขกจะทำงานได้อย่างถูกต้อง

คุณสามารถดูตัวอย่างของวิธีการใช้ AdSafe โดยการมองหาที่template.htmlและtemplate.jsไฟล์ในโครงการที่เก็บ GitHub

ฉันสร้างห้องสมุดsandboxเรียกว่าjsandboxที่ใช้เว็บเวิร์คเพื่อรหัสที่ประเมิน sandbox นอกจากนี้ยังมีวิธีการป้อนข้อมูลเพื่อให้ข้อมูลรหัส sandboxed อย่างชัดเจนซึ่งไม่สามารถทำได้

ต่อไปนี้เป็นตัวอย่างของ 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
      }
  });

ฉันคิดว่าjs.jsน่าพูดถึงนี่ มันเป็นล่าม JavaScript ที่เขียนด้วย JavaScript

มันช้ากว่า Native JS ประมาณ 200 เท่า แต่ธรรมชาติของมันทำให้มันเป็นสภาพแวดล้อมที่สมบูรณ์แบบ ข้อเสียเปรียบอีกประการหนึ่งคือขนาดของมัน - เกือบ 600 kb ซึ่งอาจเป็นที่ยอมรับสำหรับเดสก์ท็อปในบางกรณี แต่ไม่ใช่สำหรับอุปกรณ์มือถือ

ดังที่กล่าวไว้ในเครื่องมือตอบรับอื่น ๆ ก็เพียงพอที่จะจำรหัสไว้ใน iframe แบบ sandboxed (โดยไม่ต้องส่งรหัสไปที่ฝั่งเซิร์ฟเวอร์) และสื่อสารกับข้อความ ฉันขอแนะนำให้ดูที่ห้องสมุดขนาดเล็กฉันสร้างขึ้นส่วนใหญ่เนื่องจากต้องการให้ API บางอย่างแก่รหัสที่ไม่น่าเชื่อถือเช่นเดียวกับที่อธิบายไว้ในคำถาม: มีโอกาสที่จะส่งออกชุดฟังก์ชันเฉพาะลงในกล่องทราย รหัสไม่น่าเชื่อถือทำงาน และยังมีตัวอย่างที่ใช้รหัสที่ผู้ใช้ส่งในแซนด์บ็อกซ์

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

ผู้ขายเบราว์เซอร์และข้อมูลจำเพาะ HTML5 ทั้งหมดทำงานต่อคุณสมบัติแซนด์บ็อกซ์จริงเพื่ออนุญาต iframe แบบ sandbox แต่ก็ยัง จำกัด อยู่ที่ granularity iframe

โดยทั่วไปแล้วไม่มีระดับของนิพจน์ทั่วไปและอื่น ๆ สามารถทำให้ผู้ใช้โดยพลการให้จาวาสคริปต์อย่างปลอดภัยเนื่องจากมันทำให้ปัญหาหยุดชะงัก: - /

รุ่นปรับปรุงของรหัส Sandbox เว็บเวิร์คของ @ RyanOHara ในไฟล์เดียว (ไม่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);
    });
    }

ทดสอบมัน

https://jsfiddle.net/kp0cq6yw/

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

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

ควรส่งออก6(ทดสอบใน Chrome และ Firefox)

วิธีที่น่าเกลียด แต่บางทีมันอาจเหมาะกับคุณฉันเอารูปวงกลมทั้งหมดและนิยามใหม่ไว้ในขอบเขตของกล่องทรายเช่นกันฉันได้เพิ่มโหมดที่เข้มงวดเพื่อให้พวกเขาไม่สามารถรับวัตถุระดับโลกได้โดยใช้ฟังก์ชันที่ไม่ระบุชื่อ

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

ล่าม Javascript อิสระมีแนวโน้มที่จะให้ผล sandbox ที่แข็งแกร่งกว่ารุ่นที่ถูกขังในการใช้งานเบราว์เซอร์ในตัว ไรอันได้กล่าวแล้ว js.jsแต่โครงการขึ้นไปวันคือJS-ล่าม เอกสารครอบคลุมถึงวิธีการที่จะเปิดเผยฟังก์ชั่นต่างๆเพื่อล่าม แต่ขอบเขตของมันจะถูก จำกัด มากมิฉะนั้น

ในปี 2019 vm2ดูเหมือนจะเป็นทางออกที่ได้รับความนิยมและได้รับการอัพเดทเป็นประจำมากที่สุดสำหรับปัญหานี้

ด้วยNISPคุณจะสามารถทำการประเมินแบบ Sandbox ได้ แม้ว่านิพจน์ที่คุณเขียนนั้นไม่ใช่ JS จริงๆ แต่คุณจะเขียน s-expressions ได้ เหมาะสำหรับ DSL แบบง่าย ๆ ที่ไม่ต้องการการเขียนโปรแกรมที่ครอบคลุม

1) สมมติว่าคุณมีรหัสเพื่อดำเนินการ:

var sCode = "alert(document)";

ตอนนี้สมมติว่าคุณต้องการรันมันในแซนด์บ็อกซ์:

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

สองบรรทัดนี้เมื่อเรียกใช้งานจะล้มเหลวเนื่องจากฟังก์ชั่น "การเตือน" ไม่พร้อมใช้งานจาก "แซนด์บ็อกซ์"

2) และตอนนี้คุณต้องการแสดงสมาชิกของวัตถุหน้าต่างด้วยฟังก์ชันการทำงานของคุณ:

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

แน่นอนว่าคุณสามารถเพิ่มเครื่องหมายคำพูดเพื่อหนีและทำการขัดแบบอื่น ๆ ได้ แต่ฉันคิดว่าความคิดนั้นชัดเจน

JavaScript ผู้ใช้นี้มาจากที่ใด

มีไม่มากที่คุณสามารถทำได้เกี่ยวกับผู้ใช้ฝังโค้ดในหน้าของคุณแล้วเรียกมันจากเบราว์เซอร์ของพวกเขา (ดู Greasemonkey, http://www.greasespot.net/ ) มันเป็นเพียงสิ่งที่เบราว์เซอร์ทำ

อย่างไรก็ตามถ้าคุณเก็บสคริปต์ไว้ในฐานข้อมูลให้ดึงมันมาและ eval () มันจากนั้นคุณสามารถทำความสะอาดสคริปต์ก่อนที่มันจะถูกเรียกใช้

ตัวอย่างของรหัสที่ลบหน้าต่างทั้งหมด และเอกสาร อ้างอิง:

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

สิ่งนี้พยายามป้องกันไม่ให้มีการดำเนินการต่อไปนี้ (ไม่ได้ทดสอบ):

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

มีข้อ จำกัด มากมายที่คุณจะต้องนำไปใช้กับสคริปต์ผู้ใช้ที่ไม่ปลอดภัย น่าเสียดายที่ไม่มี 'sandbox container' สำหรับ JavaScript

ฉันทำงานกับ sandbox js แบบง่าย ๆ เพื่อให้ผู้ใช้สร้าง applets สำหรับเว็บไซต์ของฉัน แม้ว่าฉันยังคงเผชิญกับความท้าทายบางอย่างด้วยการอนุญาตให้เข้าถึง DOM (parentNode เพียงแค่ไม่ให้ฉันเก็บสิ่งที่ปลอดภัย = /) วิธีการของฉันคือการกำหนดวัตถุหน้าต่างใหม่ด้วยสมาชิกที่มีประโยชน์ / ไม่เป็นอันตรายจากนั้น eval () ผู้ใช้ รหัสที่มีหน้าต่างนิยามใหม่นี้เป็นขอบเขตเริ่มต้น

รหัส "คอร์" ของฉันเป็นเช่นนี้ ... (ฉันไม่ได้แสดงเลย;)

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

ดังนั้นฉันสามารถอินสแตนซ์ Sandbox และใช้ execute () เพื่อเรียกใช้โค้ด นอกจากนี้ตัวแปรที่ประกาศใหม่ทั้งหมดภายในโค้ด eval'd จะผูกไว้กับขอบเขต execute () ในที่สุดดังนั้นจะไม่มีการปะทะกันของชื่อหรือ messing ด้วยรหัสที่มีอยู่

แม้ว่าวัตถุทั่วโลกจะยังคงอยู่ accesible วัตถุที่ควรจะยังไม่ทราบรหัส sandboxed จะต้องกำหนดเป็นผู้รับมอบฉันทะในวัตถุขอบเขต Sandbox ::

หวังว่าสิ่งนี้จะได้ผลสำหรับคุณ

คุณสามารถใส่รหัสของผู้ใช้ในฟังก์ชั่นที่กำหนดวัตถุต้องห้ามใหม่เป็นพารามิเตอร์ซึ่งสิ่งเหล่านี้จะเป็นเช่นนั้น undefinedเรียกเมื่อ:

(function (alert) {

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

}) ();

แน่นอนว่าผู้โจมตีที่ฉลาดสามารถแก้ไขสิ่งนี้ได้ด้วยการตรวจสอบ Javascript DOM และค้นหาวัตถุที่ไม่ถูกแทนที่ซึ่งมีการอ้างอิงไปยังหน้าต่าง

ความคิดก็คือการสแกนรหัสของผู้ใช้ใช้เครื่องมือเช่นJSLint ตรวจสอบให้แน่ใจว่าได้ตั้งค่าให้ไม่มีตัวแปรที่ตั้งไว้ล่วงหน้า (หรือ: เฉพาะตัวแปรที่คุณต้องการ) จากนั้นหากตั้งค่าหรือเข้าถึง globals ใด ๆ จะไม่อนุญาตให้ใช้สคริปต์ของผู้ใช้ อีกครั้งอาจมีความเสี่ยงที่จะเดิน DOM - วัตถุที่ผู้ใช้สามารถสร้างโดยใช้ตัวอักษรอาจมีการอ้างอิงโดยนัยไปยังวัตถุหน้าต่างที่สามารถเข้าถึงได้เพื่อหลบหนีกล่องทราย