Por qué char[] es mejor que String para contraseñas? Guía con código

Introducción: ¿Por qué esta pregunta sigue siendo relevante?

Imagine una situación: está escribiendo una aplicación para iniciar sesión. El usuario ingresa una contraseña y usted necesita verificarla. Parece que lo más fácil es guardarla como una cadena (String). Pero los desarrolladores Java experimentados le dirán: "¡Nunca use String para contraseñas! ¡Use char[]!". ¿Por qué?

Esta pregunta es una de las más populares en Stack Overflow (más de 100,000 visitas). Y no es que String no pueda almacenar caracteres. El problema es más profundo: se trata de seguridad, gestión de memoria y fuga de datos. En este artículo, analizaremos por qué char[] para contraseñas es un estándar de seguridad y mostraremos con ejemplos de código cómo implementar correctamente esta práctica en Java.

Si recién está comenzando a aprender Java o desea aumentar el nivel de seguridad de sus aplicaciones, este artículo es para usted.

Problema #1: Inmutabilidad de String

La clase String en Java es inmutable. Esto significa que después de crear un objeto String, su valor no se puede modificar. Cualquier operación que "cambie" la cadena (por ejemplo, toUpperCase() o replace()) en realidad crea un nuevo objeto String en la memoria.

¿Por qué esto es malo para una contraseña? Veamos un ejemplo:

String password = "MySecret123";// ... usamos la contraseña para verificar ...// Terminamos de trabajar con la contraseñapassword = null; // "limpiamos" la referencia

¿Cree que ha limpiado la memoria? ¡No! El objeto "MySecret123" todavía está en la memoria, en el llamado String Pool (grupo de cadenas). El recolector de basura (GC) no lo eliminará de inmediato. Se almacenará allí hasta la próxima recolección de basura, o más precisamente, hasta que haya referencias a él. E incluso después de password = null, el objeto puede permanecer en la memoria por un tiempo indefinido.

¿Y qué pasa si un atacante obtiene un volcado de memoria (heap dump) de su aplicación? Podrá leer la contraseña en texto plano. La inmutabilidad de String hace imposible eliminar inmediatamente la contraseña de la memoria.

Problema #2: String Pool y fuga de contraseñas

Java optimiza el trabajo con cadenas a través del String Pool. Cuando crea una cadena con un literal (por ejemplo, "password"), se coloca en el grupo. Si otra parte del programa usa la misma cadena, simplemente hace referencia al objeto existente.

Ahora imagine que su contraseña es "admin123". Esta misma contraseña podría usarse accidentalmente en otro lugar del sistema (por ejemplo, en registros, en un nombre de archivo o en una configuración). La cadena "admin123" vive en el grupo para siempre (al menos hasta que finalice la JVM). Esto aumenta la superficie de ataque.

// Código que puede provocar una fugaString password = "admin123";System.out.println("Contraseña: " + password); // La contraseña termina en los registros// Incluso si luego password = null, la cadena "admin123" permanece en los registros y en el grupo

Con un array char[] no existe este problema: puede sobrescribir explícitamente cada elemento del array después de usarlo.

Solución: array char[] y gestión manual de memoria

El array de caracteres char[] es un objeto mutable. Puede modificar su contenido en cualquier momento. La principal ventaja: puede limpiar el array inmediatamente después de que la contraseña ya no sea necesaria.

Así es como se ve en la práctica:

import java.util.Arrays;

public class PasswordExample {    public static void main(String[] args) {        // Incorrecto: String        String passwordString = "MySecret123";        // ... verificación ...        passwordString = null; // La contraseña aún puede estar en la memoria                // Correcto: char[]        char[] passwordChars = { 'M', 'y', 'S', 'e', 'c', 'r', 'e',