මුරපද සඳහා සංගීතයට වඩා වර්‍ගය [] වඩා කැමති ඇයි?

Swing දී, මුරපදය ක්ෂේත්රය ඇත getPassword()(ප්රතිලාභ char[]වෙනුවට සුපුරුදු ක) ක්රමය getText()(ප්රතිලාභ 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

නිල ලේඛනයක් උපුටා දැක්වීම සඳහා, ජාවා ගුප්ත ලේඛන ගෘහ නිර්මාණ මාර්ගෝපදේශය මෙය char[]එදිරිව Stringමුරපද ගැන (මුරපදය මත පදනම් වූ සංකේතනය ගැන, නමුත් මෙය සාමාන්‍යයෙන් මුරපද ගැන වේ):

මුරපදය එක්තරා ආකාරයක වස්තුවක එකතු කර ගබඩා කිරීම තර්කානුකූල යැයි පෙනේ java.lang.String. කෙසේ වෙතත්, මෙන්න අවවාදයයි: Objectවර්ගයේ Stringවෙනස් කළ නොහැකි ය, එනම්, String භාවිතයෙන් පසු අන්තර්ගතය වෙනස් කිරීමට (නැවත ලිවීමට) හෝ ශුන්‍ය කිරීමට ඔබට ඉඩ සලසන ක්‍රම නිර්වචනය කර නොමැත . Stringපරිශීලක මුරපද වැනි ආරක්ෂක සංවේදී තොරතුරු ගබඩා කිරීම සඳහා මෙම අංගය වස්තු නුසුදුසු කරයි . ඔබ සැමවිටම charඒ වෙනුවට ආරක්‍ෂිත සංවේදී තොරතුරු අරාව තුළ රැස් කර ගබඩා කළ යුතුය .

ජාවා ක්‍රමලේඛන භාෂාව සඳහා වන ආරක්ෂිත කේතීකරණ මාර්ගෝපදේශයේ 2-2 මාර්ගෝපදේශය, 4.0 අනුවාදය ද ඒ හා සමාන දෙයක් පවසයි (එය මුලින් ලොග් වීමේ සන්දර්භය තුළ වුවද):

මාර්ගෝපදේශ 2-2: ඉහළ සංවේදී තොරතුරු ලොග් නොකරන්න

සමාජ ආරක්ෂණ අංක (එස්එස්එන්) සහ මුරපද වැනි සමහර තොරතුරු ඉතා සංවේදී ය. මෙම තොරතුරු අවශ්‍ය ප්‍රමාණයට වඩා වැඩි කාලයක් තබා නොගත යුතුය. උදාහරණයක් ලෙස, එය ලොග් ලිපිගොනු වෙත යැවිය යුතු අතර සෙවුම් හරහා එහි පැවැත්ම හඳුනාගත නොහැක. සමහර අස්ථිර දත්ත වර්‍ග අරා වැනි විකෘති දත්ත ව්‍යුහයන් තුළ තබා ගත හැකි අතර ඒවා භාවිතයෙන් පසු නිෂ්කාශනය වේ. දත්ත ව්‍යුහයන් ඉවත් කිරීමෙන් සාමාන්‍ය ජාවා ධාවන කාල පද්ධතිවල effectiveness ලදායීතාවය අඩු වී ඇති අතර වස්තු මතකයේ විනිවිද පෙනෙන ලෙස ක්‍රමලේඛකයා වෙත ගෙන යනු ලැබේ.

මෙම මාර්ගෝපදේශයට ඔවුන් ගනුදෙනු කරන දත්ත පිළිබඳ අර්ථකථන දැනුමක් නොමැති පහළ මට්ටමේ පුස්තකාල ක්‍රියාත්මක කිරීම සහ භාවිතා කිරීම සඳහා ඇඟවුම් ද ඇත. නිදසුනක් ලෙස, පහත් මට්ටමේ නූල් විග්‍රහ කිරීමේ පුස්තකාලයක් මඟින් එය ක්‍රියාත්මක වන පෙළ ලොග් කළ හැකිය. යෙදුමක් පුස්තකාලය සමඟ SSN විග්‍රහ කළ හැකිය. ලොග් ලිපිගොනු වෙත ප්‍රවේශය ඇති පරිපාලකයින්ට SSN ලබා ගත හැකි තත්වයක් මෙය නිර්මාණය කරයි.

අක්ෂර අරා ( char[]) භාවිතයෙන් පසු සෑම අක්‍ෂරයක්ම බිංදුවට සැකසීමෙන් ඉවත් කළ හැකිය. යමෙකුට මතක රූපය කෙසේ හෝ දැකිය හැකි නම්, නූල් භාවිතා කරන්නේ නම් ඔවුන්ට සරල පා text යකින් මුරපදයක් දැකිය හැකිය, නමුත් char[]එය භාවිතා කරන්නේ නම්, 0 සමඟ දත්ත පිරිසිදු කිරීමෙන් පසු මුරපදය ආරක්ෂිත වේ.

සමහර අය විශ්වාස කරන්නේ ඔබට මුරපදය අවශ්‍ය නොවන විට එය ගබඩා කිරීමට භාවිතා කරන මතකය නැවත ලිවිය යුතු බවයි. මෙය ඔබේ පද්ධතියෙන් මුරපදය කියවීමට ප්‍රහාරකයාට ඇති කාල කවුළුව අඩු කරන අතර මෙය සිදු කිරීම සඳහා ප්‍රහාරකයාට දැනටමත් ජේවීඑම් මතකය පැහැර ගැනීමට ප්‍රමාණවත් ප්‍රවේශයක් අවශ්‍ය බව නොසලකා හරියි. එතරම් ප්‍රවේශයක් ඇති ප්‍රහාරකයෙකුට මෙය සම්පූර්ණයෙන්ම නිෂ් less ල වන ඔබගේ ප්‍රධාන සිදුවීම් අල්ලා ගත හැකිය (AFAIK, එබැවින් කරුණාකර මා වැරදියි නම් මාව නිවැරදි කරන්න).

යාවත්කාලීන කරන්න

මගේ පිළිතුර යාවත්කාලීන කළ යුතු අදහස් වලට ස්තූතියි. මුරපදයක් දෘ hard තැටියට ගොඩවිය හැකි කාලය අඩු කරන බැවින් (ඉතා) සුළු ආරක්ෂක වැඩිදියුණු කිරීමක් එකතු කළ හැකි අවස්ථා දෙකක් ඇති බව පෙනේ. තවමත් මම සිතන්නේ එය බොහෝ භාවිත අවස්ථාවන් සඳහා අධික ලෙස මරා දැමීමයි.

• ඔබේ ඉලක්ක පද්ධතිය නරක ලෙස වින්‍යාස කර ඇති අතර ඔබ එය උපකල්පනය කළ යුතු අතර ඔබ මූලික ඩම්ප් ගැන ව්‍යාකූල විය යුතුය (පද්ධති පරිපාලකයෙකු විසින් කළමනාකරණය නොකරන්නේ නම් වලංගු විය හැකිය).
• ප්‍රහාරකයා දෘඩාංග වෙත ප්‍රවේශය ලබා ගැනීමත් සමඟ දත්ත කාන්දු වීම වැළැක්වීම සඳහා ඔබේ මෘදුකාංගය ඕනෑවට වඩා ව්‍යාකූල විය යුතුය - TrueCrypt (අත්හිටුවා ඇත), VeraCrypt හෝ CipherShed වැනි දෑ භාවිතා කිරීම .

හැකි නම්, මූලික ඩම්ප් සහ ස්වප් ගොනුව අක්‍රීය කිරීමෙන් ගැටළු දෙකම ගැන සැලකිලිමත් වේ. කෙසේ වෙතත්, ඔවුන්ට පරිපාලක අයිතිවාසිකම් අවශ්‍ය වන අතර ක්‍රියාකාරීත්වය අඩු කිරීමට (භාවිතා කිරීමට අඩු මතකයක්) සහ ධාවන පද්ධතියකින් RAM අදින්න තවමත් වලංගු කාරණයක් වනු ඇත.

මෙය වලංගු යෝජනාවක් යැයි මම නොසිතමි, නමුත්, මට අවම වශයෙන් හේතුව අනුමාන කළ හැකිය.

මුරපදය මතකයේ ඇති සියලුම හෝඩුවාවන් ක්ෂණිකව හා නිසැකවම මකා දැමිය හැකි බවට වග බලා ගැනීමට පෙළඹවීම අවශ්‍ය යැයි මම සිතමි. සමඟ char[]ඔබට අරාවේ සෑම අංගයක්ම හිස් හෝ වෙනත් දෙයක් සමඟ නැවත ලිවිය හැකිය. ඔබට Stringඒ ආකාරයෙන් අභ්‍යන්තර වටිනාකම සංස්කරණය කළ නොහැක .

නමුත් එය පමණක් හොඳ පිළිතුරක් නොවේ; ඇයි පමණක් කිරීමට වග බලා ගන්න සැඳහුම නො char[]හෝ Stringගැලවී ගත කරන්නේ කෙසේද? එවිට ආරක්ෂක ගැටළුවක් නොමැත. නමුත් කාරණය වන්නේ Stringවස්තූන් intern()න්‍යායිකව සංස්කරණය කර නියත තටාකය තුළ ජීවත්ව තබා ගැනීමයි. මම හිතන්නේ char[]මෙම හැකියාව තහනම් කිරීම.

පිළිතුර දැනටමත් ලබා දී ඇත, නමුත් මම මෑතකදී සොයාගත් ගැටලුවක් ජාවා සම්මත පුස්තකාල සමඟ බෙදා ගැනීමට කැමැත්තෙමි. මුරපද නූල් char[]සෑම තැනකම ප්‍රතිස්ථාපනය කිරීම ගැන ඔවුන් දැන් විශාල සැලකිල්ලක් දක්වන අතර (ඇත්තෙන්ම එය හොඳ දෙයකි), මතකයෙන් ඉවත් කිරීමේදී වෙනත් ආරක්ෂක-විවේචනාත්මක දත්ත නොසලකා හරින බවක් පෙනේ.

මම හිතන්නේ උදා: PrivateKey පන්තිය. PKCS # 12 ගොනුවකින් ඔබ පුද්ගලික RSA යතුරක් පටවන යම් අවස්ථාවක් සලකා බලන්න. දැන් මේ අවස්ථාවේ දී, යතුරු ගොනුවට භෞතික ප්‍රවේශය නිසියාකාරව සීමා කර ඇති තාක් කල් මුරපදය මිරිකීමෙන් ඔබට උදව් නොවනු ඇත. මුරපදය වෙනුවට ඔබ කෙලින්ම යතුර ලබා ගත්තේ නම් ප්‍රහාරකයෙකු ලෙස ඔබට වඩා හොඳ වනු ඇත. අපේක්ෂිත තොරතුරු විවිධාකාරයෙන් කාන්දු විය හැකිය, මූලික ඩම්ප්, නිදොස් කිරීමේ සැසියක් හෝ හුවමාරු ලිපිගොනු උදාහරණ කිහිපයක් පමණි.

පෙනෙන ආකාරයට, PrivateKeyමතකයෙන් පුද්ගලික තොරතුරු ඉවත් කිරීමට ඔබට ඉඩ සලසන කිසිවක් නැත , මන්ද අනුරූප තොරතුරු සාදන බයිට් අතුගා දැමීමට ඔබට ඉඩ දෙන API කිසිවක් නොමැති බැවිනි.

මෙය, මෙම ලෙස නරක තත්වයක් කඩදාසි උද්ගත විය හැකි සූරා කෑ හැකි ආකාරය විස්තර කරයි.

පුද්ගලික යතුරු නිදහස් කිරීමට පෙර OpenSSL පුස්තකාලය විවේචනාත්මක මතක කොටස් නැවත ලියයි. ජාවා කසළ එකතු කරන බැවින්, ජාවා යතුරු සඳහා පුද්ගලික තොරතුරු අතුගා දැමීමට සහ අවලංගු කිරීමට අපට පැහැදිලි ක්‍රම අවශ්‍ය වනු ඇත, ඒවා යතුර භාවිතා කළ විගසම යෙදිය යුතුය.

ජෝන් ස්කීට් පවසන පරිදි, පරාවර්තනය භාවිතා කිරීම හැර වෙනත් මාර්ගයක් නොමැත.

කෙසේ වෙතත්, පරාවර්තනය ඔබට විකල්පයක් නම්, ඔබට මෙය කළ හැකිය.

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: '***********'

සටහන: GC චක්‍රයක කොටසක් ලෙස String's char [] පිටපත් කර ඇත්නම්, පෙර පිටපත මතකයේ කොතැනක හෝ තිබීමට අවස්ථාවක් තිබේ.

මෙම පැරණි පිටපත ගොඩවල් වල නොපෙන්වයි, නමුත් ඔබට ක්‍රියාවලියේ අමු මතකයට access ජු ප්‍රවේශයක් ඇත්නම් ඔබට එය දැකිය හැකිය. පොදුවේ ඔබ එවැනි ප්‍රවේශයක් ඇති කිසිවෙකුට වැළකී සිටිය යුතුය.

මේ සියල්ලම හේතු වේ, යමෙක් මුරපදයක් සඳහා String වෙනුවට char [] array එකක් තෝරා ගත යුතුය .

1. ජාවා හි නූල් වෙනස් කළ නොහැකි බැවින්, ඔබ මුරපදය සරල පා text යක් ලෙස ගබඩා කරන්නේ නම්, කසළ එකතු කරන්නා එය ඉවත් කරන තෙක් එය මතකයේ රැඳෙනු ඇත, සහ නැවත භාවිතා කිරීම සඳහා නූල් තටාකයේ භාවිතා කරන බැවින් එය නැවත භාවිතා කිරීම සඳහා ඉහළ අවස්ථාවක් තිබේ ආරක්ෂක තර්ජනයක් වන දිගු කාලයක් මතකයේ රැඳී සිටින්න.

මතක ඩම්ප් වෙත ප්‍රවේශය ඇති ඕනෑම කෙනෙකුට මුරපදය පැහැදිලි පා text යකින් සොයාගත හැකි බැවින්, ඔබ සැමවිටම සාමාන්‍ය පෙළට වඩා සංකේතාත්මක මුරපදයක් භාවිතා කළ යුතුය. නූල් වෙනස් කළ නොහැකි බැවින් නූල් වල අන්තර්ගතය වෙනස් කළ හැකි ක්‍රමයක් නැති නිසා ඕනෑම වෙනස්කමක් නව නූලක් නිපදවන අතර ඔබ වර්‍ගයක් භාවිතා කරන්නේ නම් ඔබට සියලු අංග හිස් හෝ ශුන්‍ය ලෙස සැකසිය හැකිය. එබැවින් මුරපදයක් අක්ෂර මාලාවක ගබඩා කිරීම මුරපදයක් සොරකම් කිරීමේ ආරක්ෂක අවදානම පැහැදිලිවම අඩු කරයි.

2. ජාවා විසින්ම නිර්දේශ කරනුයේ ආරක්‍ෂිත හේතූන් මත පැහැදිලි පා text යෙන් මුරපද ලබා දෙන ක්ෂය කළ getText () ක්‍රමය වෙනුවට වර්‍ගයක් ලබා දෙන JPasswordField හි getPassword () ක්‍රමය භාවිතා කිරීමයි. ජාවා කණ්ඩායමේ උපදෙස් පිළිපැදීම හා ඒවාට එරෙහිව යාම වෙනුවට ප්‍රමිතීන් පිළිපැදීම හොඳය.

3. නූල් සමඟ සෑම විටම ලොග් ගොනුවක හෝ කොන්සෝලයක සරල පෙළ මුද්‍රණය කිරීමේ අවදානමක් ඇත, නමුත් ඔබ අරාව භාවිතා කරන්නේ නම් ඔබ අරාවෙහි අන්තර්ගතය මුද්‍රණය නොකරනු ඇත, නමුත් ඒ වෙනුවට එහි මතක ස්ථානය මුද්‍රණය වේ. සැබෑ හේතුවක් නොවුනත් එය තවමත් අර්ථවත් කරයි.

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;
}

