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

อย่างไรก็ตามฉันมักจะเบือนหน้าหนีจากการใช้งานeval()ถ้าฉันสามารถหลีกเลี่ยงได้เพราะมันเป็นสิ่งที่ชั่วร้าย (และถูกหรือผิดฉันคิดเสมอว่ามันเป็นสิ่งที่เลวร้ายกว่าใน JavaScript เพราะรหัสที่จะถูกประเมินอาจมีการเปลี่ยนแปลงโดยผู้ใช้ )

ดังนั้นเมื่อไรที่จะใช้มัน?

ฉันต้องการที่จะใช้เวลาสักครู่เพื่อตอบคำถามของคุณ - Eval () นั้น " ชั่วร้าย " คำว่า " ความชั่วร้าย " ที่ใช้โดยคนภาษาการเขียนโปรแกรมมักจะหมายถึง "อันตราย" หรือแม่นยำกว่า "สามารถทำให้เกิดความเสียหายมากมายด้วยคำสั่งที่ดูง่าย" ดังนั้นเมื่อไรที่จะใช้สิ่งที่เป็นอันตราย? เมื่อคุณรู้ว่าอันตรายคืออะไรและเมื่อคุณใช้มาตรการป้องกันที่เหมาะสม

ถึงจุดนี้ลองดูที่อันตรายในการใช้ eval () อาจมีอันตรายซ่อนเร้นขนาดเล็กจำนวนมากเหมือนกับทุกสิ่งทุกอย่าง แต่ความเสี่ยงใหญ่สองประการ - สาเหตุที่ทำให้ eval () ถูกพิจารณาว่าเป็นสิ่งชั่ว - คือประสิทธิภาพและการฉีดโค้ด

• ประสิทธิภาพ - eval () เรียกใช้ตัวแปล / คอมไพเลอร์ ถ้ารหัสของคุณถูกคอมไพล์นี่เป็นสิ่งที่ฮิตมากเพราะคุณต้องเรียกคอมไพเลอร์ที่อาจมีค่ามากในช่วงเวลาทำงาน อย่างไรก็ตาม JavaScript ยังคงเป็นภาษาที่ตีความส่วนใหญ่ซึ่งหมายความว่าการเรียก eval () ไม่ใช่ประสิทธิภาพที่ยิ่งใหญ่ในกรณีทั่วไป (แต่ดูคำพูดเฉพาะของฉันด้านล่าง)
• การฉีดโค้ด - eval () อาจเรียกใช้สตริงของรหัสภายใต้สิทธิ์ระดับสูง ตัวอย่างเช่นโปรแกรมที่ทำงานในฐานะผู้ดูแลระบบ / รูทจะไม่ต้องการ eval () อินพุตของผู้ใช้เนื่องจากอินพุตนั้นอาจเป็น "rm -rf / etc / important-file" หรือแย่กว่านั้น อีกครั้ง JavaScript ในเบราว์เซอร์ไม่มีปัญหานั้นเนื่องจากโปรแกรมกำลังทำงานในบัญชีของผู้ใช้อยู่แล้ว JavaScript ฝั่งเซิร์ฟเวอร์อาจมีปัญหานั้น

เพื่อกรณีเฉพาะของคุณ จากสิ่งที่ฉันเข้าใจคุณกำลังสร้างสตริงด้วยตัวเองดังนั้นสมมติว่าคุณระวังที่จะไม่สร้างสตริงเช่น "rm -rf some-important" ที่จะสร้างไม่มีความเสี่ยงในการฉีดรหัส (แต่โปรดจำไว้ว่ามันเป็นเรื่องที่ดีมาก ยากที่จะมั่นใจในกรณีทั่วไป) นอกจากนี้หากคุณใช้เบราว์เซอร์การฉีดโค้ดมีความเสี่ยงเล็กน้อยฉันเชื่อว่า

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

