เพราะเหตุใดอักขระ char [] จึงนิยมใช้ String สำหรับรหัสผ่าน

ใน Swing ฟิลด์รหัสผ่านมีเมธอดgetPassword()(return char[]) แทนที่จะเป็นเมธอดปกติgetText()(return String) ในทำนองเดียวกันฉันเจอข้อเสนอแนะที่จะไม่ใช้Stringในการจัดการรหัสผ่าน

เหตุใดจึงStringเป็นภัยคุกคามต่อความปลอดภัยเมื่อต้องใช้รหัสผ่าน char[]มันให้ความรู้สึกไม่สะดวกในการใช้งาน

สตริงจะไม่เปลี่ยนรูป ซึ่งหมายความว่าเมื่อคุณสร้างขึ้นStringแล้วหากกระบวนการอื่นสามารถถ่ายโอนข้อมูลหน่วยความจำได้ไม่มีทาง (นอกเหนือจากการไตร่ตรอง ) คุณสามารถกำจัดข้อมูลก่อนที่การรวบรวมขยะจะเริ่มขึ้น

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

ใช่แล้วนี่เป็นข้อกังวลด้านความปลอดภัย - แต่ถึงแม้จะใช้char[]เพียงแค่ลดโอกาสในการโจมตีของผู้โจมตีและจะใช้สำหรับการโจมตีประเภทนี้โดยเฉพาะเท่านั้น

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

ในขณะที่คำแนะนำอื่น ๆ ที่นี่ดูเหมือนถูกต้อง แต่ก็มีอีกเหตุผลที่ดี ด้วยธรรมดาStringคุณมีโอกาสสูงมากในการพิมพ์รหัสผ่านไปยังบันทึกตรวจสอบหรือสถานที่ที่ไม่ปลอดภัยอื่น ๆ โดยไม่ตั้งใจ char[]มีความเสี่ยงน้อยกว่า

พิจารณาสิ่งนี้:

public static void main(String[] args) {
    Object pw = "Password";
    System.out.println("String: " + pw);

    pw = "Password".toCharArray();
    System.out.println("Array: " + pw);
}

พิมพ์:

String: Password
Array: [C@5829428e

หากต้องการอ้างอิงเอกสารอย่างเป็นทางการคู่มือสถาปัตยกรรม Java Cryptographyกล่าวถึงเรื่องนี้char[]กับStringรหัสผ่าน (เกี่ยวกับการเข้ารหัสด้วยรหัสผ่าน แต่นี่เป็นเรื่องปกติเกี่ยวกับรหัสผ่านของหลักสูตร):

java.lang.Stringมันจะดูเหมือนตรรกะที่จะรวบรวมและจัดเก็บรหัสผ่านในวัตถุของการพิมพ์ อย่างไรก็ตามนี่คือ caveat: Objects ชนิดStringไม่เปลี่ยนรูปนั่นคือไม่มีวิธีการที่กำหนดไว้เพื่อให้คุณสามารถเปลี่ยน (เขียนทับ) หรือลบเนื้อหาของ a String หลังการใช้งาน คุณสมบัตินี้ทำให้Stringวัตถุไม่เหมาะสมสำหรับการจัดเก็บข้อมูลความปลอดภัยเช่นรหัสผ่านผู้ใช้ คุณควรรวบรวมและจัดเก็บข้อมูลที่สำคัญด้านความปลอดภัยใน charอาเรย์แทน

Guideline 2-2 ของแนวทางการเข้ารหัสที่ปลอดภัยสำหรับภาษาการเขียนโปรแกรม Java เวอร์ชัน 4.0ยังกล่าวถึงบางสิ่งที่คล้ายกัน (แม้ว่าจะอยู่ในบริบทของการบันทึก):

หลักเกณฑ์ 2-2: อย่าบันทึกข้อมูลที่มีความอ่อนไหวสูง

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

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

สามารถใช้อักขระอาร์เรย์ ( char[]) หลังจากการใช้งานโดยตั้งค่าอักขระแต่ละตัวให้เป็นศูนย์และไม่ใช้สตริง หากใครบางคนสามารถเห็นภาพหน่วยความจำพวกเขาสามารถเห็นรหัสผ่านในรูปแบบข้อความธรรมดาหากมีการใช้ Strings แต่ถ้าchar[]ใช้หลังจากล้างข้อมูลด้วย 0 แล้วรหัสผ่านจะปลอดภัย

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

ปรับปรุง

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

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

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

ฉันไม่คิดว่านี่เป็นข้อเสนอแนะที่ถูกต้อง แต่อย่างน้อยฉันก็สามารถเดาได้ด้วยเหตุผล

ฉันคิดว่าแรงจูงใจต้องการให้แน่ใจว่าคุณสามารถลบการติดตามทั้งหมดของรหัสผ่านในหน่วยความจำทันทีและด้วยความมั่นใจหลังจากใช้งาน ด้วยchar[]คุณสามารถเขียนทับแต่ละองค์ประกอบของอาร์เรย์ด้วยช่องว่างหรือบางสิ่งบางอย่างได้อย่างแน่นอน คุณไม่สามารถแก้ไขค่าภายในของStringวิธีนั้นได้

แต่นั่นไม่ใช่คำตอบที่ดีเพียงอย่างเดียว ทำไมไม่ให้แน่ใจว่ามีการอ้างอิงถึงchar[]หรือStringไม่หลบหนี จากนั้นไม่มีปัญหาด้านความปลอดภัย แต่สิ่งนี้คือStringวัตถุสามารถถูกแก้ไขได้intern()ในทางทฤษฎีและมีชีวิตอยู่ภายในสระว่ายน้ำคงที่ ฉันคิดว่าใช้char[]ความเป็นไปได้นี้ห้าม

ได้รับคำตอบแล้ว แต่ฉันต้องการแบ่งปันปัญหาที่ฉันค้นพบเมื่อเร็ว ๆ นี้กับไลบรารีมาตรฐาน Java ในขณะที่พวกเขาใช้ความระมัดระวังอย่างมากในการแทนที่สตริงรหัสผ่านด้วยchar[]ทุกที่ (ซึ่งแน่นอนว่าเป็นสิ่งที่ดี) ข้อมูลด้านความปลอดภัยที่สำคัญอื่น ๆ ดูเหมือนว่าจะถูกมองข้ามเมื่อพูดถึงการล้างข้อมูลออกจากหน่วยความจำ

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

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

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

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

ในฐานะที่เป็น Jon Skeet รัฐไม่มีทางยกเว้นโดยใช้การสะท้อน

อย่างไรก็ตามหากการสะท้อนกลับเป็นตัวเลือกสำหรับคุณคุณสามารถทำได้

public static void main(String[] args) {
    System.out.println("please enter a password");
    // don't actually do this, this is an example only.
    Scanner in = new Scanner(System.in);
    String password = in.nextLine();
    usePassword(password);

    clearString(password);

    System.out.println("password: '" + password + "'");
}

private static void usePassword(String password) {

}

private static void clearString(String password) {
    try {
        Field value = String.class.getDeclaredField("value");
        value.setAccessible(true);
        char[] chars = (char[]) value.get(password);
        Arrays.fill(chars, '*');
    } catch (Exception e) {
        throw new AssertionError(e);
    }
}

เมื่อวิ่ง

please enter a password
hello world
password: '***********'

หมายเหตุ: หากอักขระของ String [] ถูกคัดลอกเป็นส่วนหนึ่งของวงจร GC อาจมีโอกาสที่สำเนาก่อนหน้าจะอยู่ในหน่วยความจำ

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

นี่คือเหตุผลทั้งหมดที่ควรเลือกอาร์เรย์[]แทนที่จะเป็นสตริงสำหรับรหัสผ่าน

1. Strings นั้นไม่เปลี่ยนรูปแบบใน Java ถ้าคุณเก็บรหัสผ่านเป็นข้อความธรรมดามันจะมีอยู่ในหน่วยความจำจนกว่า Garbage Collector จะล้างมันและเนื่องจาก String ถูกใช้ใน Pool pool เพื่อให้สามารถนำมาใช้ใหม่ได้ ยังคงอยู่ในหน่วยความจำเป็นเวลานานซึ่งก่อให้เกิดภัยคุกคามความปลอดภัย

เนื่องจากทุกคนที่สามารถเข้าถึงการถ่ายโอนข้อมูลหน่วยความจำสามารถค้นหารหัสผ่านในข้อความที่ชัดเจนนั่นเป็นอีกเหตุผลหนึ่งที่คุณควรใช้รหัสผ่านที่เข้ารหัสแทนที่จะเป็นข้อความธรรมดา เนื่องจาก Strings ไม่สามารถเปลี่ยนแปลงได้จึงไม่มีทางที่เนื้อหาของ Strings สามารถเปลี่ยนแปลงได้เนื่องจากการเปลี่ยนแปลงใด ๆ ที่จะสร้างสตริงใหม่ในขณะที่ถ้าคุณใช้อักขระ [] คุณยังคงสามารถตั้งค่าองค์ประกอบทั้งหมดเป็นค่าว่างหรือเป็นศูนย์ได้ ดังนั้นการจัดเก็บรหัสผ่านในอาเรย์อักขระจะช่วยลดความเสี่ยงด้านความปลอดภัยในการขโมยรหัสผ่านได้อย่างชัดเจน

2. Java แนะนำให้ใช้เมธอด getPassword () ของ JPasswordField ซึ่งส่งคืนอักขระ char [] แทนเมธอด getText () ที่เลิกใช้แล้วซึ่งส่งคืนรหัสผ่านในรูปแบบข้อความที่ชัดเจนด้วยเหตุผลด้านความปลอดภัย เป็นการดีที่จะทำตามคำแนะนำจากทีม Java และยึดมั่นในมาตรฐานแทนที่จะไปเทียบกับพวกเขา

3. ด้วย String จะมีความเสี่ยงในการพิมพ์ข้อความธรรมดาในล็อกไฟล์หรือคอนโซล แต่ถ้าคุณใช้ Array คุณจะไม่พิมพ์เนื้อหาของอาเรย์ แต่จะมีการพิมพ์ตำแหน่งหน่วยความจำแทน แม้ว่าจะไม่ใช่เหตุผลที่แท้จริง แต่ก็ยังสมเหตุสมผล

String strPassword="Unknown";
char[] charPassword= new char[]{'U','n','k','w','o','n'};
System.out.println("String password: " + strPassword);
System.out.println("Character password: " + charPassword);

String password: Unknown
Character password: [C@110b053

อ้างอิงจากบล็อกนี้ ฉันหวังว่านี่จะช่วยได้.

แก้ไข:กลับมาที่คำตอบนี้หลังจากหนึ่งปีของการวิจัยความปลอดภัยฉันรู้ว่ามันทำให้เกิดความโชคร้ายที่คุณจะเปรียบเทียบรหัสผ่านธรรมดา โปรดอย่า ใช้กัญชาหนึ่งในวิธีการที่ปลอดภัยด้วยเกลือและจำนวนที่เหมาะสมของการทำซ้ำ ลองใช้ห้องสมุด: สิ่งนี้ยากที่จะเข้าใจ!

คำตอบเดิม:อะไรคือความจริงที่ว่า String.equals () ใช้การประเมินผลแบบลัดวงจรและดังนั้นจึงมีความเสี่ยงต่อการถูกโจมตีด้วยจังหวะ? อาจไม่น่าเป็นไปได้ แต่คุณสามารถใช้เวลาในการเปรียบเทียบรหัสผ่านในทางทฤษฎีเพื่อกำหนดลำดับอักขระที่ถูกต้อง

public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        // Quits here if Strings are different lengths.
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            // Quits here at first different character.
            while (n-- != 0) {
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

แหล่งข้อมูลเพิ่มเติมเกี่ยวกับการโจมตีเวลา:

• บทเรียนในการโจมตีเวลา
• การอภิปรายเกี่ยวกับการโจมตีเวลาใน Information Security Stack Exchange
• และแน่นอนหน้าTiming Attack Wikipedia

ไม่มีสิ่งใดที่อาร์เรย์ char จะให้คุณเทียบกับสตริงเว้นแต่คุณจะล้างข้อมูลด้วยตนเองหลังการใช้งานและฉันไม่ได้เห็นใครทำเช่นนั้น ดังนั้นสำหรับฉันความชอบของ char [] vs String นั้นค่อนข้างโอ้อวดไปหน่อย

ลองดูที่ห้องสมุด Spring Security ที่_{ใช้กันอย่างแพร่หลาย}ที่นี่และถามตัวเอง - รหัสผ่านของ Spring Security ไม่สามารถใช้งานได้หรือใช้รหัสผ่าน [ถ่าน] ก็ไม่สมเหตุสมผล เมื่อแฮกเกอร์ที่น่ารังเกียจบางคนคว้าหน่วยความจำของแรมของคุณให้แน่ใจว่าเขา / เธอจะได้รับรหัสผ่านทั้งหมดแม้ว่าคุณจะใช้วิธีการที่ซับซ้อนเพื่อซ่อนพวกเขา

อย่างไรก็ตาม Java เปลี่ยนแปลงตลอดเวลาและคุณสมบัติบางอย่างที่น่ากลัวเช่นคุณลักษณะการคัดลอกสตริงของ Java 8อาจฝึกงานกับวัตถุสตริงโดยที่คุณไม่ทราบ แต่นั่นคือการสนทนาที่แตกต่างกัน

สตริงไม่สามารถเปลี่ยนแปลงได้และไม่สามารถเปลี่ยนแปลงได้เมื่อสร้างขึ้นแล้ว การสร้างรหัสผ่านเป็นสตริงจะทำให้การอ้างอิงหลงทางไปยังรหัสผ่านบนฮีปหรือในพูลสตริ ตอนนี้ถ้ามีใครสักคนจัดการกองของกระบวนการ Java และทำการตรวจสอบอย่างรอบคอบเขาอาจเดารหัสผ่านได้ แน่นอนว่าสายอักขระที่ไม่ได้ใช้งานจะถูกเก็บรวบรวมขยะ แต่ขึ้นอยู่กับว่าเมื่อใดที่ GC เข้ามา

ในอีกด้านหนึ่งอักขระ char [] สามารถเปลี่ยนแปลงได้ทันทีที่การตรวจสอบสิทธิ์เสร็จสิ้นคุณสามารถเขียนทับอักขระเหล่านั้นด้วยอักขระใด ๆ เช่น M หรือแบ็กสแลชทั้งหมด ตอนนี้แม้ว่าบางคนใช้การถ่ายโอนข้อมูลฮีปเขาอาจไม่สามารถรับรหัสผ่านที่ไม่ได้ใช้งานอยู่ในปัจจุบัน สิ่งนี้ช่วยให้คุณสามารถควบคุมได้มากขึ้นเช่นการล้างเนื้อหาวัตถุด้วยตัวคุณเองและรอให้ GC ทำเช่นนั้น

สตริงไม่เปลี่ยนรูปและมันจะไปที่สระว่ายน้ำสตริง เมื่อเขียนแล้วจะไม่สามารถเขียนทับได้

char[] เป็นอาร์เรย์ที่คุณควรเขียนทับเมื่อคุณใช้รหัสผ่านและนี่คือวิธีการทำ:

char[] passw = request.getPassword().toCharArray()
if (comparePasswords(dbPassword, passw) {
 allowUser = true;
 cleanPassword(passw);
 cleanPassword(dbPassword);
 passw=null;
}

private static void cleanPassword (char[] pass) {

Arrays.fill(pass, '0');
}

สถานการณ์หนึ่งที่ผู้โจมตีสามารถใช้งานได้คือ crashdump - เมื่อ JVM หยุดทำงานและสร้างการถ่ายโอนข้อมูลหน่วยความจำ - คุณจะสามารถดูรหัสผ่านได้

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

คำตอบสั้น ๆ และตรงไปตรงมาอาจเป็นเพราะchar[]ไม่แน่นอนในขณะที่Stringวัตถุไม่ได้

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

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

ด้วยอาร์เรย์อักขระคุณสามารถอ่านรหัสผ่านทำงานกับมันให้เสร็จโดยเร็วที่สุดจากนั้นจึงเปลี่ยนเนื้อหาทันที

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

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

เนื่องจากข้อกังวลด้านความปลอดภัยจึงเป็นการดีกว่าที่จะเก็บรหัสผ่านเป็นอาเรย์อักขระ

เป็นที่ถกเถียงกันว่าคุณควรใช้ String หรือใช้ Char [] เพื่อจุดประสงค์นี้เพราะทั้งคู่มีข้อดีและข้อเสีย ขึ้นอยู่กับสิ่งที่ผู้ใช้ต้องการ

เนื่องจาก Strings ใน Java นั้นไม่เปลี่ยนรูปเมื่อใดก็ตามที่บางคนพยายามจัดการสตริงของคุณมันจะสร้าง Object ใหม่และ String ที่มีอยู่จะไม่ได้รับผล สิ่งนี้อาจถูกมองว่าเป็นข้อดีสำหรับการจัดเก็บรหัสผ่านเป็นสตริง แต่วัตถุยังคงอยู่ในหน่วยความจำแม้หลังการใช้งาน ดังนั้นหากใครก็ตามได้ตำแหน่งหน่วยความจำของวัตถุบุคคลนั้นสามารถติดตามรหัสผ่านของคุณที่เก็บไว้ในตำแหน่งนั้นได้อย่างง่ายดาย

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

จากสถานการณ์ข้างต้นเราสามารถทราบได้ว่าจะไปกับ String หรือไปกับ Char [] สำหรับความต้องการของพวกเขา

สตริงตัวเรือน:

    String password = "ill stay in StringPool after Death !!!";
    // some long code goes
    // ...Now I want to remove traces of password
    password = null;
    password = "";
    // above attempts wil change value of password
    // but the actual password can be traced from String pool through memory dump, if not garbage collected

เคส CHAR ARRAY:

    char[] passArray = {'p','a','s','s','w','o','r','d'};
    // some long code goes
    // ...Now I want to remove traces of password
    for (int i=0; i<passArray.length;i++){
        passArray[i] = 'x';
    }
    // Now you ACTUALLY DESTROYED traces of password form memory