කාල ප්‍රහාර සඳහා තවත් සම්පත් කිහිපයක්:

• කාල පහරදීම් පිළිබඳ පාඩමක්
• තොරතුරු ආරක්ෂණ තොග හුවමාරුවට කාලෝචිත ප්‍රහාර පිළිබඳ සාකච්ඡාවක්
• ඇත්ත වශයෙන්ම, වේලාසන ප්‍රහාර විකිපීඩියා පිටුව

භාවිතයෙන් පසු ඔබ එය අතින් පිරිසිදු නොකරන්නේ නම්, වර්‍ග අරාව ඔබට එදිරිව එදිරිව ලබා දෙන කිසිවක් නැත, කිසිවෙකු එය කරන බව මා දැක නැත. ඉතින් මට නම් char [] vs String හි මනාපය ටිකක් අතිශයෝක්තියට නංවයි.

මෙම දෙස බලන්න _{පුළුල් ලෙස භාවිතා} වසන්තය ආරක්ෂක පුස්තකාල මෙහි සහ ඔබ ඇසීමට, - වසන්තය ආරක්ෂක යාලුවනේ අදක්ෂ හෝ අඟුරු වේ [] මුරපද පමණක් තේරුමක් නැහැ. සමහර නපුරු හැකර් ඔබේ RAM හි මතක ඩම්ප් අල්ලා ගන්නා විට ඔබ සැඟවීමට නවීන ක්‍රම භාවිතා කළත් ඔහුට / ඔහු සියලු මුරපද ලබා ගන්නා බවට වග බලා ගන්න.