eval()ไม่ใช่ความชั่วร้าย หรือถ้าเป็นก็เป็นสิ่งที่ชั่วร้ายในลักษณะเดียวกันกับที่ไฟล์ภาพ / I / O ของเครือข่ายการทำเกลียวและ IPC เป็น "ความชั่วร้าย" ในภาษาอื่น

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

เมื่อคุณเชื่อถือแหล่งที่มา

ในกรณีของ JSON มันยากมากที่จะยุ่งเกี่ยวกับแหล่งที่มาเพราะมันมาจากเว็บเซิร์ฟเวอร์ที่คุณควบคุม ตราบใดที่ JSON เองไม่มีข้อมูลที่ผู้ใช้อัปโหลดไม่มีข้อเสียเปรียบที่สำคัญในการใช้ eval

ในกรณีอื่น ๆ ทั้งหมดฉันจะใช้ความพยายามอย่างยิ่งใหญ่ในการตรวจสอบให้แน่ใจว่าข้อมูลที่ผู้ใช้ให้มานั้นสอดคล้องกับกฎของฉันก่อนที่จะส่งไปให้ eval ()

รับคนจริง ๆ :

1. เบราว์เซอร์หลัก ๆ ทุกเครื่องมีคอนโซลในตัวซึ่งแฮกเกอร์ของคุณสามารถใช้ได้อย่างมากมายในการเรียกใช้ฟังก์ชั่นที่มีค่าใด ๆ

2. หากใช้เวลา 0.2 วินาทีในการรวบรวม JavaScript 2,000 บรรทัดการเสื่อมประสิทธิภาพของฉันจะเป็นอย่างไรหากฉันประเมิน JSON สี่บรรทัด

แม้แต่คำอธิบายของ Crockford สำหรับ 'eval is evil' ก็อ่อนแอ

eval is Evil, ฟังก์ชั่น eval เป็นคุณสมบัติที่ใช้งานผิดพลาดมากที่สุดของ JavaScript หลีกเลี่ยงมัน

ในขณะที่คร็อคฟอร์ดเองอาจพูดว่า "ข้อความแบบนี้มีแนวโน้มที่จะสร้างโรคประสาทไม่ลงตัวอย่าซื้อเลย"

การทำความเข้าใจการประเมินและการรู้ว่าเมื่อใดจะมีประโยชน์มีความสำคัญมากกว่า ตัวอย่างเช่น eval เป็นเครื่องมือที่เหมาะสมสำหรับการประเมินการตอบกลับของเซิร์ฟเวอร์ที่สร้างโดยซอฟต์แวร์ของคุณ

BTW: Prototype.js เรียกใช้ eval โดยตรงห้าครั้ง (รวมถึง evalJSON () และ evalResponse ()) jQuery ใช้มันใน parseJSON (ผ่าน Function Constructor)

ฉันมักจะทำตามคำแนะนำ Crockford ของสำหรับeval()และหลีกเลี่ยงมันทั้งหมด แม้แต่วิธีที่ดูเหมือนว่าต้องการไม่ทำ ตัวอย่างเช่นการsetTimeout()อนุญาตให้คุณผ่านฟังก์ชั่นแทนที่จะเป็นแบบ eval

setTimeout(function() {
  alert('hi');
}, 1000);

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

ฉันเห็นคนสนับสนุนไม่ใช้ eval เพราะมันชั่วร้ายแต่ฉันเห็นคนเดียวกันใช้ Function และ setTimeout แบบไดนามิกดังนั้นพวกเขาจึงใช้ eval ภายใต้หมวก : D

