Por que char [] é preferido sobre String para senhas?

No Swing, o campo da senha possui um método getPassword()(retornos char[]) em vez do método usual getText()(retornos String). Da mesma forma, encontrei uma sugestão para não usar Stringpara lidar com senhas.

Por que Stringrepresenta uma ameaça à segurança quando se trata de senhas? Parece inconveniente de usar char[].

Strings são imutáveis . Isso significa que, depois de criar String, se outro processo puder despejar memória, não há como (além da reflexão ) você poder se livrar dos dados antes que a coleta de lixo comece .

Com uma matriz, você pode limpar explicitamente os dados depois de terminar. Você pode sobrescrever a matriz com o que quiser e a senha não estará presente em nenhum lugar do sistema, mesmo antes da coleta de lixo.

Portanto, sim, essa é uma preocupação de segurança - mas mesmo o uso char[]reduz apenas a janela de oportunidade para um invasor, e é apenas para esse tipo específico de ataque.

Conforme observado nos comentários, é possível que as matrizes que estão sendo movidas pelo coletor de lixo deixem cópias dispersas dos dados na memória. Acredito que isso seja específico da implementação - o coletor de lixo pode limpar toda a memória, para evitar esse tipo de coisa. Mesmo que isso aconteça, ainda há o tempo durante o qual os char[]caracteres reais são exibidos como uma janela de ataque.

Embora outras sugestões aqui pareçam válidas, há outro bom motivo. Com simplicidade, Stringvocê tem chances muito maiores de imprimir acidentalmente a senha em logs , monitores ou em algum outro local inseguro. char[]é menos vulnerável.

Considere isto:

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

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

Impressões:

String: Password
Array: [C@5829428e

Para citar um documento oficial, o guia Java Cryptography Architecture diz isso sobre char[]vs. Stringsenhas (sobre criptografia baseada em senha, mas geralmente é sobre senhas, é claro):

Parece lógico coletar e armazenar a senha em um objeto do tipo java.lang.String. No entanto, aqui está a ressalva: Objects do tipo Stringsão imutáveis, ou seja, não há métodos definidos que permitam alterar (substituir) ou zerar o conteúdo de um String pós-uso. Esse recurso torna os Stringobjetos inadequados para armazenar informações confidenciais de segurança, como senhas de usuários. Você sempre deve coletar e armazenar informações confidenciais de segurança em uma charmatriz.

A Diretriz 2-2 das Diretrizes de codificação segura para a linguagem de programação Java, versão 4.0 também diz algo semelhante (embora seja originalmente no contexto do log):

Diretriz 2-2: Não registre informações altamente confidenciais

Algumas informações, como números de segurança social (SSNs) e senhas, são altamente confidenciais. Essas informações não devem ser mantidas por mais tempo que o necessário, nem onde possam ser vistas, mesmo pelos administradores. Por exemplo, ele não deve ser enviado para arquivos de log e sua presença não deve ser detectável por meio de pesquisas. Alguns dados transitórios podem ser mantidos em estruturas de dados mutáveis, como matrizes de caracteres, e limpos imediatamente após o uso. A limpeza de estruturas de dados reduziu a eficácia em sistemas Java runtime típicos, à medida que os objetos são movidos na memória de forma transparente para o programador.

Essa diretriz também tem implicações para a implementação e o uso de bibliotecas de nível inferior que não possuem conhecimento semântico dos dados com os quais estão lidando. Como exemplo, uma biblioteca de análise de seqüência de caracteres de baixo nível pode registrar o texto em que trabalha. Um aplicativo pode analisar um SSN com a biblioteca. Isso cria uma situação em que os SSNs estão disponíveis para administradores com acesso aos arquivos de log.

As matrizes de caracteres ( char[]) podem ser limpas após o uso, definindo cada caractere como zero e Strings, não. Se alguém puder ver a imagem da memória de alguma forma, poderá ver uma senha em texto sem formatação se Strings forem usadas, mas se char[]for usada, após limpar os dados com zeros, a senha estará segura.

Algumas pessoas acreditam que você precisa sobrescrever a memória usada para armazenar a senha quando não precisar mais dela. Isso reduz a janela de tempo que um invasor precisa ler a senha do seu sistema e ignora completamente o fato de que o invasor já precisa de acesso suficiente para seqüestrar a memória da JVM para fazer isso. Um invasor com tanto acesso pode capturar seus principais eventos, tornando isso completamente inútil (AFAIK, por favor, corrija-me se estiver errado).

Atualizar

Graças aos comentários, tenho que atualizar minha resposta. Aparentemente, existem dois casos em que isso pode adicionar uma (muito) pequena melhoria de segurança, pois reduz o tempo que uma senha pode pousar no disco rígido. Ainda acho que é um exagero para a maioria dos casos de uso.

• Seu sistema de destino pode estar mal configurado ou você deve assumir que é e deve ser paranóico em relação aos core dumps (pode ser válido se os sistemas não forem gerenciados por um administrador).
• Seu software deve ser excessivamente paranóico para evitar vazamentos de dados com o invasor obtendo acesso ao hardware - usando coisas como TrueCrypt (descontinuado), VeraCrypt ou CipherShed .

Se possível, desativar os dumps principais e o arquivo de troca resolveriam os dois problemas. No entanto, eles exigiriam direitos de administrador e podem reduzir a funcionalidade (menos memória para usar) e extrair RAM de um sistema em execução ainda seria uma preocupação válida.

Não acho que seja uma sugestão válida, mas pelo menos posso adivinhar o motivo.

Eu acho que a motivação é ter certeza de que você pode apagar todo o rastreamento da senha na memória imediatamente e com segurança depois que ela for usada. Com um, char[]você pode sobrescrever cada elemento da matriz com um espaço em branco ou algo com certeza. Você não pode editar o valor interno Stringdessa maneira.

Mas isso por si só não é uma boa resposta; por que não apenas garantir que uma referência char[]ou Stringnão escape? Então não há problema de segurança. Mas o fato é que os Stringobjetos podem ser intern()edificados em teoria e mantidos vivos dentro da piscina constante. Suponho que o uso char[]proíba essa possibilidade.

A resposta já foi dada, mas eu gostaria de compartilhar um problema que descobri recentemente com as bibliotecas padrão Java. Enquanto eles tomam muito cuidado agora de substituir as strings de senha por char[]todos os lugares (o que é bom), outros dados críticos de segurança parecem ser esquecidos quando se trata de limpá-los da memória.

Estou pensando, por exemplo, na classe PrivateKey . Considere um cenário em que você carregaria uma chave RSA privada de um arquivo PKCS # 12, usando-a para executar alguma operação. Agora, nesse caso, farejar a senha por si só não ajudaria muito, desde que o acesso físico ao arquivo-chave seja adequadamente restrito. Como invasor, você seria muito melhor se obtivesse a chave diretamente em vez da senha. As informações desejadas podem ser coletor vazado, core dumps, sessão de depurador ou arquivos de troca são apenas alguns exemplos.

E, como se vê, não há nada que permita limpar as informações privadas de um PrivateKeyda memória, porque não há API que permita limpar os bytes que formam as informações correspondentes.

Esta é uma situação ruim, pois este artigo descreve como essa circunstância pode ser potencialmente explorada.

A biblioteca OpenSSL, por exemplo, substitui as seções críticas da memória antes que as chaves privadas sejam liberadas. Como o Java é coletado pelo lixo, precisaríamos de métodos explícitos para limpar e invalidar informações privadas para chaves Java, que devem ser aplicadas imediatamente após o uso da chave.

Como Jon Skeet afirma, não há maneira, exceto usando a reflexão.

No entanto, se a reflexão é uma opção para você, você pode fazer isso.

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

quando correr

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

Nota: se o char [] da String foi copiado como parte de um ciclo do GC, é possível que a cópia anterior esteja em algum lugar na memória.

Essa cópia antiga não apareceria em um despejo de heap, mas se você tiver acesso direto à memória bruta do processo, poderá vê-la. Em geral, você deve evitar alguém que tenha esse acesso.

Por todas essas razões, deve-se escolher uma matriz char [] em vez de String para uma senha.

1. Como as Strings são imutáveis ​​em Java, se você armazenar a senha como texto sem formatação, ela estará disponível na memória até que o Garbage Collector a limpe, e como a String é usada no pool de String para reutilização, há uma chance muito grande de permanecem na memória por um longo período, o que representa uma ameaça à segurança.

Como qualquer pessoa que tenha acesso ao despejo de memória pode encontrar a senha em texto não criptografado, esse é outro motivo pelo qual você deve sempre usar uma senha criptografada em vez de texto sem formatação. Como as Strings são imutáveis, não há como o conteúdo das Strings poder ser alterado porque qualquer alteração produzirá uma nova String, enquanto que se você usar um char [], poderá definir todos os elementos como em branco ou zero. Portanto, armazenar uma senha em uma matriz de caracteres reduz claramente o risco de segurança de roubar uma senha.

2) próprio Java recomenda o uso do método getPassword () do JPasswordField, que retorna um char [], em vez do método obsoleto getText (), que retorna senhas em texto não criptografado, indicando os motivos de segurança. É bom seguir os conselhos da equipe Java e aderir aos padrões, em vez de ir contra eles.

3. Com String, há sempre o risco de imprimir texto sem formatação em um arquivo de log ou console, mas se você usar uma matriz, não imprimirá o conteúdo de uma matriz, mas seu local de memória será impresso. Embora não seja um motivo real, ainda faz sentido.

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

Referenciado neste blog . Eu espero que isso ajude.

Edit: Voltando a esta resposta após um ano de pesquisa de segurança, percebo que isso implica a lamentável implicação de que você realmente compararia senhas em texto simples. Por favor não. Use um hash unidirecional seguro com um sal e um número razoável de iterações . Considere usar uma biblioteca: é difícil acertar essas coisas!

