Чому для паролів char [] віддається перевагу над String?

У 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

Якщо цитувати офіційний документ, керівництво архітектури криптографії Java говорить про паролі char[]проти Stringпаролів (про шифрування на основі паролів, але, звичайно, про паролі, звичайно):

Здавалося б, логічно збирати і зберігати пароль в об'єкті типу java.lang.String. Однак ось застереження: Objects типу Stringє незмінними, тобто не існує визначених методів, які дозволять вам змінити (перезаписати) або нульовий вміст String після використання після використання. Ця функція робить Stringоб'єкти непридатними для зберігання інформації, захищеної від безпеки, наприклад паролів користувача. Ви завжди повинні збирати та зберігати інформацію, захищену від безпеки, у charмасиві.

Керівництво 2-2 Правил безпечного кодування для мови програмування Java, версія 4.0 також говорить про щось подібне (хоча це спочатку в контексті реєстрації):

Настанова 2-2: Не реєструйте високочутливу інформацію

Деякі відомості, такі як номери соціального страхування (SSN) та паролі, є дуже чутливими. Цю інформацію не слід зберігати довше, ніж це потрібно, ні там, де її бачать, навіть адміністратори. Наприклад, він не повинен надсилатися до файлів журналу, а його наявність не повинна виявлятися за допомогою пошуку. Деякі перехідні дані можуть зберігатися в змінних структурах даних, таких як масиви символів, і видалятися відразу після використання. Очищення структур даних знижує ефективність типових систем виконання Java, оскільки об'єкти прозоро переміщуються в пам'яті програмісту.

Це керівництво також має наслідки для впровадження та використання бібліотек нижчого рівня, які не мають семантичних знань щодо даних, з якими вони мають справу. Наприклад, бібліотека низького рівня розбору рядків може записувати текст, над яким вона працює. Додаток може проаналізувати SSN з бібліотекою. Це створює ситуацію, коли SSN доступні адміністраторам, які мають доступ до файлів журналу.

Масиви символів ( char[]) можна очистити після використання, встановивши кожен символ на нуль, а рядки - ні. Якщо хтось може якимось чином бачити зображення пам'яті, він може бачити пароль у простому тексті, якщо використовуються рядки, але якщо char[]вони використовуються, після очищення даних з 0-х, пароль захищено.

Деякі люди вважають, що вам доведеться перезаписати пам'ять, що використовується для зберігання пароля, як тільки він вам більше не потрібен. Це скорочує часове вікно, коли зловмисник повинен прочитати пароль з вашої системи і повністю ігнорує той факт, що зловмиснику вже потрібен достатній доступ для викрадення пам'яті JVM для цього. Зловмисник з таким великим доступом може зловити ваші ключові події, роблячи це абсолютно марним (AFAIK, тому, будь ласка, виправте мене, якщо я помиляюся).

Оновлення

Завдяки коментарям я маю оновити свою відповідь. Мабуть, є два випадки, коли це може додати (дуже) незначне поліпшення безпеки, оскільки це скорочує час, коли пароль може потрапити на жорсткий диск. І все-таки я думаю, що це надмірність для більшості випадків використання.

• Ваша цільова система може бути неправильно налаштована або ви повинні припустити, що вона є, і ви повинні бути параноїдними щодо основних дампів (може бути дійсним, якщо системами не керує адміністратор).
• Програмне забезпечення має бути надмірно параноїдальним, щоб запобігти витоку даних, коли зловмисник отримає доступ до обладнання - використовуючи такі речі, як TrueCrypt (припинено), VeraCrypt або CipherShed .