BTW หากแซนด์บ็อกซ์ของคุณไม่เพียงพอ (ตัวอย่างเช่นหากคุณกำลังทำงานในไซต์ที่อนุญาตให้มีการฉีดโค้ด) eval เป็นปัญหาสุดท้ายของคุณ กฎพื้นฐานของการรักษาความปลอดภัยที่ทุกการป้อนข้อมูลเป็นความชั่วร้าย แต่ในกรณีของ JavaScript แม้ JavaScript ตัวเองอาจจะเป็นความชั่วร้ายเพราะใน JavaScript คุณสามารถเขียนทับฟังก์ชั่นใด ๆ และคุณก็ไม่สามารถให้แน่ใจว่าคุณกำลังใช้จริงดังนั้น หากโค้ดอันตรายเริ่มต้นก่อนหน้าคุณจะไม่สามารถไว้ใจฟังก์ชั่น JavaScript ในตัว: D

ตอนนี้บทส่งท้ายของบทความนี้คือ:

ถ้าคุณ จริงๆต้องการมัน (80% ของเวลา EVAL จะไม่จำเป็น) และคุณแน่ใจว่าสิ่งที่คุณกำลังทำเพียงแค่ใช้ EVAL (หรือฟังก์ชั่นที่ดีกว่า;)) ปิดและ OOP ครอบคลุม 80/90% ของ กรณีที่สามารถเปลี่ยน eval โดยใช้ตรรกะชนิดอื่นส่วนที่เหลือเป็นรหัสที่สร้างขึ้นแบบไดนามิก (ตัวอย่างเช่นถ้าคุณกำลังเขียนล่าม) และตามที่คุณพูดแล้วประเมิน JSON (ที่นี่คุณสามารถใช้การประเมินผลที่ปลอดภัย Crockford;))

Eval เป็นส่วนเสริมของการคอมไพล์ซึ่งใช้ในการสร้างรหัสเทมเพลต โดยการสร้างเทมเพลตฉันหมายความว่าคุณเขียนเทมเพลตที่เรียบง่ายซึ่งสร้างโค้ดเทมเพลตที่มีประโยชน์ซึ่งจะช่วยเพิ่มความเร็ว

ฉันได้เขียนเฟรมเวิร์กโดยที่นักพัฒนาไม่ได้ใช้ EVAL แต่พวกเขาใช้เฟรมเวิร์กของเราและในที่สุดเฟรมเวิร์กก็ต้องใช้ EVAL เพื่อสร้างเทมเพลต

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

var a = eval("3 + 5");

มันควรจะจัดเป็น

var f = eval("(function(a,b) { return a + b; })");

var a = f(3,5);

การแคชจะปรับปรุงความเร็วอย่างแน่นอน

Chrome ยังสามารถแก้ไขข้อบกพร่องของฟังก์ชั่นดังกล่าวได้อย่างง่ายดาย

เกี่ยวกับความปลอดภัยการใช้ eval หรือไม่สร้างความแตกต่าง

1. ก่อนอื่นเบราว์เซอร์จะเรียกใช้สคริปต์ทั้งหมดในแซนด์บ็อกซ์
2. รหัสใด ๆ ที่เป็นความชั่วร้ายใน EVAL เป็นความชั่วร้ายในเบราว์เซอร์เอง ผู้โจมตีหรือใครก็ตามสามารถฉีดโหนดสคริปต์ใน DOM ได้อย่างง่ายดายและทำทุกอย่างถ้าเขา / เธอสามารถทำอะไรได้ การไม่ใช้ EVAL จะไม่สร้างความแตกต่างใด ๆ
3. การรักษาความปลอดภัยฝั่งเซิร์ฟเวอร์ส่วนใหญ่นั้นเป็นอันตราย การตรวจสอบคุกกี้ที่ไม่ดีหรือการใช้งาน ACL ที่ไม่ดีบนเซิร์ฟเวอร์ทำให้เกิดการโจมตีส่วนใหญ่
4. ช่องโหว่ Java ล่าสุดและอื่น ๆ มีอยู่ในโค้ดเนทีฟของ Java JavaScript นั้นถูกออกแบบมาให้ทำงานในแซนด์บ็อกซ์ในขณะที่แอปเพล็ตถูกออกแบบมาให้ทำงานนอกแซนด์บ็อกซ์พร้อมใบรับรอง ฯลฯ ซึ่งนำไปสู่ช่องโหว่และสิ่งอื่น ๆ อีกมากมาย
5. การเขียนโค้ดเพื่อเลียนแบบเบราว์เซอร์นั้นไม่ยาก สิ่งที่คุณต้องทำคือส่งคำขอ HTTP ไปยังเซิร์ฟเวอร์ด้วยสตริงตัวแทนผู้ใช้ที่คุณชื่นชอบ เครื่องมือทดสอบทั้งหมดจำลองเบราว์เซอร์ไว้แล้ว หากผู้โจมตีต้องการทำร้ายคุณ EVAL เป็นทางเลือกสุดท้ายของพวกเขา พวกเขามีวิธีอื่น ๆ ในการจัดการกับความปลอดภัยฝั่งเซิร์ฟเวอร์ของคุณ
6. DOM เบราว์เซอร์ไม่สามารถเข้าถึงไฟล์และไม่ใช่ชื่อผู้ใช้ อันที่จริงไม่มีอะไรในเครื่องที่ eval สามารถเข้าถึงได้