කෙසේ වෙතත්, ජාවා සෑම විටම වෙනස් වන අතර, ජාවා 8 හි String Deduplication විශේෂාංගය වැනි සමහර භයානක ලක්ෂණ ඔබේ අනුදැනුමකින් තොරව String වස්තු වලට සම්බන්ධ විය හැකිය. නමුත් එය වෙනස් සංවාදයකි.

නූල් වෙනස් නොවන අතර ඒවා නිර්මාණය කිරීමෙන් පසු වෙනස් කළ නොහැක. මුරපදයක් නූලක් ලෙස සෑදීමෙන් මුරපදය වෙත සංචිතයේ හෝ සංගීත තටාකයේ අයාලේ යොමුවනු ඇත. දැන් යමෙකු ජාවා ක්‍රියාවලියේ විශාල ප්‍රමාණයක් ගෙන ප්‍රවේශමෙන් පරිලෝකනය කළහොත් ඔහුට මුරපද අනුමාන කළ හැකිය. ඇත්ත වශයෙන්ම මෙම භාවිතා නොකරන නූල් එකතු කරනු ලබන්නේ කසළ එකතු කරන නමුත් එය රඳා පවතින්නේ 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');
}

ප්‍රහාරකයාට එය භාවිතා කළ හැකි එක් අවස්ථාවක් වන්නේ කඩාවැටීමකි - ජේවීඑම් බිඳ වැටී මතක ඩම්ප් එකක් ජනනය කරන විට - ඔබට මුරපදය දැකගත හැකිය.

