Cómo implementar el cifrado MD5 en JSP
Código fuente
/**
*Nombre de clase: MD5Digest
* Descripción : parámetros de la utilidad md5 para cifrado de contraseñas
* Fecha: 05/03/2001<...br>
* Modificado por:
* Modificado por:
* @autor edgarlo edgarlo@china.com
* @versión 1.0
* /
importar java.security.MessageDigest;
importar java.security.MessageDigest;
importar java.security.MessageDigest;
importar java. security.MessageDigest;
importar java.security.MessageDigest;
ac largo) {
a += H (b, c, d) + x + ac;
a = ((int) a << s) | ((int) a >>> (32 - s));
a += b;
devolver a;
}
privado largo II(largo a, largo b, largo c, largo d, largo x, largo s,
largo ac) {
a += I (b, c, d) + x + ac;
a = ((int) a << s ) ( (int) a > ; >> (32 - s));
a += b;
return a;
}
/*
md5Update es el proceso de cálculo principal de MD5, inbuf es la cadena de bytes que se va a convertir, inputlen es la longitud, esta función es llamada por getMD5ofStr y md5init debe llamarse antes de llamar. Por lo tanto, está diseñado para ser privado
*/
private void md5Update(byte[] inbuf, int inputLen) {
int i, index.partLen ;
byte[] bloque = nuevo byte[64];
índice = (int)(recuento[0] >>> 3) & 0x3F;
/ /* Actualizar el número de dígitos*/
if ((count[0] += (inputLen < < 3)) < (inputLen << 3))
contar[1] ++;
contar[1] += (inputLen <<< 29);
partLen = 64 - índice;
// tantos como sea posible Transformar.
if (inputLen >= partLen) {
md5Memcpy(buffer, inbuf, index, 0, partLen);
md5Transform(buffer) ;
for (i = partLen; i + 63 < inputLen; i += 64) {
md5Memcpy(block, inbuf, 0, i, 64);
md5Transform (bloque);
}
índice = 0;
} más
i = 0;
///* Entrada restante del búfer */
md5Memcpy(buffer, inbuf, index, i, inputLen - i);
md5Memcpy(block, inbuf, 0, i, 64);
md5Transform( inputLen - i);
}
/*
md5Final organiza y completa la salida< / p>
*/
private void md5Final () {
byte[] bits = nuevo byte[8];
int index, padLen ;
///* Guardar el número de bits*/
Codificar (bits, recuento, 8);
///* Rellenar 56 mod 64 .
index = (int)(count[0] >& gt;> 3) & 0x3f;
padLen = (index < 56) ?(56 - index) : (120 - index);
md5Update (PADDING, padLen);
///* Agregar longitud (antes del relleno) */
md5Update(bits, 8) ;
///* Almacenar estado en resumen */
Codificar (resumen, estado,
}
/); * md5Memcpy es una función de copia de bloque de matriz de bytes utilizada internamente que comienza en las entradas de entrada y copia bytes de longitud de longitud
a las posiciones exteriores.
Copiar al principio de la posición de salida de salida
*/
private void md5Memcpy (byte[] de salida, byte[] de entrada,
int outpos, int inpos, int len)
{
int i;
para (i = 0; i < len; i++)
salida [outpos + i] = input[inpos + i];
}
/*
md5Transform es el programa de conversión principal de MD5, llamado por md5Update, y bloque es bloque Bytes sin procesar
*/
private void md5Transform (bloque de bytes[]) {
long a = estado[0], b = estado[ 1] , c = estado[2], d = estado[3];
long[] x = new long[16];
Decodificar (x, bloque, 64) ;
/* Ronda 1 */
a = FF (a, b, c, d, x[0], S11, 0xd76aa478L /* 1 */
d = FF (d, a, b, c , x[1], S12, 0xe8c7b756L /* 2 */
c = FF (c, d, a, b); , x [2], S13, 0x242070dbL); /* 3 */
b = FF (b, c, d, a, x[3], S14, 0xc1bdceeeL /* 4 */);
a = FF (a, b, c, d, x[4], S11, 0xf57c0fafL /* 5 */
d = FF (d, a, b); , c , x[5], S12, 0x4787c62aL); /* 6 */
c = FF (c, d, a, b, x[6], S13, 0xa8304613L); */
b = FF (b, c, d, a, x[7], S14, 0xfd469501L); /* 8 */
a = FF (a, b); , c , d, x[8], S11, 0x698098d8L); /* 9 */
d = FF (d, a, b, c, x[9], S12, 0x8b44f7afL); * 10 */
c = FF (c, d, a, b, x[10], S13, 0xffff5bb1L); /* 11 */
b = FF (b); , c , d, a, x[11], S14, 0x895cd7beL /* 12 */
a = FF (a, b, c, d, x[12], S11, 0x6b901122L); ;/ * 13 */
d = FF (d, a, b, c, x[13], S12, 0xfd987193L); /* 14 */
c = FF); (c , d, a, b, x[14], S13, 0xa679438eL /* 15 */
b = FF (b, c, d, a, x[15], S14,); 0x49b40821L);/* 16 */
/*
Ronda 2*/
a = GG ( a, b, c, d, x[1], S21, 0xf61e2562L /* 17 */
d = GG ( d); , a, b, c, x[6], S22, 0xc040b340L /* 18 */
c = GG (c, d, a, b, x[11], S23, 0x265e5a51L ) ; /* 19 */
b = GG ( b, c, d, a, x[0], S24, 0xe9b6c7aaL); /* 20 */
a = GG); (a, b, c, d, x[5], S21, 0xd62f105dL /* 21 */
d = GG (d, a, b, c, x[10], S22 , 0x2441453L); /* 22 */
c = GG (c, d, a, b, x[15], S23, 0xd8a1e6868aaL); = GG (c, d, a, b, x[15], S23, 0xd8a1e681L); /* 23 */
b = GG (b, c, d, a, x[4] , S24, 0xe7d3fbc8L); /* 24 */
a = GG (a, b, c, d, x[9], S21, /* 25 */
< p); > d = GG (d, a, b, c, x[14], S22, 0xc33707d6L /* 26 */c = GG (c, d, a, b, x[ 3); ], S23, 0xf4d50d87L); /* 27 */
b = GG (b, c, d, a, x[8], S24, 0x455a14edL /* 28 */
);a = GG (a, b, c, d, x[13], S21, 0xa9e3e905L /* 29 */
d = GG (d, a, b, c, x); [2], S22, 0xfcefa3f8L); /* 30 */
c = GG (c, d, a, b, x[7], S23.0x676f02d9L /* 31 */< /); p>
b = GG (b, c, d, a, x[12], S24, 0x8d2a4c8aL /* 32 */
/* Ronda 3*/
<); p>a = HH (a, b, c, d, x[5], S31, 0xfffa3942L /* 33 */d = HH (d, a, b, c, x[); 8], S32, 0x8771f681L); /* 34 */
c = HH (c, d, a, b, x[11], S33, 0x6d9d6122L); >
b = HH (b, c, d, a, x[14], S34, 0xfde5380cL /* 36 */
a = HH (a, b, c, d, x[1], S31, 0xa4beea44L); /* 37 */
d = HH (d, a, b, c, x[4], S32, 0x4bdecfa9L); /p>
c = HH (c, d, a, b, x[7], S33, 0xf6bb4b60L /* 39 */
b = HH (b, c, d,); a, x[10], S3
4, 0xbebfbc70L); /* 40 */
a = HH (a, b, c, d, x[13], S31, 0x289b7ec6L); > d = HH (d, a, b, c, x[0], S32, 0xeaa127faL /* 42 */
c = HH (c, d, a, b, x[3); ], S33, 0xd4ef3085L); /* 43 */
b = HH (b, c, d, a, x[6], S34, /* 44 */
);a = HH (a, b, c, d, x[9], S31, 0xd9d4d039L /* 45 */
d = HH (d, a, b, c, x); [12], S32, 0xe6db99e5L); /* 46 */
c = HH (c, d, a, b, x[15], S33, 0x1fa27cf8L /* 47 */
b = HH (b, c, d, a, x[2], S34, 0xc4ac5665L /* 48 */
/* Ronda 4*/
<); p>a = II (a, b, c, d, x[0], S41, 0xf4292244L /* 49 */d = II (d, a, b, c, x [); 7], S42, 0x432aff97L); /* 50 */
c = II (c, d, a, b, x[14], S43, 0xab9423a7L /* 51 */
b = II (b, c, d, a, x[14], S43, 0xab9423a7L /* 51 */
b = II (b, c, d, a ,); x[5], S44, 0xfc93a039L); /* 52 */
a = II (a, b, c, d, x[12], S41, 0x655b59c3L); /p>
d = II (d, a, b, c, x[3], S42, 0x8f0ccc92L /* 54 * /
c = II (c, d, a ,); b, x[10], S43, 0xffeff47dL); /* 55 */
b = II (b, c, d, a, x[1], S44, 0x85845dd1L); /
a = II (a, b, c, d, x[8], S41, 0x6fa87e4f 0x6fa87e4fL); /* 57 */
d = II (d, a , b, c, x[15], S42, 0xfe2ce6e0L); /* 58 */
c = II (c, d, a, b, x[6], S43, 0xa3014314L); * 59 */
b = II (b c, d, a, x[13], S44, 0x4e0811a1L); /* 60 */
a = II (a, b); , c, d, x[4], S41, 0xf7537e82L); /* 61 */
d = II (d, a, b, c, x[11], S42, 0xbd3af235L); * 62 */
c = II (c, d, a, b, x[2], S43, 0x2
ad7d2bbL); /* 63 */
b = II (b, c, d, a, x[9], S44, 0xeb86d391L /* 64 */
estado); [0] += a;
estado[ 1] += b;
estado[2] += c;
estado[3] += d;
}
/*Encode divide la matriz larga en matrices de bytes, porque el tipo largo de Java es de 64 bits,
Para adaptarse a la implementación original de C, solo divídala en 32 bits,
*/
codificación vacía privada (byte[] de salida, long[] de entrada, int len) {
int i, j;
for (i = 0, j = 0; j < len; i++, j += 4) {
salida[j] = ( byte )(entrada & 0xffL);
salida[j + 1] = (byte)((entrada >>> 8) & 0xffL);
salida[j + 2] = (byte)((entrada > 16) & 0xffL);
salida[j + 2] = (byte)((entrada >> 16)) gt;> 16) & 0xffL);< / p>
salida[j + 3] = (byte)((entrada >>> 24) & 0xffL
}
}
/*Decode sintetiza la matriz de bytes en una matriz larga en orden. Dado que el tipo largo de Java es de 64 bits,
solo sintetiza los 32 bits inferiores y los 32 superiores. los bits se borran de acuerdo con el propósito de la implementación original de C
*/
decodificación privada vacía (salida larga [], entrada byte [], int len) {
int i, j;
for (i = 0, j = 0; j < len; i++, j += 4)
salida = b2iu(entrada [j]) |
(b2iu(entrada[j + 1]) < < 8) |
(b2iu( entrada[j + 2]) << 16)|
(b2iu (entrada[j + 3]) << 24);
Retorno;
}
/*
b2iu está escrito por mí Un programa que "promueve" bytes al siguiente nivel, independientemente del signo.
b2iu es un programa que escribí para "promover" bytes a un nivel superior independientemente del signo, ya que Java no tiene operaciones sin firmar
*/
public static long b2iu(byte b) {
return b < 0 ?b & 0x7F + 128: b;
}
/*byteHEX() Uso para convertir números de tipo byte a representación ASCII hexadecimal ,
porque toString de bytes en Java no puede hacer esto y no tenemos C
sprintf( outbuf、"%02X",ib)
*/
cadena estática pública byteHEX(byte ib) {
char[] Dígito = { '0' ,'1','2','3','4',' 5','6','7','8','9',
'A','B ','C','D','E','F' } ;
char [] ob = nuevo char[2];
ob[0] = Dígito [(ib >>>4) &0X0F];
ob[1] = Dígito[ ib &0X0F];
Cadena s = nueva Cadena(ob);
return s;
}
public static void main(String args[]) {
MD5 m = new MD5();
if (Array.getLength(args) == 0) { // Si no hay argumentos, ejecute el Test Suite estándar
System.out.println("MD5 Test suite:
System.out.println("MD5 (\"); \"):"+m.getMD5ofStr(""));
System.out.println("MD5(\ "a\")："+m.getMD5ofStr("a"));
System.out.println("MD5(\"abc\")："+m.getMD5ofStr("a" ));
System.out.println("MD5 (\"\"/")："+m.getMD5ofStr("abc"));
System.out println("MD5(\"resumen del mensaje\")："+m.getMD5ofStr. ("resumen del mensaje"));
System.out.println("MD5(\"abcdefghijklmnopqrstuvwxyz\")：" +
m.getMD5ofStr("abcdefghijklmnopqrstuvwxyz"));
System.out.println("MD5("resumen del mensaje")：\ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789\")："+
p>m.getMD5ofStr("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz012 3
456789"));
}
else
System.out.println("MD5(" + args[0] + ") =" + m .getMD5ofStr(args[0]));
}
}
}
Usado en JSP
------------------------------------------------ - ---------------------------------
<%@ idioma de la página='java' % >
& lt;%@ página import='java.util .* '%>
<%@ página import='java.sql.*'%>
<%
<%
<%
String userid = request.getParameter("UserID" //Obtener la entrada del usuario UserID
);String contraseña = request.getParameter("Contraseña"); //Obtener la contraseña ingresada por el usuario
String pwdmd5 = oMD5.getMD5ofStr(contraseña) //calcular el valor MD5
<); p> PrintWriter rp = respuesta.getWriter();Class.forName(" sun.jdbc.odbc.JdbcOdbcDriver");
Conexión con = DriverManager.getConnection("jdbc: odbc: community", "", "");
Declaración stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("seleccione * de los usuarios donde userID = '" +userid+"' y pwdmd5= '")+ pwdmd5+"'");
if (rs.next())
{
rp.print(" Iniciar sesión OK ");
}
else
{
rp.print("Error de inicio de sesión");
}
stmt.close();
con.close();
%>
No estoy seguro...
Disponible en www.xuebc.com
Dirección original: /read.php?tid=434 encontrado.