หากการรักษาความปลอดภัยฝั่งเซิร์ฟเวอร์ของคุณมั่นคงเพียงพอสำหรับทุกคนที่จะถูกโจมตีจากทุกที่คุณไม่ควรกังวลเกี่ยวกับ EVAL อย่างที่ฉันได้กล่าวไปแล้วว่าถ้าไม่มี EVAL ผู้โจมตีจะมีเครื่องมือมากมายที่จะแฮ็คเข้าสู่เซิร์ฟเวอร์ของคุณ

Eval นั้นดีสำหรับการสร้างเทมเพลตบางตัวเพื่อทำการประมวลผลสตริงที่ซับซ้อนตามสิ่งที่ไม่ได้ใช้ล่วงหน้า ตัวอย่างเช่นฉันจะชอบ

"FirstName + ' ' + LastName"

ตรงข้ามกับ

"LastName + ' ' + FirstName"

เป็นชื่อที่แสดงของฉันซึ่งสามารถมาจากฐานข้อมูลและไม่ได้ hardcoded

เมื่อทำการดีบั๊กใน Chrome (v28.0.1500.72) ฉันพบว่าตัวแปรไม่ถูกผูกไว้กับการปิดหากไม่ได้ใช้ในฟังก์ชันซ้อนที่สร้างการปิด ฉันเดาว่าเป็นเครื่องมือเพิ่มประสิทธิภาพของ JavaScript

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

นี่คือรหัสทดสอบของฉัน:

(function () {
    var eval = function (arg) {
    };

    function evalTest() {
        var used = "used";
        var unused = "not used";

        (function () {
            used.toString();   // Variable "unused" is visible in debugger
            eval("1");
        })();
    }

    evalTest();
})();

(function () {
    var eval = function (arg) {
    };

    function evalTest() {
        var used = "used";
        var unused = "not used";

        (function () {
            used.toString();   // Variable "unused" is NOT visible in debugger
            var noval = eval;
            noval("1");
        })();
    }

    evalTest();
})();

(function () {
    var noval = function (arg) {
    };

    function evalTest() {
        var used = "used";
        var unused = "not used";

        (function () {
            used.toString();    // Variable "unused" is NOT visible in debugger
            noval("1");
        })();
    }

    evalTest();
})();

สิ่งที่ฉันชอบที่จะชี้ให้เห็นที่นี่คือ eval () นั้นไม่จำเป็นต้องอ้างถึงeval()ฟังก์ชั่นพื้นฐาน ทั้งหมดขึ้นอยู่กับชื่อของฟังก์ชั่น ดังนั้นเมื่อเรียกชื่อพื้นเมืองeval()ด้วยชื่อนามแฝง (พูดvar noval = eval;แล้วในฟังก์ชันภายในnoval(expression);) การประเมินผลexpressionอาจล้มเหลวเมื่ออ้างถึงตัวแปรที่ควรเป็นส่วนหนึ่งของการปิด แต่จริง ๆ แล้วไม่ใช่

