มีกรณีที่ชาญฉลาดของการแก้ไขโค้ดรันไทม์หรือไม่?

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

ระบบปฏิบัติการสมัยใหม่ดูเหมือนจะขมวดคิ้วกับโปรแกรมที่ทำเช่นนี้เนื่องจากไวรัสใช้เทคนิคนี้เพื่อหลีกเลี่ยงการตรวจจับ

สิ่งที่ฉันคิดได้คือการเพิ่มประสิทธิภาพรันไทม์บางประเภทที่จะลบหรือเพิ่มโค้ดบางอย่างโดยรู้บางอย่างในรันไทม์ซึ่งไม่สามารถทราบได้ในเวลาคอมไพล์

มีหลายกรณีที่ถูกต้องสำหรับการแก้ไขโค้ด การสร้างรหัสในขณะทำงานจะมีประโยชน์สำหรับ:

• เครื่องเสมือนบางเครื่องใช้การคอมไพล์ JITเพื่อปรับปรุงประสิทธิภาพ
• การสร้างฟังก์ชันพิเศษได้ทันทีเป็นเรื่องปกติในคอมพิวเตอร์กราฟิก ดูเช่น Rob Pike และ Bart Locanthi และ John Reiser Hardware Software Tradeoffs สำหรับกราฟิกบิตแมปบน Blit (1984)หรือโพสต์นี้(2006)โดย Chris Lattner เกี่ยวกับการใช้ LLVM ของ Apple สำหรับความเชี่ยวชาญด้านโค้ดรันไทม์ในสแต็ก OpenGL
• ในบางกรณีซอฟต์แวร์ใช้เทคนิคที่เรียกว่าแทรมโพลีนซึ่งเกี่ยวข้องกับการสร้างโค้ดแบบไดนามิกบนสแต็ก (หรือที่อื่น) ตัวอย่างคือฟังก์ชันซ้อนของ GCC และกลไกสัญญาณของ Unices บางแห่ง

บางครั้งโค้ดจะถูกแปลเป็นโค้ดที่รันไทม์ (เรียกว่าการแปลไบนารีแบบไดนามิก ):

• อีมูเลเตอร์เช่นRosettaของ Apple ใช้เทคนิคนี้เพื่อเร่งความเร็วในการจำลอง อีกตัวอย่างหนึ่งคือ Transmeta ของซอฟต์แวร์ morphing รหัส
• ดีบักเกอร์และผู้สร้างโปรไฟล์ที่ซับซ้อนเช่นValgrindหรือPinใช้เพื่อเป็นเครื่องมือในการใช้รหัสของคุณในขณะที่กำลังดำเนินการ
• ก่อนที่จะมีการสร้างส่วนขยายให้กับชุดคำสั่ง x86 ซอฟต์แวร์เวอร์ชวลไลเซชันเช่น VMWare ไม่สามารถรันโค้ด x86 ที่มีสิทธิพิเศษภายในเครื่องเสมือนได้โดยตรง แต่ต้องแปลคำแนะนำที่มีปัญหาในทันทีให้เป็นโค้ดที่กำหนดเองที่เหมาะสมกว่า

การปรับเปลี่ยนโค้ดสามารถใช้เพื่อหลีกเลี่ยงข้อ จำกัด ของชุดคำสั่ง:

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

กรณีอื่น ๆ ของการแก้ไขโค้ด:

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

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

เหตุผลหนึ่งที่ถูกต้องคือเนื่องจากชุดคำสั่ง asm ไม่มีคำสั่งที่จำเป็นซึ่งคุณสามารถสร้างขึ้นเองได้ ตัวอย่าง: บน x86 ไม่มีวิธีสร้างอินเทอร์รัปต์ให้กับตัวแปรในรีจิสเตอร์ (เช่นทำการขัดจังหวะด้วยหมายเลขอินเทอร์รัปต์ใน ax) อนุญาตให้ใช้เฉพาะหมายเลข const ที่เข้ารหัสใน opcode เท่านั้น ด้วยการปรับรหัสด้วยตนเองเราสามารถเลียนแบบพฤติกรรมนี้ได้

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