Resposta original: E o fato de o String.equals () usar avaliação de curto-circuito e, portanto, é vulnerável a um ataque de tempo? Pode ser improvável, mas você poderia teoricamente cronometrar a comparação da senha para determinar a sequência correta de caracteres.

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

Mais alguns recursos sobre ataques de tempo:

• Uma lição sobre ataques de tempo
• Uma discussão sobre a sincronização de ataques no Information Security Stack Exchange
• E, claro, a página da Wikipedia sobre Timing Attack

Não há nada que o array de caracteres dê a você vs String, a menos que você o limpe manualmente após o uso, e eu não vi ninguém fazendo isso. Então, para mim, a preferência de char [] vs String é um pouco exagerada.

Dê uma olhada na biblioteca Spring Security _{amplamente usada} aqui e pergunte a si mesmo - os caras do Spring Security são incompetentes ou as senhas char [] simplesmente não fazem muito sentido. Quando um hacker desagradável agarra despejos de memória da sua RAM, verifique se ele obterá todas as senhas, mesmo se você usar maneiras sofisticadas de escondê-las.

No entanto, o Java muda o tempo todo e alguns recursos assustadores, como o recurso de redução de redundância de seqüência do Java 8, podem internar objetos String sem o seu conhecimento. Mas isso é uma conversa diferente.

Strings são imutáveis ​​e não podem ser alteradas depois de criadas. Criar uma senha como uma sequência deixará referências dispersas para a senha na pilha ou no pool de Sequências. Agora, se alguém pegar um monte de lixo do processo Java e varrer cuidadosamente, poderá adivinhar as senhas. É claro que essas seqüências não usadas serão coletadas como lixo, mas isso depende de quando o GC entra em ação.

Por outro lado, char [] é mutável assim que a autenticação é concluída, você pode substituí-los por qualquer caractere como todos os M's ou barras invertidas. Agora, mesmo que alguém faça um despejo de pilha, ele pode não conseguir obter as senhas que não estão em uso no momento. Isso lhe dá mais controle no sentido de limpar o conteúdo do objeto e esperar o GC fazer isso.

String é imutável e vai para o pool de strings. Uma vez escrito, não pode ser substituído.

char[] é uma matriz que você deve substituir depois de usar a senha e é assim que deve ser feito:

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

Um cenário em que o invasor pode usá-lo é um despejo de memória - quando a JVM trava e gera um despejo de memória - você poderá ver a senha.

Isso não é necessariamente um invasor externo malicioso. Pode ser um usuário de suporte que tenha acesso ao servidor para fins de monitoramento. Ele poderia espiar um despejo de memória e encontrar as senhas.

A resposta curta e direta seria porque char[]é mutável enquanto os Stringobjetos não são.

Stringsem Java são objetos imutáveis. É por isso que eles não podem ser modificados depois de criados e, portanto, a única maneira de remover o conteúdo da memória é fazer com que o lixo seja coletado. Somente então será possível substituir a memória liberada pelo objeto e os dados desaparecerão.

Agora, a coleta de lixo em Java não acontece em nenhum intervalo garantido. O Stringpode, assim, persistem na memória por um longo tempo, e se um processo deixa de funcionar durante este tempo, o conteúdo da corda pode acabar em um despejo de memória ou algum log.

Com uma matriz de caracteres , você pode ler a senha, terminar de trabalhar com ela o mais rápido possível e alterar imediatamente o conteúdo.

String em java é imutável. Portanto, sempre que uma string é criada, ela permanece na memória até ser coletada como lixo. Portanto, qualquer pessoa que tenha acesso à memória pode ler o valor da string.
Se o valor da string for modificado, ele acabará criando uma nova string. Portanto, o valor original e o valor modificado permanecem na memória até a coleta de lixo.

Com a matriz de caracteres, o conteúdo da matriz pode ser modificado ou apagado quando o objetivo da senha for atendido. O conteúdo original da matriz não será encontrado na memória após sua modificação e mesmo antes da coleta de lixo.

Por causa da preocupação com a segurança, é melhor armazenar a senha como uma matriz de caracteres.

É discutível se você deve usar String ou Char [] para esse fim, pois ambos têm suas vantagens e desvantagens. Depende do que o usuário precisa.

Como Strings em Java são imutáveis, sempre que algumas tentam manipular sua string, ela cria um novo Objeto e a String existente permanece inalterada. Isso pode ser visto como uma vantagem para armazenar uma senha como uma String, mas o objeto permanece na memória mesmo após o uso. Portanto, se alguém conseguiu a localização da memória do objeto, ela pode rastrear facilmente sua senha armazenada nessa localização.

Char [] é mutável, mas tem a vantagem de que após o uso, o programador pode limpar explicitamente a matriz ou substituir valores. Portanto, quando terminar de usá-lo, ele será limpo e ninguém poderá saber sobre as informações que você armazenou.

Com base nas circunstâncias acima, pode-se ter uma idéia de usar String ou de Char [] para seus requisitos.

Caso String:

    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

Caso 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