ไมโครซอฟท์อธิบายว่าทำไม EVAL () เป็นไปอย่างช้าในเบราว์เซอร์ของพวกเขาในบล็อก IE, คำแนะนำ IE + JavaScript ในผลการดำเนินงานส่วนที่ 2: รหัส JavaScript ไร้ประสิทธิภาพ

บรรทัดล่าง

หากคุณสร้างหรือปรุงแต่งรหัสที่คุณevalก็ไม่เคยมีความชั่วร้าย

รายละเอียดเพิ่มเติมเล็กน้อย

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

evalคือไม่ได้ชั่วร้ายถ้าทำงานบนไคลเอนต์แม้ว่าใช้อินพุต unsanitized ที่สร้างขึ้นโดยลูกค้า

เห็นได้ชัดว่าคุณควรฆ่าเชื้ออินพุตให้สะอาดอยู่เสมอเพื่อให้สามารถควบคุมโค้ดที่คุณใช้

เหตุผล

ไคลเอนต์สามารถเรียกใช้รหัสใด ๆ ที่พวกเขาต้องการแม้ว่านักพัฒนาไม่ได้รหัส นี่คือความจริงไม่เพียง แต่สำหรับสิ่งที่จะ evaled แต่เรียกร้องให้evalตัวเอง

อินสแตนซ์เดียวที่คุณควรใช้ eval () คือเมื่อคุณต้องการเรียกใช้ JS แบบไดนามิกได้ทันที ฉันกำลังพูดถึง JS ที่คุณดาวน์โหลดแบบอะซิงโครนัสจากเซิร์ฟเวอร์ ...

... และ 9 คูณ 10 คุณสามารถหลีกเลี่ยงการทำเช่นนั้นซ้ำได้โดยง่าย

evalไม่ใช่ทางเลือกที่เหมาะสม ขณะที่อาจมีหลายกรณีที่คุณสามารถบรรลุสิ่งที่คุณต้องการที่จะประสบความสำเร็จโดยการเชื่อมโยงสคริปต์ด้วยกันและทำงานได้ทันทีคุณมักจะมีประสิทธิภาพมากขึ้นและเทคนิคการบำรุงรักษาที่จำหน่ายของคุณ: สัญกรณ์เชื่อมโยงอาร์เรย์ ( obj["prop"]เป็นเช่นเดียวกับobj.prop) , การปิด, เทคนิคเชิงวัตถุ, เทคนิคการใช้งาน - ใช้มันแทน

เท่าที่ลูกค้าสคริปต์ไปฉันคิดว่าปัญหาด้านความปลอดภัยเป็นจุดที่สงสัย ทุกสิ่งที่โหลดลงในเบราว์เซอร์อาจมีการจัดการและควรได้รับการปฏิบัติเช่นนี้ ไม่มีความเสี่ยงในการใช้คำสั่ง eval () เมื่อมีวิธีที่ง่ายกว่าในการเรียกใช้โค้ด JavaScript และ / หรือจัดการกับวัตถุใน DOM เช่นแถบ URL ในเบราว์เซอร์ของคุณ

javascript:alert("hello");

ถ้ามีคนต้องการจัดการ DOM ของพวกเขาฉันจะบอกว่าแกว่งไป การรักษาความปลอดภัยเพื่อป้องกันการโจมตีประเภทใด ๆ ควรเป็นความรับผิดชอบของแอปพลิเคชันเซิร์ฟเวอร์ระยะเวลา

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