มีหลายกรณี:

• ไวรัสมักใช้โค้ดที่แก้ไขด้วยตนเองเพื่อ "ลดความยุ่งเหยิง" โค้ดของพวกเขาก่อนที่จะดำเนินการ แต่เทคนิคนั้นยังมีประโยชน์ในการทำวิศวกรรมย้อนกลับการแคร็กและการแฮกเกอร์ที่ไม่ต้องการ
• ในบางกรณีอาจมีจุดใดจุดหนึ่งระหว่างรันไทม์ (เช่นทันทีหลังจากอ่านไฟล์กำหนดค่า) เมื่อทราบว่า - ตลอดอายุการใช้งานที่เหลือของกระบวนการสาขาใดสาขาหนึ่งจะถูกนำมาใช้เสมอหรือไม่เคย: แทนที่จะไม่จำเป็น การตรวจสอบตัวแปรบางตัวเพื่อกำหนดวิธีที่จะแยกสาขาคำสั่งของสาขาเองสามารถแก้ไขได้ตามนั้น
  • เช่นอาจเป็นที่ทราบกันดีว่าจะมีการจัดการประเภทที่ได้รับมาเพียงประเภทเดียวเท่านั้นดังนั้นการจัดส่งเสมือนสามารถถูกแทนที่ด้วยการโทรเฉพาะ
  • เมื่อตรวจพบว่าฮาร์ดแวร์ใดพร้อมใช้งานการใช้รหัสที่ตรงกันอาจเป็นฮาร์ดโค้ด
• โค้ดที่ไม่จำเป็นสามารถแทนที่ได้ด้วยคำสั่งแบบไม่ใช้งานหรือข้ามไปเลยหรือให้โค้ดถัดไปเลื่อนเข้าที่โดยตรง (ง่ายกว่าถ้าใช้ opcodes ที่ไม่ขึ้นกับตำแหน่ง)
• โค้ดที่เขียนขึ้นเพื่ออำนวยความสะดวกในการดีบักของตัวเองอาจฉีดคำสั่งกับดัก / สัญญาณ / ขัดจังหวะที่คาดว่าโดยดีบักเกอร์ในตำแหน่งยุทธศาสตร์
• นิพจน์เพรดิเคตบางอย่างที่ขึ้นอยู่กับการป้อนข้อมูลของผู้ใช้อาจถูกรวบรวมเป็นโค้ดเนทีฟโดยไลบรารี
• การแทรกการดำเนินการง่ายๆที่ไม่สามารถมองเห็นได้จนกว่าจะรันไทม์ (เช่นจากไลบรารีที่โหลดแบบไดนามิก) ...
• เพิ่มขั้นตอนการวัดด้วยตนเอง / การทำโปรไฟล์ตามเงื่อนไข
• แคร็กอาจใช้เป็นไลบรารีที่แก้ไขโค้ดที่โหลดได้ (ไม่ใช่การแก้ไขแบบ "ตัวเอง" แต่ต้องใช้เทคนิคและสิทธิ์เดียวกัน)
• ...

โมเดลการรักษาความปลอดภัยของระบบปฏิบัติการบางรุ่นหมายความว่าโค้ดที่แก้ไขได้เองไม่สามารถทำงานได้หากไม่มีสิทธิ์รูท / ผู้ดูแลระบบทำให้ไม่สามารถใช้งานได้ทั่วไป

จาก Wikipedia:

ซอฟต์แวร์แอพพลิเคชั่นที่ทำงานภายใต้ระบบปฏิบัติการที่มีการรักษาความปลอดภัย W ^ X ที่เข้มงวดไม่สามารถดำเนินการคำสั่งในหน้าที่อนุญาตให้เขียนได้เฉพาะระบบปฏิบัติการเท่านั้นที่ได้รับอนุญาตให้เขียนคำสั่งลงในหน่วยความจำและดำเนินการตามคำสั่งเหล่านั้นในภายหลัง