එය අනිෂ්ට බාහිර ප්‍රහාරකයෙකු නොවේ. මෙය අධීක්ෂණ අරමුණු සඳහා සේවාදායකයට ප්‍රවේශය ඇති සහායක පරිශීලකයෙකු විය හැකිය. ඔහුට කඩාවැටීමකට ගොස් මුරපද සොයාගත හැකිය.

කෙටි හා සෘජු පිළිතුර වනුයේ char[]විකෘති වන අතරString වස්තූන් නොමැති .

Stringsජාවා හි වෙනස් කළ නොහැකි වස්තු වේ. නිර්මාණය කිරීමෙන් පසු ඒවා වෙනස් කළ නොහැකි වන්නේ එබැවිනි. එබැවින් ඒවායේ අන්තර්ගතය මතකයෙන් ඉවත් කිරීමට ඇති එකම ක්‍රමය වන්නේ කසළ එකතු කිරීමයි. එය සිදුවන්නේ වස්තුවෙන් නිදහස් වූ මතකය නැවත ලිවීමට හැකි වූ විට පමණක් වන අතර දත්ත නැති වී යයි.

දැන් ජාවා හි කසළ එකතු කිරීම කිසිදු සහතික කළ කාල පරාසයකින් සිදු නොවේ. එමString අනුව දීර් memory කාලයක් මතකයේ රැඳී සිටිය හැකි අතර, මෙම කාලය තුළ ක්‍රියාවලියක් බිඳ වැටුණහොත්, නූලෙහි අන්තර්ගතය මතක ඩම්ප් හෝ යම් ලොගයකින් අවසන් විය හැකිය.

