JNI-1: Only use JNI when necessaryT

JNI-1: Only use JNI when necessary
The easiest security measure for JNI to remember is to avoid native code whenever possible. Therefore, the first task is to identify an alternative that is implemented in Java before choosing JNI as an implementation framework. This is mainly because the development chain of writing, deploying, and maintaining native libraries will burden the entire development chain for the lifetime of the component. Attackers like native code, mainly because JNI security falls back to the security of C/C++, therefore they expect it to break first when attacking a complex application. While it may not always be possible to avoid implementing native code, it should still be kept as short as possible to minimize the attack surface.

JNI-2: Be aware of the C/C++ threat model
Although is it is not impossible to find exploitable holes in the Java layer, C/C++ coding flaws may provide attackers with a faster path towards exploitability. Native antipatterns enable memory exploits (such as heap and stack buffer overflows), but the Java runtime environment safely manages memory and performs automatic checks on access within array bounds. Furthermore, Java has no explicit pointer arithmetic. Native code requires dealing with heap resources carefully, which means that operations to allocate and free native memory require symmetry to prevent memory leaks.

JNI-3: Expect that JNI code can violate Java visibility and isolation rules
The Java runtime environment often executes untrusted code, and protection against access to unauthorized resources is a built in feature. In C/C++, private resources such as files (containing passwords and private keys), system memory (private fields) and sockets are essentially just a pointer away. Existing code may contain vulnerabilities that could be instrumented by an attacker (on older operating systems simple shellcode injection was sufficient, whereas advanced memory protections would require the attacker to apply return-oriented programming techniques). This means that C/C++ code, once successfully loaded, is not limited by the Java security policy or any visibility rules.

JNI-4: Secure your JNI implementation from the Java side
In order to prevent native code from being exposed to untrusted and unvalidated data, Java code should sanitize data before passing it to JNI methods. This is also important for application scenarios that process untrusted persistent data, such as deserialization code.

As stated in Guideline 5-3, native methods should be private and should only be accessed through Java-based wrapper methods. This allows for parameters to be validated by Java code before they are passed to native code. The following example illustrates how to validate a pair of offset and length values that are used when accessing a byte buffer. The Java-based wrapper method validates the values and checks for integer overflow before passing the values to a native method.

ผลลัพธ์ (ไทย) 1:

JNI-1: ใช้ JNI เมื่อจำเป็นเท่านั้นมาตรการรักษาความปลอดภัยที่ง่ายที่สุดสำหรับ JNI จำรหัสภาษาเมื่อใดก็ ตามที่สามารถหลีกเลี่ยงได้ ดังนั้น งานแรกคือการ ระบุทางเลือกที่ใช้ใน Java ก่อนที่จะเลือก JNI เป็นกรอบการดำเนินงาน นี้เป็นส่วนใหญ่เนื่องจากการพัฒนาห่วงโซ่ของการเขียน ปรับใช้ และการรักษาไลบรารีภาษาจะ burden โซ่ทั้งพัฒนาสำหรับอายุการใช้งานของส่วนประกอบ รหัสภาษา ชอบโจมตี เพราะความปลอดภัย JNI ฟอลส์กลับเพื่อความปลอดภัยของ C/c ++ ดังนั้นพวกเขาคาดหวังให้ตัดครั้งแรกเมื่อโจมตีแอพลิเคชันที่ซับซ้อน ในขณะที่มันอาจไม่เสมอเป็นไปได้เพื่อหลีกเลี่ยงการใช้รหัสภาษา มันควรยังคงเก็บไว้สั้นที่สุดเพื่อลดพื้นที่การโจมตีJNI-2: ระวังรูปแบบภัยคุกคาม C/c ++แม้ว่าจะไม่ไปหาหลุม exploitable ในชั้น Java, C/c ++รหัสข้อบกพร่องอาจให้ผู้โจมตี ด้วยเส้นทางเร็วกว่าไปทาง exploitability Antipatterns ท้องถิ่นใช้ประโยชน์หน่วยความจำ (เช่นฮีปและสแต็คบัฟเฟอร์โอเวอร์โฟลว์), แต่ Java รันไทม์สภาพแวดล้อมจัดการหน่วยความจำ และดำเนินการตรวจสอบโดยอัตโนมัติในการเข้าถึงภายในขอบเขตอาร์เรย์อย่างปลอดภัย นอกจากนี้ Java ได้ไม่ชัดเจนชี้ที่เลขคณิต รหัสดั้งเดิมต้องเผชิญกับกองทรัพยากรอย่างระมัดระวัง ซึ่งหมายความ ว่า การดำเนินการจัดสรร และเพิ่มหน่วยความจำเป็นต้องสมมาตรเพื่อป้องกันการรั่วไหลของหน่วยความจำJNI-3: คาดว่า JNI รหัสสามารถละเมิดกฎการมองเห็นและแยกจาวาสภาพแวดล้อมรันไทม์ Java มักดำเนินการรหัสที่ไม่น่าเชื่อถือ และป้องกันการเข้าถึงทรัพยากรไม่ถูกสร้างขึ้นในลักษณะ ใน C/c ++ ทรัพยากรส่วนตัวเช่นแฟ้ม (ประกอบด้วยคีย์ส่วนตัวและรหัสผ่าน), หน่วยความจำระบบ (เขตข้อมูลส่วนตัว) และซ็อกเก็ตได้เป็นเพียงแค่ตัวชี้ไป รหัสที่มีอยู่อาจประกอบด้วยช่องโหว่ที่สามารถ instrumented โดยผู้โจมตี (ในระบบปฏิบัติการเก่า shellcode ง่าย ฉีดก็เพียงพอ ในขณะที่หน่วยความจำที่ต้องการความคุ้มครองจะต้องมีผู้โจมตีสามารถใช้กลับมุ่งเน้นเทคนิคการเขียนโปรแกรมขั้นสูง) หมายความ ว่า รหัส C/c ++ โหลดครั้งเดียวเสร็จสมบูรณ์แล้ว ไม่ได้ถูกจำกัด โดยนโยบายความปลอดภัย Java หรือกฎใด ๆ ที่มองเห็นJNI-4: การนำไปใช้ JNI จากด้าน Java จองเพื่อป้องกันรหัสภาษาถูกเปิดเผยข้อมูลไม่น่าเชื่อถือ และ unvalidated รหัส Java ควร sanitize ข้อมูลก่อนที่จะช่วยให้วิธี JNI นี้เป็นสิ่งสำคัญสำหรับสถานการณ์ของโปรแกรมประยุกต์ที่ไม่น่าเชื่อถือข้อมูลแบบ เช่นดีซีเรียลไลซ์รหัสประมวลผลตามที่ระบุไว้ในคำแนะนำ 5-3 วิธีดั้งเดิมควรเป็นส่วนตัว และควรเท่านั้นสามารถเข้าถึงได้ผ่านวิธีการห่อโดยใช้ Java นี้ช่วยให้สำหรับพารามิเตอร์ที่จะต้องตรวจสอบตามรหัส Java ก่อนที่พวกเขาจะผ่านรหัสท้องถิ่น ตัวอย่างต่อไปนี้แสดงวิธีการตรวจสอบคู่ตรงข้ามและความยาวของค่าที่จะใช้เมื่อเข้าถึงบัฟเฟอร์ไบต์ วิธีห่อตาม Java ตรวจสอบค่า และตรวจสอบสำหรับจำนวนเต็มยาวเกินก่อนช่วยค่ากับวิธีดั้งเดิม

ผลลัพธ์ (ไทย) 3:

jni-1 : ใช้ jni เมื่อจำเป็น
ง่ายที่สุดมาตรการรักษาความปลอดภัยให้ jni จำเป็นเพื่อหลีกเลี่ยงรหัสพื้นเมืองเมื่อใดก็ตามที่เป็นไปได้ ดังนั้น ภารกิจแรกคือการระบุทางเลือกที่ดำเนินการใน Java ก่อนการเลือก jni เป็นกรอบ นี้เป็นหลักเนื่องจากการพัฒนาการใช้โซ่ของการเขียนและรักษาห้องสมุดพื้นเมืองจะเป็นภาระห่วงโซ่การพัฒนาทั้งสำหรับการใช้งานของส่วนประกอบ โจมตีเหมือนรหัสพื้นเมืองส่วนใหญ่เนื่องจากการรักษาความปลอดภัย jni อยู่ด้านหลังเพื่อความปลอดภัยของ C / C จึงคาดหวังให้มันแตกก่อนเมื่อโจมตีโปรแกรมที่ซับซ้อน ในขณะที่มันอาจจะไม่เสมอไปที่จะหลีกเลี่ยงการใช้รหัสพื้นเมือง ,มันควรจะเก็บไว้สั้นที่สุดเท่าที่จะทำได้เพื่อลดพื้นผิวโจมตี

