javascript - online - Encriptación de contraseña en el lado del cliente

encriptar y desencriptar javascript

Question

Posible duplicado:
Acerca del sistema hashing de contraseñas en el lado del cliente

Tengo que asegurar las contraseñas de los usuarios de mi sitio web. Lo que hice fue usar hash de cifrado MD5 en el servidor. Pero el problema es que las contraseñas permanecen en texto plano hasta que llegan al servidor, lo que significa que la contraseña puede capturarse utilizando la supervisión del tráfico. Entonces, lo que quiero es usar un mecanismo de encriptación / codificación de contraseñas del lado del cliente y enviar la contraseña codificada / hash. ¿Alguien puede decir cuál es la forma de hacer esto?

Answer 1

Este tipo de protección normalmente se proporciona mediante el uso de HTTPS , por lo que toda la comunicación entre el servidor web y el cliente está encriptada.

Las instrucciones exactas sobre cómo lograr esto dependerán de su servidor web.

La documentación de Apache tiene una guía HOW-TO de configuración SSL que puede ser de alguna ayuda. (gracias al usuario G. Qyy por el enlace)

Answer 2

Esto no será seguro, y es simple explicar por qué:

Si hash la contraseña en el lado del cliente y usa ese token en lugar de la contraseña, entonces es poco probable que un atacante descubra cuál es la contraseña.

Sin embargo, el atacante no necesita averiguar cuál es la contraseña, ya que su servidor ya no espera la contraseña, está esperando el token. ¡Y el atacante conoce el token porque se envía a través de un HTTP sin cifrar!

Ahora, es posible hackear juntos algún tipo de cifrado de desafío / respuesta, lo que significa que la misma contraseña producirá un token diferente para cada solicitud. Sin embargo, esto requerirá que la contraseña se almacene en un formato descifrable en el servidor, algo que no es ideal, pero podría ser un compromiso adecuado.

Y, finalmente, ¿realmente desea exigirles a los usuarios que tengan activado el JavaScript antes de que puedan iniciar sesión en su sitio web?

En cualquier caso, SSL ya no es una solución costosa o especialmente difícil de configurar

Answer 3

Has etiquetado esta pregunta con la etiqueta ssl y SSL es la respuesta. Curioso.

Answer 4

Hay bibliotecas MD5 disponibles para javascript. Tenga en cuenta que esta solución no funcionará si necesita admitir usuarios que no tienen JavaScript disponible.

La solución más común es usar HTTPS. Con HTTPS, el cifrado SSL se negocia entre su servidor web y el cliente, cifrando de forma transparente todo el tráfico.

Answer 5

He enumerado un JavaScript completo para crear un MD5 en la parte inferior, pero es realmente inútil sin una conexión segura por varias razones.

Si MD5 la contraseña y almacena ese MD5 en su base de datos, entonces el MD5 es la contraseña. La gente puede decir exactamente lo que hay en tu base de datos. Básicamente, has hecho que la contraseña sea una cadena más larga, pero aún no es segura si eso es lo que estás almacenando en tu base de datos.

Si dices: "Bueno, voy a MD5, el MD5" te estás perdiendo el punto. Al observar el tráfico de la red o buscar en su base de datos, puedo falsificar su sitio web y enviarle el MD5. De acuerdo, esto es mucho más difícil que solo reutilizar una contraseña de texto sin formato, pero sigue siendo un agujero de seguridad.

La mayoría de todos, aunque no se puede saltear el lado del cliente hash sin enviar la sal sobre la red sin cifrar, por lo tanto, la salazón sin sentido. Sin sal o con una sal conocida, puedo atacar con fuerza bruta el hash y descubrir cuál es la contraseña.

Si va a hacer este tipo de cosas con transmisiones sin encriptar, necesita usar una clave pública / clave privada de cifrado . El cliente encripta usando su clave pública, luego descifra su nombre con su clave privada, luego MD5 la contraseña (usando un usuario único) y la almacena en su base de datos. Aquí hay una biblioteca de clave pública / privada de JavaScript GPL .

De todos modos , aquí está el código JavaScript para crear un lado del cliente MD5 (no mi código):

/**
*
*  MD5 (Message-Digest Algorithm)
*  http://www.webtoolkit.info/
*
**/