Якщо можливо, вимкнення основних скидів і файлу swap допоможе вирішити обидві проблеми. Однак вони вимагатимуть прав адміністратора і можуть знизити функціональність (менше використовувати пам'ять), а витяг оперативної пам’яті з працюючої системи все одно буде поважною проблемою.

Я не думаю, що це правильна пропозиція, але, принаймні, я можу здогадатися про причину.

Я думаю, що мотивація хоче переконатися, що ви зможете оперативно і з певністю видалити всі сліди пароля в пам'яті після його використання. З допомогою char[]ви можете перезаписати кожен елемент масиву порожнім або напевно. Ви не можете редагувати внутрішнє значення таким Stringчином.

Але це одне не є гарною відповіддю; чому б просто не переконатися, що посилання на char[]або Stringне уникне? Тоді проблем із безпекою немає. Але річ у тому, що Stringоб’єкти можна intern()редагувати теоретично і зберігати живими всередині постійного пулу. Я припускаю, що використовувати char[]таку можливість забороняє.

Відповідь вже дана, але я хотів би поділитися проблемою, яку я нещодавно виявив зі стандартними бібліотеками Java. У той час як вони дуже піклуються про заміну рядків паролів на char[]всюди (що, звичайно, це добре), але інші критично важливі для безпеки дані, здається, не помічаються, коли мова йде про очищення їх з пам'яті.

Я думаю, наприклад, про клас PrivateKey . Розглянемо сценарій, коли ви завантажите приватний ключ RSA з файлу PKCS # 12, використовуючи його для виконання певної операції. Тепер у цьому випадку нюхання пароля не допоможе вам сильно, якщо фізичний доступ до ключового файлу обмежений належним чином. Як зловмисник, вам було б набагато краще, якби ви отримали ключ безпосередньо замість пароля. Бажана інформація може бути просоченою колектором, основними дампами, сеансом налагодження або файлами swap - лише деякі приклади.

І як виявляється, ніщо не дозволяє вам очистити приватну інформацію PrivateKeyпам'яті, оскільки немає API, який дозволяє стерегти байти, які формують відповідну інформацію.

Це погана ситуація, оскільки ця стаття описує, як ця обставина може бути потенційно використана.

Наприклад, бібліотека OpenSSL перезаписує критичні розділи пам'яті до звільнення приватних ключів. Оскільки Java збирається сміттям, нам знадобляться явні методи, щоб витерти та визнати недійсними приватну інформацію для ключів Java, яку слід застосувати відразу після використання ключа.

Як констатує Джон Скіт, немає іншого способу, крім використання роздумів.

Однак якщо рефлексія - це варіант для вас, ви можете це зробити.

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

Примітка: якщо char [String's char]] було скопійовано як частину циклу GC, є ймовірність, що попередня копія знаходиться десь у пам'яті.

Ця стара копія не відображатиметься на купі, але якщо у вас є прямий доступ до необмеженої пам'яті процесу, ви можете її бачити. Взагалі слід уникати того, щоб хтось мав такий доступ.

Це все причини. Для пароля слід вибрати масив char [] замість String .

1. Оскільки Strings незмінні в Java, якщо ви зберігаєте пароль як звичайний текст, він буде доступний у пам'яті, поки збирач сміття не очистить його, а оскільки String використовується в пулі String для повторного використання, є досить великий шанс, що він буде залишаються в пам’яті на тривалий час, що становить загрозу безпеці.

Оскільки кожен, хто має доступ до дампа пам’яті, може знайти пароль у чистому тексті, це ще одна причина, що ви завжди повинні використовувати зашифрований пароль, а не звичайний текст. Оскільки рядки незмінні, то зміст рядків не може бути змінено, оскільки будь-яка зміна призведе до появи нового String, тоді як якщо ви використовуєте char [], ви все одно можете встановити всі елементи як порожні або нульові. Тому зберігання пароля в масиві символів явно зменшує ризик безпеки викрадення пароля.

2. Сама Java рекомендує використовувати метод getPassword () JPasswordField, який повертає char [], замість застарілого методу getText (), який повертає паролі в чіткому тексті із зазначенням причин безпеки. Добре дотримуватися порад команди Java та дотримуватися стандартів, а не йти проти них.

3. У String завжди є ризик друкувати звичайний текст у файлі журналу чи консолі, але якщо ви використовуєте масив, ви не будете друкувати вміст масиву, а натомість його місце в пам'яті надрукується. Хоч це і не є справжньою причиною, але все ж має сенс.

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

Ще кілька ресурсів для синхронних атак:

• Урок у часі атаки
• Дискусія про часові атаки на обмін стеком інформаційної безпеки
• І звичайно, сторінка Вікіпедії Timing Attack

Масив char не дає вам проти String, якщо ви не очищаєте його вручну після використання, і я не бачив, щоб хтось це робив. Тож для мене перевага char [] проти String трохи перебільшена.

Погляньте на _{широко розповсюджену} тут бібліотеку Spring Security і запитайте себе - невмілі хлопці Spring Security або паролі char [] просто не мають великого сенсу. Коли якийсь неприємний хакер схопить пам'ять вашої оперативної пам’яті, будьте впевнені, що він / він отримає всі паролі, навіть якщо ви використовуєте складні способи їх приховання.

Однак Java постійно змінюється, і деякі страшні функції, такі як функція дедуплікації рядків Java 8, можуть інтернувати рядкові об'єкти без вашого відома. Але це вже інша розмова.

Рядки незмінні і не можуть бути змінені після їх створення. Якщо створити пароль у вигляді рядка, це залишатиме бродячі посилання на пароль на купі або в пулі String. Тепер, якщо хтось виконує куповий процес 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');
}

Один із сценаріїв, коли зловмисник міг би це використати, - це краш-дамп - коли JVM виходить з ладу і генерує дамп пам'яті - ви зможете побачити пароль.

Це не обов'язково зловмисний зовнішній нападник. Це може бути користувач підтримки, який має доступ до сервера для моніторингу. Він міг зазирнути в аварійний збір і знайти паролі.

Короткий і прямий відповідь був би тому, що char[]він міняється, а Stringоб'єкти - ні.

Stringsна Яві - незмінні об'єкти. Ось чому вони не можуть бути змінені після створення, і тому єдиний спосіб видалення їх вмісту з пам'яті - це збирання сміття. Це буде лише тоді, коли пам'ять, звільнена об'єктом, може бути перезаписана, а дані не зникнуть.

Зараз збирання сміття на Java не відбувається в будь-який гарантований інтервал. Таким Stringчином, баночка може зберігатися в пам'яті тривалий час, і якщо процес виходить з ладу протягом цього часу, вміст рядка може потрапити в дамп пам'яті або якийсь журнал.

За допомогою масиву символів ви можете прочитати пароль, якнайшвидше закінчити роботу з ним, а потім негайно змінити вміст.

Рядок у яві непорушний. Тож щоразу, коли створюється рядок, вона залишатиметься в пам’яті, поки не буде зібрана сміття. Тож кожен, хто має доступ до пам'яті, може прочитати значення рядка.
Якщо значення рядка буде змінено, воно в кінцевому підсумку створить новий рядок. Так і вихідне значення, і змінене значення залишаються в пам'яті, поки воно не зібране сміття.

За допомогою символьного масиву вміст масиву може бути змінено або стерто, як тільки призначено призначення пароля. Оригінальний вміст масиву не знайдеться в пам'яті після його модифікації та ще до того, як починає збиратися сміття.

Через проблеми безпеки краще зберігати пароль як масив символів.

Дискусійним є питання про те, чи слід використовувати String або використовувати Char [] для цієї мети, оскільки обидва мають свої переваги та недоліки. Це залежить від того, що потрібно користувачеві.

Оскільки рядки в Java незмінні, кожен раз, коли хтось намагається маніпулювати вашим рядком, він створює новий Об'єкт, і існуючий рядок залишається незмінним. Це може розглядатися як перевага для зберігання пароля як 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