අක්ෂර පෙළක් සමඟ , ඔබට මුරපදය කියවිය හැකිය, ඔබට හැකි ඉක්මනින් එය සමඟ වැඩ කිරීම අවසන් කරන්න, ඉන්පසු වහාම අන්තර්ගතය වෙනස් කරන්න.

ජාවා වල නූල් වෙනස් කළ නොහැක. එබැවින් නූලක් නිර්මාණය කරන සෑම විටම එය කසළ එකතු වන තෙක් මතකයේ රැඳෙනු ඇත. එබැවින් මතකයට ප්‍රවේශය ඇති ඕනෑම කෙනෙකුට නූලෙහි වටිනාකම කියවිය හැකිය.
නූලෙහි අගය වෙනස් කර ඇත්නම් එය නව නූලක් නිර්මාණය කරයි. එබැවින් මුල් වටිනාකම සහ වෙනස් කළ අගය යන දෙකම කසළ එකතු වන තෙක් මතකයේ රැඳේ.

අක්ෂර අරාව සමඟ, මුරපදයේ අරමුණ ඉටු වූ පසු අරාවෙහි අන්තර්ගතය වෙනස් කිරීමට හෝ මකා දැමීමට හැකිය. අරාවෙහි මුල් අන්තර්ගතය වෙනස් කිරීමෙන් පසුව සහ කසළ එකතු කිරීමට පෙර පවා මතකයේ සොයාගත නොහැක.