บนระบบปฏิบัติการดังกล่าวแม้แต่โปรแกรมเช่น Java VM ก็ต้องมีสิทธิ์รูท / ผู้ดูแลระบบเพื่อรันโค้ด JIT (ดูhttp://en.wikipedia.org/wiki/W%5EXสำหรับรายละเอียดเพิ่มเติม)

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

ใช่นั่นคือตัวอย่างของการเพิ่มประสิทธิภาพรันไทม์

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

ประเด็นของฉันการแก้ไขโค้ดด้วยตนเองอาจเป็นเรื่องที่น่ารังเกียจอย่างยิ่งในการทดสอบ / ดีบักและมักจะมีสมมติฐานที่ซ่อนอยู่เกี่ยวกับพฤติกรรมของเครื่อง (ไม่ว่าจะเป็นฮาร์ดแวร์หรือเสมือน) ยิ่งไปกว่านั้นระบบไม่สามารถแชร์โค้ดเพจระหว่างเธรด / กระบวนการต่างๆที่ดำเนินการบนเครื่องมัลติคอร์ (ตอนนี้) สิ่งนี้เอาชนะประโยชน์หลายอย่างของหน่วยความจำเสมือน ฯลฯ นอกจากนี้ยังจะทำให้การเพิ่มประสิทธิภาพสาขาที่ทำในระดับฮาร์ดแวร์เป็นโมฆะ

(หมายเหตุ - ฉันไม่ได้รวม JIT ไว้ในหมวดหมู่ของรหัสที่ปรับเปลี่ยนได้เอง JIT กำลังแปลจากการแสดงรหัสหนึ่งเป็นการแสดงทางเลือก แต่ไม่ได้แก้ไขรหัส)

สรุปแล้วมันเป็นแค่ความคิดที่ไม่ดี - เรียบร้อยจริงๆคลุมเครือ แต่แย่จริงๆ

แน่นอน - ถ้าทั้งหมดที่คุณมีคือ 8080 และ ~ 512 ไบต์ของหน่วยความจำคุณอาจต้องใช้วิธีปฏิบัติดังกล่าว

จากมุมมองของเคอร์เนลระบบปฏิบัติการทุก Just In Time Compiler และ Linker Runtime จะทำการแก้ไขข้อความโปรแกรมด้วยตนเอง ตัวอย่างที่โดดเด่นคือ V8 ECMA Script Interpreter ของ Google

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

คุณรู้ไหมว่าเกาลัดรุ่นเก่าไม่มีความแตกต่างทางตรรกะระหว่างฮาร์ดแวร์และซอฟต์แวร์ ... เราสามารถพูดได้ว่าไม่มีความแตกต่างทางตรรกะระหว่างรหัสและข้อมูล

โค้ดที่ปรับเปลี่ยนได้เองคืออะไร? โค้ดที่ใส่ค่าในสตรีมการดำเนินการเพื่อให้สามารถ imterpreted ไม่ใช่เป็นข้อมูล แต่เป็นคำสั่ง แน่นอนว่ามีมุมมองทางทฤษฎีในภาษาที่ใช้งานได้ว่าไม่มีความแตกต่างกัน ฉันกำลังบอกว่าใน e สามารถทำได้อย่างตรงไปตรงมาในภาษาที่จำเป็นและคอมไพเลอร์ / ล่ามโดยไม่ต้องสันนิษฐานว่ามีสถานะเท่าเทียมกัน

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

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

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

กรณีการใช้งานหนึ่งคือไฟล์ทดสอบ EICARซึ่งเป็นไฟล์ COM ปฏิบัติการ DOS ที่ถูกต้องสำหรับการทดสอบโปรแกรมป้องกันไวรัส

X5O!P%@AP[4\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H*

ต้องใช้การแก้ไขโค้ดด้วยตนเองเนื่องจากไฟล์ปฏิบัติการต้องมีเฉพาะอักขระ ASCII ที่พิมพ์ได้ / พิมพ์ได้ในช่วง [21h-60h, 7Bh-7Dh] ซึ่ง จำกัด จำนวนคำสั่งที่เข้ารหัสได้อย่างมาก

มีการอธิบายรายละเอียดที่นี่

นอกจากนี้ยังใช้สำหรับการจัดส่งการดำเนินการจุดลอยตัวใน DOS

คอมไพเลอร์บางตัวจะปล่อยCD xxxx ตั้งแต่ 0x34-0x3B ในตำแหน่ง x87 คำแนะนำจุดลอยตัว เนื่องจากCDเป็น opcode สำหรับintคำสั่งมันจะข้ามไปที่ interrupt 34h-3Bh และเลียนแบบคำสั่งนั้นในซอฟต์แวร์หากไม่มีตัวประมวลผลร่วม x87 มิฉะนั้นตัวจัดการขัดจังหวะจะแทนที่ 2 ไบต์เหล่านั้น9B Dxเพื่อให้การดำเนินการในภายหลังถูกจัดการโดยตรงโดย x87 โดยไม่มีการจำลอง

โปรโตคอลสำหรับการจำลองจุดลอยตัว x87 ใน MS-DOS คืออะไร?

Linux Kernelมีโมดูลเคอร์เนลที่ใส่ได้ซึ่งทำเพียงแค่ว่า

Emacs ยังมีความสามารถนี้และฉันใช้มันตลอดเวลา

สิ่งใดก็ตามที่รองรับสถาปัตยกรรมปลั๊กอินแบบไดนามิกจะต้องแก้ไขโค้ดที่รันไทม์เป็นหลัก

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

สถานการณ์ที่สามารถใช้เป็นโปรแกรมการเรียนรู้ เพื่อตอบสนองต่อการป้อนข้อมูลของผู้ใช้โปรแกรมจะเรียนรู้อัลกอริทึมใหม่:

1. มันค้นหาฐานรหัสที่มีอยู่สำหรับอัลกอริทึมที่คล้ายกัน
2. หากไม่มีอัลกอริทึมที่คล้ายกันอยู่ในโค้ดเบสโปรแกรมจะเพิ่มอัลกอริทึมใหม่
3. หากมีอัลกอริทึมที่คล้ายกันโปรแกรม (อาจได้รับความช่วยเหลือจากผู้ใช้) จะปรับเปลี่ยนอัลกอริทึมที่มีอยู่เพื่อให้สามารถตอบสนองทั้งวัตถุประสงค์เก่าและวัตถุประสงค์ใหม่

มีคำถามว่าจะทำอย่างไรใน Java: อะไรคือความเป็นไปได้สำหรับการแก้ไขโค้ด Java ด้วยตนเอง?

รุ่นที่ดีที่สุดอาจเป็น Lisp Macros ซึ่งแตกต่างจากมาโคร C ซึ่งเป็นเพียงตัวประมวลผลก่อนหน้าช่วยให้คุณสามารถเข้าถึงภาษาโปรแกรมทั้งหมดได้ตลอดเวลา นี่เป็นคุณลักษณะที่ทรงพลังที่สุดในเสียงกระเพื่อมและไม่มีอยู่ในภาษาอื่น

ฉันไม่ได้เป็นผู้เชี่ยวชาญ แต่ได้รับเสียงกระเพื่อมคนหนึ่งพูดถึงเรื่องนี้! มีเหตุผลที่พวกเขากล่าวว่า Lisp เป็นภาษาที่ทรงพลังที่สุดและคนที่ฉลาดไม่ว่าพวกเขาจะพูดถูก