jni-2 : ระวังของ C / C การคุกคามแบบ
ถึงแม้ว่ามันเป็นไปไม่ได้ที่จะหาช่องโหว่ใน จาวา exploitable ชั้น C / C รหัสข้อบกพร่องอาจให้เร็วขึ้น โจมตีด้วยเส้นทางสู่ exploitability . antipatterns พื้นเมืองให้ใช้หน่วยความจำ ( เช่น กอง และกองบัฟเฟอร์ล้น )แต่ Java Runtime Environment อย่างปลอดภัยจัดการหน่วยความจำโดยอัตโนมัติ และการตรวจสอบการเข้าถึงอาร์เรย์ภายในขอบเขต นอกจากนี้ java ได้ชัดเจนชี้เลขคณิต รหัสพื้นเมืองต้องจัดการกับกองทรัพยากรอย่างระมัดระวัง ซึ่งหมายความ ว่า การจัดสรรหน่วยความจำพื้นเมืองฟรีต้องสมมาตรเพื่อป้องกันการรั่วไหลของหน่วยความจำ jni-3

:คาดหวังว่า รหัส jni สามารถละเมิดกฎการแยก
Java และ Java Runtime Environment มักจะรันรหัสที่ไม่น่าเชื่อถือ และป้องกันการเข้าถึงไม่ได้รับอนุญาต คือ ทรัพยากรที่สร้างขึ้นในคุณลักษณะ ใน C / C , ทรัพยากรส่วนบุคคลเช่นไฟล์ที่มีรหัสผ่านและคีย์ส่วนตัว ) , หน่วยความจำระบบ ( ข้อมูลส่วนบุคคล ) และซ็อกเก็ตเป็นหลักก็ชี้ไปรหัสที่มีอยู่อาจมีช่องโหว่ที่อาจจะ instrumented โดยผู้โจมตี ( รุ่นเก่าระบบปฏิบัติการง่าย shellcode ฉีดก็เพียงพอ ส่วนการป้องกันหน่วยความจำขั้นสูงจะต้องโจมตีเพื่อใช้กลับมุ่งเน้นเทคนิคการเขียนโปรแกรม ) ซึ่งหมายความว่า C / C รหัส เมื่อโหลดเสร็จเรียบร้อยแล้ว ไม่ จำกัด โดยเป็นนโยบายการรักษาความปลอดภัยหรือการมองเห็นกฎ

jni-4 :การใช้ Java jni ของคุณจากด้าน
เพื่อป้องกันรหัสพื้นเมืองจากการสัมผัสกับข้อมูลที่ไม่น่าเชื่อถือ unvalidated รหัส Java ควร sanitize ข้อมูลก่อนที่จะผ่านมันวิธีการ jni . นี้ยังเป็นสิ่งสำคัญสำหรับการใช้สถานการณ์ที่กระบวนการข้อมูลแบบถาวรที่ไม่น่าเชื่อถือ เช่น รหัส deserialization

ตามที่ระบุไว้ในแนวทาง 5-3 ,วิธีการดั้งเดิมควรเป็นส่วนบุคคลและควรจะเข้าถึงได้ผ่านทางจาวา ตามวิธี กระดาษห่อ นี้จะช่วยให้สำหรับพารามิเตอร์ที่จะถูกตรวจสอบโดยรหัสก่อนที่จะถูกส่งผ่านไปยังรหัสพื้นเมือง . ตัวอย่างต่อไปนี้แสดงวิธีการตรวจสอบคู่ของค่า offset และความยาวที่ใช้เมื่อเข้าถึงไบต์บัฟเฟอร์ชวาใช้วิธีห่อตรวจสอบค่าและตรวจสอบล้นเต็มก่อนที่จะส่งค่าไปยังวิธีพื้นเมือง