ආරක්ෂක අවශ්‍යතා නිසා මුරපදය අක්ෂර අරාවක් ලෙස ගබඩා කිරීම වඩා හොඳය.

මේ සඳහා ඔබ නූල් භාවිතා කළ යුතුද නැතහොත් චාර් [] භාවිතා කළ යුතුද යන්න විවාදාත්මක ය. එය පරිශීලකයාට අවශ්‍ය දේ මත රඳා පවතී.

ජාවා හි නූල් වෙනස් කළ නොහැකි බැවින්, සමහරු ඔබේ නූල් හැසිරවීමට උත්සාහ කරන සෑම විටම එය නව වස්තුවක් නිර්මාණය කරන අතර පවතින නූල් වලට කිසිදු බලපෑමක් සිදු නොවේ. මුරපදයක් සංගීත භාණ්ඩයක් ලෙස ගබඩා කිරීමේ වාසියක් ලෙස මෙය දැකිය හැකි නමුත් භාවිතයෙන් පසුව පවා වස්තුව මතකයේ රැඳේ. එබැවින් යමෙකුට කෙසේ හෝ වස්තුවේ මතක ස්ථානය ලැබුනේ නම්, එම පුද්ගලයාට එම ස්ථානයේ ගබඩා කර ඇති ඔබගේ මුරපදය පහසුවෙන් සොයාගත හැකිය.

චාර් [] විකෘති වන නමුත් එය භාවිතා කිරීමෙන් පසු ක්‍රමලේඛකයාට අරාව පැහැදිලිවම පිරිසිදු කිරීමට හෝ අගයන් ඉක්මවා යාමට හැකිය. එබැවින් එය භාවිතා කිරීමෙන් පසු එය පිරිසිදු කර ඇති අතර ඔබ ගබඩා කර ඇති තොරතුරු ගැන කිසිවෙකුට දැනගත නොහැක.

ඉහත තත්වයන් මත පදනම්ව, යමෙකුට ඔවුන්ගේ අවශ්‍යතා සඳහා ස්ට්‍රිං සමඟ යා යුතුද නැතිනම් චාර් සමඟ යා යුතුද යන්න පිළිබඳ අදහසක් ලබා ගත හැකිය.

සිද්ධි නූල්:

    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