var MD5 = function (string) {

    function RotateLeft(lValue, iShiftBits) {
        return (lValue<<iShiftBits) | (lValue>>>(32-iShiftBits));
    }

    function AddUnsigned(lX,lY) {
        var lX4,lY4,lX8,lY8,lResult;
        lX8 = (lX & 0x80000000);
        lY8 = (lY & 0x80000000);
        lX4 = (lX & 0x40000000);
        lY4 = (lY & 0x40000000);
        lResult = (lX & 0x3FFFFFFF)+(lY & 0x3FFFFFFF);
        if (lX4 & lY4) {
            return (lResult ^ 0x80000000 ^ lX8 ^ lY8);
        }
        if (lX4 | lY4) {
            if (lResult & 0x40000000) {
                return (lResult ^ 0xC0000000 ^ lX8 ^ lY8);
            } else {
                return (lResult ^ 0x40000000 ^ lX8 ^ lY8);
            }
        } else {
            return (lResult ^ lX8 ^ lY8);
        }
    }

    function F(x,y,z) { return (x & y) | ((~x) & z); }
    function G(x,y,z) { return (x & z) | (y & (~z)); }
    function H(x,y,z) { return (x ^ y ^ z); }
    function I(x,y,z) { return (y ^ (x | (~z))); }

    function FF(a,b,c,d,x,s,ac) {
        a = AddUnsigned(a, AddUnsigned(AddUnsigned(F(b, c, d), x), ac));
        return AddUnsigned(RotateLeft(a, s), b);
    };

    function GG(a,b,c,d,x,s,ac) {
        a = AddUnsigned(a, AddUnsigned(AddUnsigned(G(b, c, d), x), ac));
        return AddUnsigned(RotateLeft(a, s), b);
    };

    function HH(a,b,c,d,x,s,ac) {
        a = AddUnsigned(a, AddUnsigned(AddUnsigned(H(b, c, d), x), ac));
        return AddUnsigned(RotateLeft(a, s), b);
    };

    function II(a,b,c,d,x,s,ac) {
        a = AddUnsigned(a, AddUnsigned(AddUnsigned(I(b, c, d), x), ac));
        return AddUnsigned(RotateLeft(a, s), b);
    };

    function ConvertToWordArray(string) {
        var lWordCount;
        var lMessageLength = string.length;
        var lNumberOfWords_temp1=lMessageLength + 8;
        var lNumberOfWords_temp2=(lNumberOfWords_temp1-(lNumberOfWords_temp1 % 64))/64;
        var lNumberOfWords = (lNumberOfWords_temp2+1)*16;
        var lWordArray=Array(lNumberOfWords-1);
        var lBytePosition = 0;
        var lByteCount = 0;
        while ( lByteCount < lMessageLength ) {
            lWordCount = (lByteCount-(lByteCount % 4))/4;
            lBytePosition = (lByteCount % 4)*8;
            lWordArray[lWordCount] = (lWordArray[lWordCount] | (string.charCodeAt(lByteCount)<<lBytePosition));
            lByteCount++;
        }
        lWordCount = (lByteCount-(lByteCount % 4))/4;
        lBytePosition = (lByteCount % 4)*8;
        lWordArray[lWordCount] = lWordArray[lWordCount] | (0x80<<lBytePosition);
        lWordArray[lNumberOfWords-2] = lMessageLength<<3;
        lWordArray[lNumberOfWords-1] = lMessageLength>>>29;
        return lWordArray;
    };

    function WordToHex(lValue) {
        var WordToHexValue="",WordToHexValue_temp="",lByte,lCount;
        for (lCount = 0;lCount<=3;lCount++) {
            lByte = (lValue>>>(lCount*8)) & 255;
            WordToHexValue_temp = "0" + lByte.toString(16);
            WordToHexValue = WordToHexValue + WordToHexValue_temp.substr(WordToHexValue_temp.length-2,2);
        }
        return WordToHexValue;
    };

    function Utf8Encode(string) {
        string = string.replace(//r/n/g,"/n");
        var utftext = "";

        for (var n = 0; n < string.length; n++) {

            var c = string.charCodeAt(n);

            if (c < 128) {
                utftext += String.fromCharCode(c);
            }
            else if((c > 127) && (c < 2048)) {
                utftext += String.fromCharCode((c >> 6) | 192);
                utftext += String.fromCharCode((c & 63) | 128);
            }
            else {
                utftext += String.fromCharCode((c >> 12) | 224);
                utftext += String.fromCharCode(((c >> 6) & 63) | 128);
                utftext += String.fromCharCode((c & 63) | 128);
            }

        }

        return utftext;
    };

    var x=Array();
    var k,AA,BB,CC,DD,a,b,c,d;
    var S11=7, S12=12, S13=17, S14=22;
    var S21=5, S22=9 , S23=14, S24=20;
    var S31=4, S32=11, S33=16, S34=23;
    var S41=6, S42=10, S43=15, S44=21;

    string = Utf8Encode(string);

    x = ConvertToWordArray(string);

    a = 0x67452301; b = 0xEFCDAB89; c = 0x98BADCFE; d = 0x10325476;

    for (k=0;k<x.length;k+=16) {
        AA=a; BB=b; CC=c; DD=d;
        a=FF(a,b,c,d,x[k+0], S11,0xD76AA478);
        d=FF(d,a,b,c,x[k+1], S12,0xE8C7B756);
        c=FF(c,d,a,b,x[k+2], S13,0x242070DB);
        b=FF(b,c,d,a,x[k+3], S14,0xC1BDCEEE);
        a=FF(a,b,c,d,x[k+4], S11,0xF57C0FAF);
        d=FF(d,a,b,c,x[k+5], S12,0x4787C62A);
        c=FF(c,d,a,b,x[k+6], S13,0xA8304613);
        b=FF(b,c,d,a,x[k+7], S14,0xFD469501);
        a=FF(a,b,c,d,x[k+8], S11,0x698098D8);
        d=FF(d,a,b,c,x[k+9], S12,0x8B44F7AF);
        c=FF(c,d,a,b,x[k+10],S13,0xFFFF5BB1);
        b=FF(b,c,d,a,x[k+11],S14,0x895CD7BE);
        a=FF(a,b,c,d,x[k+12],S11,0x6B901122);
        d=FF(d,a,b,c,x[k+13],S12,0xFD987193);
        c=FF(c,d,a,b,x[k+14],S13,0xA679438E);
        b=FF(b,c,d,a,x[k+15],S14,0x49B40821);
        a=GG(a,b,c,d,x[k+1], S21,0xF61E2562);
        d=GG(d,a,b,c,x[k+6], S22,0xC040B340);
        c=GG(c,d,a,b,x[k+11],S23,0x265E5A51);
        b=GG(b,c,d,a,x[k+0], S24,0xE9B6C7AA);
        a=GG(a,b,c,d,x[k+5], S21,0xD62F105D);
        d=GG(d,a,b,c,x[k+10],S22,0x2441453);
        c=GG(c,d,a,b,x[k+15],S23,0xD8A1E681);
        b=GG(b,c,d,a,x[k+4], S24,0xE7D3FBC8);
        a=GG(a,b,c,d,x[k+9], S21,0x21E1CDE6);
        d=GG(d,a,b,c,x[k+14],S22,0xC33707D6);
        c=GG(c,d,a,b,x[k+3], S23,0xF4D50D87);
        b=GG(b,c,d,a,x[k+8], S24,0x455A14ED);
        a=GG(a,b,c,d,x[k+13],S21,0xA9E3E905);
        d=GG(d,a,b,c,x[k+2], S22,0xFCEFA3F8);
        c=GG(c,d,a,b,x[k+7], S23,0x676F02D9);
        b=GG(b,c,d,a,x[k+12],S24,0x8D2A4C8A);
        a=HH(a,b,c,d,x[k+5], S31,0xFFFA3942);
        d=HH(d,a,b,c,x[k+8], S32,0x8771F681);
        c=HH(c,d,a,b,x[k+11],S33,0x6D9D6122);
        b=HH(b,c,d,a,x[k+14],S34,0xFDE5380C);
        a=HH(a,b,c,d,x[k+1], S31,0xA4BEEA44);
        d=HH(d,a,b,c,x[k+4], S32,0x4BDECFA9);
        c=HH(c,d,a,b,x[k+7], S33,0xF6BB4B60);
        b=HH(b,c,d,a,x[k+10],S34,0xBEBFBC70);
        a=HH(a,b,c,d,x[k+13],S31,0x289B7EC6);
        d=HH(d,a,b,c,x[k+0], S32,0xEAA127FA);
        c=HH(c,d,a,b,x[k+3], S33,0xD4EF3085);
        b=HH(b,c,d,a,x[k+6], S34,0x4881D05);
        a=HH(a,b,c,d,x[k+9], S31,0xD9D4D039);
        d=HH(d,a,b,c,x[k+12],S32,0xE6DB99E5);
        c=HH(c,d,a,b,x[k+15],S33,0x1FA27CF8);
        b=HH(b,c,d,a,x[k+2], S34,0xC4AC5665);
        a=II(a,b,c,d,x[k+0], S41,0xF4292244);
        d=II(d,a,b,c,x[k+7], S42,0x432AFF97);
        c=II(c,d,a,b,x[k+14],S43,0xAB9423A7);
        b=II(b,c,d,a,x[k+5], S44,0xFC93A039);
        a=II(a,b,c,d,x[k+12],S41,0x655B59C3);
        d=II(d,a,b,c,x[k+3], S42,0x8F0CCC92);
        c=II(c,d,a,b,x[k+10],S43,0xFFEFF47D);
        b=II(b,c,d,a,x[k+1], S44,0x85845DD1);
        a=II(a,b,c,d,x[k+8], S41,0x6FA87E4F);
        d=II(d,a,b,c,x[k+15],S42,0xFE2CE6E0);
        c=II(c,d,a,b,x[k+6], S43,0xA3014314);
        b=II(b,c,d,a,x[k+13],S44,0x4E0811A1);
        a=II(a,b,c,d,x[k+4], S41,0xF7537E82);
        d=II(d,a,b,c,x[k+11],S42,0xBD3AF235);
        c=II(c,d,a,b,x[k+2], S43,0x2AD7D2BB);
        b=II(b,c,d,a,x[k+9], S44,0xEB86D391);
        a=AddUnsigned(a,AA);
        b=AddUnsigned(b,BB);
        c=AddUnsigned(c,CC);
        d=AddUnsigned(d,DD);
    }

    var temp = WordToHex(a)+WordToHex(b)+WordToHex(c)+WordToHex(d);

    return temp.toLowerCase();
}

Answer 6

Necesita una biblioteca que pueda encriptar su entrada en el lado del cliente y transferirla al servidor en forma encriptada.

Puedes usar las siguientes libs:

• jCryption . Encriptación asimétrica cliente-servidor sobre Javascript

Actualización después de 3 años:

• Biblioteca de criptografía de Stanford Javascript

Actualización después de 4 años (¡Wohoo!)

• CryptoJS: encriptación fácil de usar
• ForgeJS: prácticamente lo cubre todo

¿Todavía no está convencido? Tampoco yo estoy :)

