Neden parolalar için karakter dizisi yerine char [] tercih edilir?

Swing'de şifre alanında bir getPassword() (döner char[]yerine her zamanki) yöntemine getText()(döner String) yöntemiyle. Benzer şekilde, Stringşifreleri işlemek için kullanmama önerisine de rastladım .

StringParolalar söz konusu olduğunda neden güvenlik için bir tehdit oluşturuyor? Kullanmak zor geliyorchar[] .

Teller değişmez . Bu String, başka bir işlem belleği dökebiliyorsa, çöp toplanmadan önce verilerinden kurtulmanın ( yansıma dışında ) hiçbir yolu olmadığı anlamına gelir. içinde tekme.

Bir diziyle, işiniz bittikten sonra verileri açıkça silebilirsiniz. İstediğiniz herhangi bir şeyle dizinin üzerine yazabilirsiniz ve parola çöp toplama işleminden önce bile sistemin herhangi bir yerinde bulunmaz.

Yani evet, bu ise bir güvenlik endişesi - ancak bu bile kullanarak char[]sadece bir saldırganın fırsat penceresi azaltır ve sadece saldırı bu özel tip için.

Yorumlarda belirtildiği gibi, çöp toplayıcı tarafından taşınan dizilerin verilerin kopyalarını hafızada bırakması mümkündür. Ben bu gerçeklenime özel inanıyoruz - Çöp toplayıcı olabilir gidiyor, bütün hafızayı temizlemek bu tür bir şey önlemek için. Olsa bile char[], gerçek karakterleri bir saldırı penceresi olarak içeren zaman vardır .

Buradaki diğer öneriler geçerli görünse de, bir başka iyi neden daha var. Plain ile parolayı yanlışlıkla günlüklere , monitörlere veya başka bir güvensiz yere basmaString şansınız çok daha yüksektir . daha az savunmasızdır.char[]

Bunu düşün:

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

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

Baskılar:

String: Password
Array: [C@5829428e

Resmi bir belge alıntı için, Java Kriptografi Mimarlık kılavuzu hakkında şunları söyler char[]vs String(şifre tabanlı şifreleme hakkında, ancak bu elbette şifreler hakkında daha genel olarak) şifreleri:

Şifreyi tür bir nesnede toplamak ve saklamak mantıklı görünebilir java.lang.String . Ancak, burada bir uyarıdır: ObjectÇeşidi ler Stringbir içeriklerinden dışarı değişikliği (üzerine yazma) ya da sıfır sizi izin tanımlı hiçbir yöntem vardır, yani iletmenin String kullanıldıktan sonra. Bu özellik, Stringnesneleri kullanıcı parolaları gibi güvenliğe duyarlı bilgileri depolamak için uygun hale getirmez. Bunun yerine her zaman güvenliğe duyarlı bilgileri bir chardizide toplayıp saklamanız gerekir .

Sürüm 4.0, Java Programlama Dili için Güvenli Kodlama Yönergeleri, Sürüm 4.0'da da benzer bir şey söylüyor (başlangıçta günlük kaydı bağlamında olmasına rağmen):

Yönerge 2-2: Çok hassas bilgileri günlüğe kaydetme

Sosyal Güvenlik numaraları (SSN'ler) ve şifreler gibi bazı bilgiler son derece hassastır. Bu bilgiler, yöneticiler tarafından bile gerekenden daha uzun süre ve ne görülebileceği konusunda saklanmamalıdır. Örneğin, günlük dosyalarına gönderilmemeli ve varlığı aramalar aracılığıyla algılanmamalıdır. Bazı geçici veriler karakter dizileri gibi değişken veri yapılarında tutulabilir ve kullanımdan hemen sonra silinebilir. Veri yapılarının temizlenmesi, nesneler belleğe şeffaf bir şekilde programlayıcıya taşındığından tipik Java çalışma zamanı sistemlerinde etkinliği azaltmıştır.

Bu kılavuzda, uğraştıkları veriler hakkında anlam bilgisi bulunmayan alt düzey kitaplıkların uygulanması ve kullanımı üzerinde de etkileri vardır. Örnek olarak, düşük düzeyli bir dize ayrıştırma kitaplığı üzerinde çalıştığı metni günlüğe kaydedebilir. Bir uygulama, bir SSN'yi kitaplıkla ayrıştırabilir. Bu, SSN'lerin günlük dosyalarına erişimi olan yöneticiler tarafından kullanılabildiği bir durum oluşturur.

Karakter dizileri ( char[]) kullanımdan sonra her karakter sıfıra ayarlanarak silinebilir ve Dizeler değil. Birisi bellek görüntüsünü bir şekilde görebiliyorsa, Dizeler kullanılıyorsa düz metin olarak bir parola görebilir, ancak char[]kullanılırsa, 0'lı veriler temizlendikten sonra parola güvenlidir.

Bazı insanlar, parolayı artık gerekmediğinde saklamak için kullanılan belleğin üzerine yazmanız gerektiğine inanır. Bu, bir saldırganın sisteminizden parolayı okuması gereken zaman penceresini azaltır ve saldırganın bunu yapmak için JVM belleğini ele geçirmek için zaten yeterli erişime ihtiyacı olduğu gerçeğini tamamen yok sayar. Bu kadar erişime sahip bir saldırgan, önemli etkinliklerinizi yakalayabilir ve bu tamamen işe yaramaz hale gelir (AFAIK, bu yüzden lütfen yanılıyorsam beni düzeltin).

Güncelleme

Yorumlar sayesinde cevabımı güncellemeliyim. Görünüşe göre, bir parolanın sabit diske inme süresini azalttığı için bunun (çok) küçük bir güvenlik iyileştirmesi ekleyebileceği iki durum vardır. Yine de çoğu kullanım vakası için aşırı dolu olduğunu düşünüyorum.

• Hedef sisteminiz kötü yapılandırılmış olabilir veya sisteminizin var olduğunu ve çekirdek dökümleri konusunda paranoyak olmanız gerektiğini (sistemlerin bir yönetici tarafından yönetilmemesi durumunda geçerli olabileceğini) varsaymanız gerekir.
• Saldırganın donanıma erişmesini ( TrueCrypt (üretilmiyor), VeraCrypt veya CipherShed gibi ) kullanarak veri sızıntılarını önlemek için yazılımınızın aşırı paranoyak olması gerekir .

Mümkünse, çekirdek dökümlerini ve takas dosyasını devre dışı bırakmak her iki sorunu da halleder. Bununla birlikte, yönetici hakları gerektirirler ve işlevselliği azaltabilir (kullanılacak daha az bellek) ve çalışan bir sistemden RAM almak hala geçerli bir endişe kaynağı olacaktır.

Bunun geçerli bir öneri olduğunu düşünmüyorum, ama en azından sebebini tahmin edebiliyorum.

Bence motivasyon şifre kullanıldıktan sonra derhal ve kesin olarak parola tüm izini silmek emin olmak istiyor. Bir ile char[]dizinin her elemanının üzerine bir boşluk veya kesin bir şey yazabilirsiniz. Bu şekilde dahili değerini düzenleyemezsiniz String.

Ancak bu tek başına iyi bir cevap değildir; neden sadece bir referansın kaçmamasını char[]veya Stringkaçmamasını sağlamak değil? Güvenlik sorunu yok. Ama mesele şu ki, Stringnesneler intern()teoride edinebilir ve sabit havuzun içinde hayatta kalabilirler . Sanırım char[]bu olasılığı yasaklıyor.

Yanıt zaten verildi, ancak son zamanlarda keşfettiğim bir sorunu Java standart kitaplıklarıyla paylaşmak istiyorum. Artık şifre dizelerini değiştirmekle çok ilgilenirken,char[] her yerle (elbette iyi bir şeydir) , güvenlik açısından kritik olan diğer veriler, bellekten temizlenmesi söz konusu olduğunda gözden kaçıyor gibi görünüyor.

Örneğin PrivateKey sınıfını . Bazı işlemleri gerçekleştirmek için PKCS # 12 dosyasından özel RSA anahtarını yükleyeceğiniz bir senaryo düşünün. Şimdi bu durumda, yalnızca şifrenin koklanması, anahtar dosyaya fiziksel erişim düzgün bir şekilde kısıtlandığı sürece size yardımcı olmaz. Saldırgan olarak, anahtarı doğrudan şifre yerine ederseniz çok daha iyi durumda olursunuz. İstenilen bilgiler sızdırılabilir manifold, çekirdek dökümleri, bir hata ayıklayıcı oturumu veya takas dosyaları sadece bazı örneklerdir.

Ve ortaya çıktığı gibi PrivateKey, ilgili bilgileri oluşturan baytları silmenizi sağlayan bir API olmadığından, a'nın özel bilgilerini bellekten silmenize izin veren hiçbir şey yoktur.

Bu makalede , bu durumun potansiyel olarak nasıl kullanılabileceği açıklandığı için bu kötü bir durumdur .

Örneğin OpenSSL kütüphanesi, özel anahtarlar serbest bırakılmadan önce kritik bellek bölümlerinin üzerine yazar. Java çöp toplandığından, Java anahtarları için özel bilgileri silmek ve geçersiz kılmak için açık yöntemler kullanmamız gerekir; bunlar, anahtarı kullandıktan hemen sonra uygulanacaktır.

Jon Skeet'in belirttiği gibi, yansıma kullanmaktan başka bir yolu yoktur.

Ancak, yansıma sizin için bir seçenekse bunu yapabilirsiniz.

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

koştuğunda

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

Not: Dizenin char [] öğesi bir GC döngüsünün parçası olarak kopyalandıysa, önceki kopyanın bellekte bir yerde olma olasılığı vardır.

Bu eski kopya bir yığın dökümünde görünmez, ancak sürecin ham belleğine doğrudan erişiminiz varsa onu görebilirsiniz. Genel olarak böyle bir erişime sahip olanlardan kaçınmalısınız.

Tüm nedenler, bir şifre için String yerine bir char [] dizisi seçmelisiniz .

1. Dizeler Java ile değiştirilemediğinden, parolayı düz metin olarak saklarsanız, Çöp toplayıcı temizlenene kadar bellekte kullanılabilir olur ve String, String havuzunda yeniden kullanılabilirlik için kullanıldığından, bir güvenlik tehdidi oluşturan uzun süre hafızada kalır.

Bellek dökümüne erişimi olan herkes parolayı düz metin olarak bulabildiğinden, bu nedenle düz metin yerine her zaman şifreli bir parola kullanmanız gerekir. Dizeler değişmez olduğu için, Dizelerin içeriğinin değiştirilmesinin bir yolu yoktur, çünkü herhangi bir değişiklik yeni bir Dize üretirken, bir char [] kullanırsanız tüm öğeleri yine de boş veya sıfır olarak ayarlayabilirsiniz. Dolayısıyla, bir şifreyi bir karakter dizisinde saklamak, bir şifreyi çalmanın güvenlik riskini açıkça azaltır.

2. Java, güvenlik nedenlerini açık bir şekilde parolaları döndüren kullanımdan kaldırılmış getText () yöntemi yerine, char [] döndüren JPasswordField öğesinin getPassword () yöntemini kullanmanızı önerir. Java ekibinin tavsiyelerine uymak ve onlara karşı olmak yerine standartlara uymak iyidir.

3. String ile her zaman bir günlük dosyasına veya konsola düz metin yazdırma riski vardır, ancak Array kullanırsanız bir dizinin içeriğini yazdırmazsınız, bunun yerine bellek konumu yazdırılır. Gerçek bir neden olmasa da, yine de mantıklı.

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

Bu blogdan referans alındı . Umarım bu yardımcı olur.

Edit: Güvenlik araştırması bir yıl sonra bu cevabı geri geliyor, ben aslında hiç düz metin şifreleri karşılaştırmak oldukça talihsiz ima yapar farkındayız. Lütfen yapma. Tuz ve makul sayıda yineleme ile güvenli tek yönlü bir karma kullanın . Bir kütüphane kullanmayı düşünün: bu işi doğru yapmak zordur!

Orijinal yanıt: String.equals () yönteminin kısa devre değerlendirmesi kullandığı ve bu nedenle bir zamanlama saldırısına karşı savunmasız olduğu gerçeğine ne dersiniz ? Bu olası olmayabilir, ancak doğru karakter sırasını belirlemek için teorik olarak şifre karşılaştırmasını zamanlayabilirsiniz.

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

Zamanlama saldırıları hakkında daha fazla kaynak:

• Zamanlama Saldırılarında Bir Ders
• Bilgi Güvenliği Yığın Değişimi'ne yönelik zaman saldırıları hakkında bir tartışma
• Ve elbette, Zamanlama Saldırısı Wikipedia sayfası

Char dizi kullanımdan sonra elle temizlemek sürece size String vs verir hiçbir şey yoktur ve ben aslında bunu yapan kimseyi görmedim. Yani bana göre char [] vs String tercihi biraz abartılı.

Bir göz atın _{yaygın olarak kullanılan} Bahar Güvenlik kütüphanesinde burada ve kendinize sorun - Bahar Güvenlik adamlar beceriksiz ya şar [] şifreleri sadece pek mantıklı değil. Bazı kötü hackerlar RAM'inizin bellek dökümlerini kaptığında, gizlemek için sofistike yollar kullansanız bile tüm şifreleri alacağından emin olun.

Bununla birlikte, Java her zaman değişir ve Java 8'in Dize Tekilleştirme özelliği gibi bazı korkunç özellikler sizin haberiniz olmadan String nesnelerini staj yapabilir. Ama bu farklı bir konuşma.

Dizeler değişmezdir ve oluşturulduktan sonra değiştirilemezler. Dize olarak bir parola oluşturmak, öbek veya Dize havuzundaki parola için başıboş başvurular bırakır. Birisi Java sürecinin yığın dökümü alır ve dikkatlice tararsa, şifreleri tahmin edebilir. Tabii ki bu kullanılmayan dizeler çöp toplanacak, ancak GC ne zaman devreye girdiğine bağlı.

Diğer tarafta char [], kimlik doğrulaması yapılır yapılmaz değiştirilebilir ve tüm M veya ters eğik çizgiler gibi herhangi bir karakterle bunların üzerine yazabilirsiniz. Birisi bir yığın dökümü alsa bile, şu anda kullanılmayan şifreleri alamayabilir. Bu, Object içeriğini kendiniz temizlemek veya GC'nin bunu yapmasını beklemek gibi anlamda daha fazla kontrol sağlar.

String değişmezdir ve string havuzuna gider. Yazıldıktan sonra üzerine yazılamaz.

char[] parolayı kullandıktan sonra üzerine yazmanız gereken bir dizidir ve şu şekilde yapılması gerekir:

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

Saldırganın kullanabileceği bir senaryo - JVM çöküp bir bellek dökümü oluşturduğunda - bir çökme dökümüdür - şifreyi görebilirsiniz.

Bu mutlaka kötü amaçlı bir harici saldırgan değildir. Bu, izleme amacıyla sunucuya erişimi olan bir destek kullanıcısı olabilir. Bir çöküşe bakabilir ve şifreleri bulabilir.

Kısa ve anlaşılır cevap, nesneler olmasa char[]da değişken olabileceğidir String.

StringsJava'da değişmez nesnelerdir. Bu yüzden bir kez oluşturulduklarında değiştirilemezler ve bu nedenle içeriklerinin bellekten kaldırılmasının tek yolu çöplerin toplanmasıdır. Ancak o zaman nesne tarafından serbest bırakılan belleğin üzerine yazılabilir ve veriler kaybolacaktır.

Artık Java'da çöp toplama herhangi bir garantili aralıkta gerçekleşmiyor. StringBöylece uzun süre hafızada sürebilen ve süreç bu süre içinde çökerse, dize içeriği bir bellek dökümü veya bazı günlüğüne sona erebilir.

Bir karakter dizisiyle şifreyi okuyabilir, mümkün olan en kısa sürede onunla çalışmayı bitirebilir ve ardından içeriği hemen değiştirebilirsiniz.

Java dizesi değişmez. Bu nedenle, bir dize oluşturulduğunda, çöp toplanana kadar bellekte kalır. Böylece, belleğe erişimi olan herkes dizenin değerini okuyabilir.
Dizenin değeri değiştirilirse, sonunda yeni bir dize oluşturulur. Böylece hem orijinal değer hem de değiştirilen değer, çöp toplanana kadar bellekte kalır.

Karakter dizisiyle, dizinin içeriği parolanın amacına ulaşıldığında değiştirilebilir veya silinebilir. Dizinin orijinal içeriği, değiştirildikten sonra ve hatta çöp toplama işlemi devreye girmeden önce bellekte bulunmaz.

Güvenlik nedeniyle, şifreyi bir karakter dizisi olarak saklamak daha iyidir.

Bu amaçla String veya Char [] kullanmanız gerekip gerekmediği tartışmalıdır, çünkü her ikisinin de avantajları ve dezavantajları vardır. Kullanıcının neye ihtiyacı olduğuna bağlıdır.

Java'daki Dizeler değişmez olduğundan, bazıları dizenizi değiştirmeye çalıştığında yeni bir Nesne oluşturur ve varolan Dize etkilenmez. Bu, parolayı Dize olarak saklamanın bir avantajı olarak görülebilir, ancak nesne kullanımdan sonra bile bellekte kalır. Dolayısıyla, herhangi bir şekilde nesnenin hafıza konumu varsa, o kişi o konumda saklanan parolanızı kolayca izleyebilir.

Char [] değiştirilebilir, ancak kullanımından sonra programcının diziyi açıkça temizleyebilmesi veya değerleri geçersiz kılabilmesi avantajına sahiptir. Bu nedenle, kullanıldığında temizlenir ve hiç kimse sakladığınız bilgileri bilemez.

Yukarıdaki koşullara dayanarak, gereksinimleri için String ile mi yoksa Char [] ile mi gidileceği hakkında bir fikir edinebilirsiniz.

Vaka Dizesi:

    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

Vaka CHAR DİZİSİ:

    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