<html>
    <body>
        <textarea id="output"></textarea><br/>
        <input type="text" id="input" />
        <button id="button" onclick="execute()">eval</button>

        <script type="text/javascript">
            var execute = function(){
                var inputEl = document.getElementById('input');
                var toEval = inputEl.value;
                var outputEl = document.getElementById('output');
                var output = "";

                try {
                    output = eval(toEval);
                }
                catch(err){
                    for(var key in err){
                        output += key + ": " + err[key] + "\r\n";
                    }
                }
                outputEl.value = output;
            }
        </script>
    <body>
</html>

บนฝั่งเซิร์ฟเวอร์ eval มีประโยชน์เมื่อจัดการกับสคริปต์ภายนอกเช่น sql หรือ influxdb หรือ mongo การตรวจสอบความถูกต้องที่กำหนดเอง ณ รันไทม์สามารถทำได้โดยไม่ต้องปรับใช้บริการของคุณอีกครั้ง

ตัวอย่างเช่นบริการความสำเร็จที่มีข้อมูลเมตาดังต่อไปนี้

{
  "568ff113-abcd-f123-84c5-871fe2007cf0": {
    "msg_enum": "quest/registration",
    "timely": "all_times",
    "scope": [
      "quest/daily-active"
    ],
    "query": "`SELECT COUNT(point) AS valid from \"${userId}/dump/quest/daily-active\" LIMIT 1`",
    "validator": "valid > 0",
    "reward_external": "ewallet",
    "reward_external_payload": "`{\"token\": \"${token}\", \"userId\": \"${userId}\", \"amountIn\": 1, \"conversionType\": \"quest/registration:silver\", \"exchangeProvider\":\"provider/achievement\",\"exchangeType\":\"payment/quest/registration\"}`"
  },
  "efdfb506-1234-abcd-9d4a-7d624c564332": {
    "msg_enum": "quest/daily-active",
    "timely": "daily",
    "scope": [
      "quest/daily-active"
    ],
    "query": "`SELECT COUNT(point) AS valid from \"${userId}/dump/quest/daily-active\" WHERE time >= '${today}' ${ENV.DAILY_OFFSET} LIMIT 1`",
    "validator": "valid > 0",
    "reward_external": "ewallet",
    "reward_external_payload": "`{\"token\": \"${token}\", \"userId\": \"${userId}\", \"amountIn\": 1, \"conversionType\": \"quest/daily-active:silver\", \"exchangeProvider\":\"provider/achievement\",\"exchangeType\":\"payment/quest/daily-active\"}`"
  }
}

ซึ่งอนุญาตให้

• การฉีดโดยตรงของวัตถุ / ค่าผ่านสตริงตัวอักษรใน json มีประโยชน์สำหรับตำราเทมเพลต

• สามารถใช้เป็นเครื่องมือเปรียบเทียบกล่าวว่าเราสร้างกฎวิธีการตรวจสอบความถูกต้องของภารกิจหรือเหตุการณ์ใน CMS

แย้งของนี้

• อาจเป็นข้อผิดพลาดในรหัสและแยกแยะสิ่งต่าง ๆ ในบริการหากไม่ผ่านการทดสอบอย่างสมบูรณ์

• หากแฮ็กเกอร์สามารถเขียนสคริปต์บนระบบของคุณแสดงว่าคุณเมามาก

• วิธีหนึ่งในการตรวจสอบสคริปต์ของคุณคือรักษาแฮชสคริปต์ไว้ที่ใดที่หนึ่งที่ปลอดภัยดังนั้นคุณสามารถตรวจสอบสคริปต์ก่อนทำงานได้

ฉันคิดว่ากรณีใด ๆ ของการประเมินความชอบธรรมจะหายาก คุณมีแนวโน้มที่จะใช้มันโดยคิดว่ามันเป็นธรรมมากกว่าที่คุณจะใช้มันเมื่อมันเป็นธรรมจริง

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

หากคุณต้องการทราบข้อมูลเพิ่มเติม: https://github.com/getify/You-Dont-Know-JS/blob/master/scope%20%26%20closures/ch2.md#eval

