ฉันไม่ได้อยู่ในสถานการณ์ที่ข้อผิดพลาดของคอมไพเลอร์ที่เกิดจากคำหลักเหล่านี้จะช่วยฉันจากข้อผิดพลาด
ไม่มากนักที่จะบันทึกผู้สร้างแอปพลิเคชันจากข้อบกพร่องเพื่อให้ผู้เขียนห้องสมุดตัดสินใจว่าส่วนใดของการใช้งานที่พวกเขากำลังมุ่งมั่นที่จะรักษาไว้
ถ้าฉันมีห้องสมุด
class C {
public void foo() { ... }
private void fooHelper() { /* lots of complex code */ }
}
ฉันอาจต้องการเปลี่ยนfooการใช้งานและอาจเปลี่ยนไปfooHelperในทางที่รุนแรง หากกลุ่มคนตัดสินใจใช้fooHelperแม้จะมีคำเตือนทั้งหมดในเอกสารของฉันฉันก็อาจไม่สามารถทำได้
privateช่วยให้ผู้เขียนห้องสมุดแบ่งห้องสมุดออกเป็นวิธีที่สามารถจัดการได้ (และprivateคลาสผู้ช่วย) โดยไม่ต้องกลัวว่าพวกเขาจะถูกบังคับให้รักษารายละเอียดภายในเหล่านั้นไว้เป็นเวลาหลายปี
อะไรจะทำให้คุ้มค่าสำหรับคอมไพเลอร์ในการบังคับใช้การซ่อนข้อมูล?
สังเกตด้านบนใน Java privateไม่ได้บังคับใช้โดยคอมไพเลอร์ แต่โดย Java ตรวจสอบ bytecode
การสะท้อนกลับสามารถแทนที่กลไกนี้ได้หรือไม่? อะไรจะทำให้คุ้มค่าสำหรับคอมไพเลอร์ในการบังคับใช้การซ่อนข้อมูล?
ใน Java การสะท้อนไม่เพียง แต่สามารถแทนที่กลไกนี้ privateJava มีสองชนิด ชนิดprivateที่ป้องกันไม่ให้คลาสภายนอกหนึ่งเข้าถึงprivateสมาชิกนอกคลาสอื่นที่ถูกตรวจสอบโดยตัวตรวจสอบ bytecode แต่ยังprivates ที่ใช้โดยคลาสภายในผ่านวิธีการเข้าถึงแพคเกจสังเคราะห์ส่วนตัวเช่นใน
public class C {
private int i = 42;
public class B {
public void incr() { ++i; }
}
}
ตั้งแต่คลาสB(ชื่อจริง ๆC$B) ใช้iคอมไพเลอร์สร้างวิธีBการเข้าถึงสังเคราะห์ที่ช่วยให้การเข้าถึงC.iในทางที่จะผ่าน bytecode verifier น่าเสียดายเนื่องจากClassLoaderอนุญาตให้คุณสร้างคลาสจาก a byte[]จึงเป็นเรื่องง่ายที่จะได้รับสิทธิ์ส่วนตัวที่Cได้สัมผัสกับคลาสภายในโดยการสร้างคลาสใหม่ในCแพ็คเกจของซึ่งเป็นไปได้หากCไม่ได้ปิดผนึกขวด
การprivateบังคับใช้ที่เหมาะสมต้องการการประสานงานระหว่าง classloaders, ตัวตรวจสอบ bytecode และนโยบายความปลอดภัยที่สามารถป้องกันการเข้าถึงแบบไตร่ตรอง
มันสามารถใช้เพื่อป้องกันสถานะลับของชั้นเรียนจากการถูกโจมตีหรือไม่?
ใช่. "การสลายตัวแบบปลอดภัย" เป็นไปได้เมื่อโปรแกรมเมอร์สามารถทำงานร่วมกันได้ในขณะที่การรักษาคุณสมบัติความปลอดภัยของโมดูลแต่ละตัว - ฉันไม่จำเป็นต้องเชื่อถือผู้เขียนโมดูลรหัสอื่นที่จะไม่ละเมิดคุณสมบัติความปลอดภัยของโมดูลของฉัน
ภาษาที่มีความสามารถในวัตถุเช่นJoe-Eใช้การซ่อนข้อมูลและวิธีการอื่นเพื่อทำให้การย่อยสลายอย่างปลอดภัยเป็นไปได้:
Joe-E เป็นส่วนย่อยของภาษาการเขียนโปรแกรม Java ที่ออกแบบมาเพื่อสนับสนุนการเขียนโปรแกรมที่ปลอดภัยตามระเบียบวินัยความสามารถของวัตถุ Joe-E มีวัตถุประสงค์เพื่ออำนวยความสะดวกในการสร้างระบบความปลอดภัยเช่นเดียวกับการอำนวยความสะดวกในการตรวจสอบความปลอดภัยของระบบที่สร้างขึ้นใน Joe-E
กระดาษที่เชื่อมโยงจากหน้านั้นเป็นตัวอย่างของการprivateบังคับใช้ที่ทำให้เกิดการสลายตัวที่ปลอดภัย
ให้การห่อหุ้มที่ปลอดภัย
รูปที่ 1. เครื่องมือช่วยการบันทึกข้อมูลแบบผนวกเท่านั้น
public final class Log {
private final StringBuilder content;
public Log() {
content = new StringBuilder();
}
public void write(String s) {
content.append(s);
}
}
พิจารณารูปที่ 1 ซึ่งแสดงวิธีที่หนึ่งอาจสร้างเครื่องมืออำนวยความสะดวกการบันทึกต่อท้ายเท่านั้น หากส่วนที่เหลือของโปรแกรมเขียนใน Joe-E ผู้ตรวจสอบรหัสสามารถกำหนดได้ว่าสามารถเพิ่มรายการบันทึกได้เท่านั้นและไม่สามารถแก้ไขหรือลบออกได้ การตรวจสอบนี้มีประโยชน์เพราะต้องการการตรวจสอบLog
ชั้นเรียนเท่านั้นและไม่ต้องการการตรวจสอบรหัสอื่นใด ดังนั้นการตรวจสอบคุณสมบัตินี้จึงจำเป็นต้องใช้เหตุผลในท้องถิ่นเกี่ยวกับรหัสการบันทึกเท่านั้น