• OpenPGP.JS: ponga el formato OpenPGP en todas partes : se ejecuta en JS para que pueda usarlo en sus aplicaciones web, aplicaciones móviles, etc.

Answer 7

Para una situación similar, utilicé este PKCS n. ° 5: Estándar de criptografía basado en contraseña de los laboratorios de RSA. Puede evitar el almacenamiento de la contraseña, sustituyéndola por algo que solo se puede generar a partir de la contraseña (en una frase). Hay algunas implementaciones de JavaScript.

Answer 8

También puede simplemente usar la autenticación http con Digest ( Aquí algunas informaciones si usa Apache httpd , Apache Tomcat , y aquí una explicación del resumen ).

Con Java, para obtener información interesante, eche un vistazo a:

• Comprender la autenticación de inicio de sesión
• Ejemplos de solicitud y respuesta de autenticación implícita HTTP
• Autenticación de HTTP Aflicciones
• Autenticación básica para la página JSP (no es un resumen, pero creo que es una fuente interesante)

Answer 9

Yo elegiría esta solución simple .

Resumiéndolo:

• Cliente "Quiero iniciar sesión"
• El servidor genera un número aleatorio #S y lo envía al Cliente
• Cliente
  • lee nombre de usuario y contraseña escritos por el usuario
  • calcula el hash de la contraseña, obteniendo h(pw) (que es lo que está almacenado en el DB)
  • genera otro número aleatorio #C
  • concatena h(pw) + #S + #C y calcula su hash, llámalo h(all)
  • envía al username del servidor, #C y h(all)
• Servidor
  • recupera h(pw)'' para el username especificado, de la base de datos
  • ahora tiene todos los elementos para calcular h(all'') , como lo hizo el Cliente
  • si h(all) = h(all'') entonces h(pw) = h(pw)'' , casi con certeza

Nadie puede repetir la solicitud para iniciar sesión como el usuario especificado. #S agrega un componente variable al hash, cada vez (es fundamental). #C agrega ruido adicional en él.