ไม่เป็นไรหากคุณสามารถควบคุมรหัสที่ส่งผ่านไปยังevalฟังก์ชันได้อย่างสมบูรณ์

เฉพาะในระหว่างการทดสอบถ้าเป็นไปได้ โปรดทราบด้วยว่า eval () ช้ากว่าผู้ให้คำปรึกษาเฉพาะด้านอื่น ๆ มากเช่นกัน

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

ดังนั้น ... เมื่อใดที่จะไม่ใช้ eval ()? Eval () ไม่ควรใช้เมื่อมีโอกาสที่บุคคลที่สามสามารถเปลี่ยนได้ เช่นเดียวกับการสกัดกั้นการเชื่อมต่อระหว่างไคลเอนต์และเซิร์ฟเวอร์ของคุณ (แต่ถ้าเป็นปัญหาให้ใช้ HTTPS) คุณไม่ควร eval () สำหรับการแยกวิเคราะห์รหัสที่คนอื่นเขียนเช่นในฟอรัม

ถ้ามันจำเป็นจริงๆ eval ไม่ใช่ความชั่วร้าย แต่ 99.9% ของการใช้ eval ที่ฉันสะดุดข้ามนั้นไม่จำเป็น (ไม่รวมสิ่ง setTimeout)

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

JavaScript ของ eval () ไม่ใช่ชั่วเมื่อใด

ฉันมักจะพยายามที่จะกีดกันจากการใช้ EVAL เกือบทุกครั้งจะมีวิธีแก้ปัญหาที่สะอาดและดูแลรักษาได้มากกว่า Eval ไม่จำเป็นแม้สำหรับ JSON แยก Eval เพิ่มการบำรุงรักษานรกเพิ่มไปยังนรกในการบำรุงรักษาไม่ว่าจะด้วยเหตุผลใดมันก็เป็นที่ขมวดคิ้วเช่นเดียวกับดักลาสครอคฟอร์ด

แต่ฉันพบตัวอย่างหนึ่งที่ควรใช้:

เมื่อคุณต้องผ่านการแสดงออก

ตัวอย่างเช่นฉันมีฟังก์ชั่นที่สร้างgoogle.maps.ImageMapTypeวัตถุทั่วไปสำหรับฉัน แต่ฉันต้องบอกสูตรว่ามันควรสร้าง URL แบบเรียงต่อจากพารามิเตอร์zoomและcoordพารามิเตอร์อย่างไร:

my_func({
    name: "OSM",
    tileURLexpr: '"http://tile.openstreetmap.org/"+b+"/"+a.x+"/"+a.y+".png"',
    ...
});

function my_func(opts)
{
    return new google.maps.ImageMapType({
        getTileUrl: function (coord, zoom) {
            var b = zoom;
            var a = coord;
            return eval(opts.tileURLexpr);
        },
        ....
    });
}

ตัวอย่างของฉันของการใช้eval: นำเข้า

มันเป็นเรื่องปกติ

var components = require('components');
var Button = components.Button;
var ComboBox = components.ComboBox;
var CheckBox = components.CheckBox;
...
// That quickly gets very boring

แต่ด้วยความช่วยเหลือevalและฟังก์ชั่นผู้ช่วยเล็กน้อยมันจึงดูดีขึ้นมาก:

var components = require('components');
eval(importable('components', 'Button', 'ComboBox', 'CheckBox', ...));

importable อาจมีลักษณะ (รุ่นนี้ไม่รองรับการนำเข้าสมาชิกที่เป็นรูปธรรม)

function importable(path) {
    var name;
    var pkg = eval(path);
    var result = '\n';

    for (name in pkg) {
        result += 'if (name !== undefined) throw "import error: name already exists";\n'.replace(/name/g, name);
    }

    for (name in pkg) {
        result += 'var name = path.name;\n'.replace(/name/g, name).replace('path', path);
    }
    return result;
}

Eval ไม่ใช่ความชั่วร้ายเพียงแค่ใช้ในทางที่ผิด

หากคุณสร้างรหัสที่จะเข้าไปหรือเชื่อถือได้มันก็ไม่เป็นไร ผู้คนกำลังพูดถึงเกี่ยวกับวิธีการป้อนข้อมูลของผู้ใช้ไม่สำคัญกับการประเมินผล เรียงกันของ ~

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

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

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

ตอนนี้เป็นตัวอย่างที่ดีของการใช้ eval เซิร์ฟเวอร์ของคุณกำลังอ่านไฟล์ swagger ที่คุณสร้างขึ้น หลาย params URL {myParam}ที่ถูกสร้างขึ้นในรูปแบบ ดังนั้นคุณจึงต้องการอ่าน URL แล้วแปลงเป็นสตริงแม่แบบโดยไม่ต้องทำการเปลี่ยนที่ซับซ้อนเพราะคุณมีจุดปลายจำนวนมาก ดังนั้นคุณอาจทำอะไรแบบนี้ หมายเหตุนี่เป็นตัวอย่างที่ง่ายมาก

const params = { id: 5 };

const route = '/api/user/{id}';
route.replace(/{/g, '${params.');

// use eval(route); to do something

การสร้างรหัส ผมเพิ่งเขียนห้องสมุดที่เรียกว่าHyperbarsซึ่งเชื่อมช่องว่างระหว่างเสมือน Domและแฮนด์ มันทำได้โดยการแยกแม่แบบแฮนด์บาร์และแปลงเป็นตัวพิมพ์ใหญ่ ตัวสร้างไฮเปอร์สเปคทีฟเป็นสตริงก่อนและก่อนที่จะส่งคืนeval()มันจะเปลี่ยนเป็นรหัสที่ปฏิบัติการได้ ฉันได้พบeval()ในสถานการณ์นี้ตรงข้ามกับความชั่วร้าย

โดยทั่วไปจาก

<div>
    {{#each names}}
        <span>{{this}}</span>
    {{/each}}
</div>

สำหรับสิ่งนี้

(function (state) {
    var Runtime = Hyperbars.Runtime;
    var context = state;
    return h('div', {}, [Runtime.each(context['names'], context, function (context, parent, options) {
        return [h('span', {}, [options['@index'], context])]
    })])
}.bind({}))

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

คุณสามารถดูวิธีการสร้างรหัสก็ประสบความสำเร็จถ้าคุณอยากรู้ที่นี่

ความเชื่อของฉันคือ eval เป็นฟังก์ชั่นที่ทรงพลังมากสำหรับเว็บแอปพลิเคชันฝั่งไคลเอ็นต์และปลอดภัย ... ปลอดภัยเหมือน JavaScript ซึ่งไม่ใช่ :-) ปัญหาด้านความปลอดภัยเป็นปัญหาด้านเซิร์ฟเวอร์เพราะตอนนี้ด้วยเครื่องมือเช่น Firebug คุณสามารถโจมตีแอปพลิเคชัน JavaScript ใด ๆ

Eval มีประโยชน์สำหรับการสร้างรหัสเมื่อคุณไม่มีมาโคร

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

เมื่อคุณแยกวิเคราะห์โครงสร้าง JSON ด้วยฟังก์ชันการแยกวิเคราะห์ (ตัวอย่างเช่น jQuery.parseJSON) มันคาดว่าโครงสร้างที่สมบูรณ์แบบของไฟล์ JSON (ชื่อคุณสมบัติแต่ละชื่ออยู่ในเครื่องหมายคำพูดคู่) อย่างไรก็ตาม JavaScript มีความยืดหยุ่นมากกว่า ดังนั้นคุณสามารถใช้ eval () เพื่อหลีกเลี่ยงได้