Cifrado MD5 variable (implementación de Java)
El significado de variable aquí es muy simple, es decir, el resultado final del cifrado es variable y no necesita implementarse de acuerdo con el cifrado MD estándar. La clase MessageDigest en la seguridad de la biblioteca de clases de Java proporciona soporte. para el cifrado MD y es muy conveniente de implementar. Para lograr más efectos, podemos diseñar la clase de herramienta MD de la siguiente manera
Código Java
paquete ** ** util <; /p>
importar seguridad java MessageDigest
/**
* El método de cifrado MD estándar es procesado por la clase MessageDigest de la seguridad. paquete de la biblioteca de clases java
* @author Sarin
*/
public class MD {
/**
* Método para obtener la contraseña de cifrado MD
* /
public static String getMD ofStr(String origString) {
String origMD = null <; /p>
intentar {
MessageDigest md = MessageDigest getInstance( MD
byte[] resultado = md digest(origString getBytes()); p>origMD = byteArray HexStr(resultado);
} catch (Excepción e) {
e printStackTrace();
}
return origMD;
}
/**
* Método para obtener la contraseña de MD procesando una matriz de bytes
*/
cadena estática privada byteArray HexStr(byte[] bs) {
p>
StringBuffer *** = new StringBuffer();
for (byte b) : bs) {
*** append(byte HexStr(b));
}
return *** toString();
}
/**
* Bytes Cambio estándar al método hexadecimal
*/
byte de cadena estática privada HexStr( byte b) {
Cadena hexStr = null
int n = b;
if (n lt; ) {
/ /Si necesita personalizar el cifrado, modifique este algoritmo de cambio
n = b amp;
ase();
}
/**
* Proporcionar un método de cifrado múltiple MD
*/
cadena estática pública getMD ofStr(String origString int times) {
String md = getMD ofStr(origString
for (int i = ; i lt; times ; i ) {
md = getMD deStr(md);
}
return getMD deStr(md);
}
;/**
* Método de verificación de contraseña
*/
pública estática booleana verificarContraseña(String inputStr String MD Code) {
Devuelve getMD ofStr(inputStr) es igual (Código MD);
}
/**
* Recargar una contraseña para múltiples cifrados Método de verificación
*/
público estático booleano verificarContraseña(String inputStr String MD Code int times) {
return getMD ofStr(inputStr times) es igual(MD Code
}
/**
* Proporcionar una función principal de prueba
*/
public static void main( String[] args) {
Sistema fuera println(: getMD ofStr());
Sistema fuera println(: getMD ofStr());
Sistema out println(sarin: getMD ofStr(sarin));
Sistema out println(: getMD ofStr()
}
}
Se puede ver que el proceso de implementación es muy simple porque la biblioteca de clases de Java proporciona soporte de procesamiento. Sin embargo, debe quedar claro que la contraseña generada de esta manera no es un código MD estándar y debe cambiarse para obtenerla. el estándar Este es el punto clave del programa de código MD ¿Cómo se puede cambiar? ¿Ajustar el algoritmo de cambio no lo haría variable? Puede obtener la contraseña de bits sin cambiar. Este no es un cifrado estándar siempre que los procesos de cifrado y verificación utilicen el mismo algoritmo.
El cifrado MD sigue siendo muy seguro, al igual que CMD, ese descifrado exhaustivo es único. Si el resultado del cifrado MD estándar se realiza después de personalizar el algoritmo de cambio, ¿seguirá siendo válido? Se puede decir que no hay solución, por lo que MD es muy seguro y confiable.
Para cambiarlo, también proporciona múltiples métodos de cifrado. Puede continuar con MD sobre la base de MD, que es. MD el resultado del primer cifrado Bueno, ¿cómo descifrarlo así? No tiene sentido.
Es seguro y confiable usarlo en sistemas MIS. Damos la bienvenida a los intercambios y esperamos que sea útil para los usuarios.
Nosotros.
Finalmente, eche un vistazo a la clase implementada por el algoritmo de cifrado MD. Es muy grande
Código Java
import java lang reflect *; *
* ******************************************* **** *
* La clase md implementa el algoritmo de resumen de mensajes MD en el RFC enviado por RSA Data Security Inc al IETF
*
* * *******************************************
* /
public class MD {
/* El siguiente S S es en realidad una matriz *, que se implementa usando #define en la implementación original de C
Implementarlos como static final aquí significa que la función de solo lectura se puede compartir entre múltiples Instancias en el mismo espacio de proceso
static final int S =
static final int. S = ;
int final estático S = ;
int final estático S = ; final int S = ;
estático final int S = ;
estático final int S =
estático final int S = ; >estático final int S = ;
estático final int S = ;
estático final int S =
estático final int S = ;
int final estático S = ;
int final estático S = ;
int final estático S = ;
byte final estático[] PADDING = {
};
/* Los siguientes tres miembros se utilizan en el proceso de cálculo de MD. Los datos principales se definen en la estructura MD _CTX en la implementación original de C.
*/
privado largo[] estado = nuevo largo[]; / / estado (ABCD)
privado largo[ ] recuento = nuevo largo[ ]; // número de bits módulo ^ (l *** primero)
byte privado[] buffer = nuevo byte[ ] // búfer de entrada
representación ASCII
*/
public S
tring digestHexStr;
/* digest es la representación interna hexadecimal del último resultado del cálculo, que representa el valor MD del bit
*/
byte privado. [] digest = new byte[ ];
/*
getMD ofStr es el parámetro de entrada del método público principal de la clase MD. El parámetro de entrada es la cadena que desea realizar la transformación MD.
Lo que se devuelve es el resultado transformado. Este resultado se obtiene del miembro público *** digestHexStr.
*/
public String getMD ofStr(String inbuf) {
md Init()
md Update(inbuf getBytes( ) inbuf longitud());
md Final();
digestHexStr =
for (int i = ; i lt; ; i ) {
digestHexStr = byteHEX(digest[i]);
}
return digestHexStr
}
/ / Este es el constructor estándar de MD. Los JavaBeans requieren un constructor público sin parámetros
public MD () {
md Init();
Return;
}
/* md Init es una función de inicialización que inicializa variables centrales y carga números mágicos estándar*/
private void md Init () {
Count[ ] = L;
count[ ] = L;
///* Cargar constantes de inicialización mágica
State[ ] = x L;
estado[ ] = xefcdab L;
estado[ ] = x badcfeL
estado[ ] = x L; p> return;
}
/* F G H I es una función MD básica en la implementación original de MD en C porque
Se pueden implementar operaciones de bits simples. como macros por razones de eficiencia, en Java, los implementamos como métodos privados. Los nombres conservan el */ original en C.
private long F(long x long y long z) {
<. p> return (x amp; y) | ((~x) amp; z);}
privado largo G(largo x largo y largo z) {
return (x amp; z) | (y amp; (~z));
}
privado long H(long x long y long z) {
regresar x ^ y ^ z;
}
privado largo I(largo x largo y largo z) {
return y ^ (x | (~z));
}
/ *
FF GG HH y II llamarán a F G H I para más transformaciones
FF GG HH y II transformaciones para rondas y
La rotación está separada de la suma para evitar la reputación
*/
privado largo FF(largo a largo b largo c largo d largo x largo s largo ac) {
a = F(b c d) x ac;
a = ((int) a lt; lt; s) | ((int) a gt; gt; gt; ( s));
Devolver a;
}
privado largo GG(largo a largo b largo c largo d largo x largo s largo ac) {
a = G(b c d) x ac;
a = ((int) a lt; lt; s) | ((int) a gt; gt; gt; ( s)); p>
a = b;
return a;
}
privado largo HH(largo a largo b largo c largo d largo x largo s largo ac) {
a = H(b c d) x ac;
a = ((int) a lt; lt; s) ((int) a gt; gt ; gt; ( s));
a = b;
return 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 lt; lt; s) | ((int) a gt; gt; gt; ( s));
a = b;
devuelve a
}
/*
md Update es el proceso de cálculo principal de MD. inbuf es la cadena de bytes que se va a transformar. inputlen es la longitud.
md init debe llamarse antes de. La función es llamada por getMD ofStr. Por lo tanto, está diseñada para ser privada
*/
private void md Update(byte[] inbuf int inputLen) {
p>
byte[] bloque = nuevo byte[];
nt[ ] gt; gt; ) amp;
// /* Actualizar número de bits */
if ((count[ ] = (inputLen lt; lt; )) lt; (inputLen lt; lt; ))
cuenta[ ] ;
cuenta[ ] = (entradaLen gt; gt; gt;
);partLen = index;
// Transforma tantas veces como sea posible
if (inputLen gt; = partLen) {
md Memcpy(buffer inbuf index partLen);
md Transform(buffer);
for (i = partLen; i lt; inputLen; i = ) {
md Memcpy(bloque). inbuf i );
md Transform(bloque);
}
índice =
} else
i = ;
///* Entrada restante del búfer */
md Memcpy(índice de entrada del búfer i inputLen i
}
/*
md Final organiza y completa los resultados de salida
*/
private void md Final() {
byte [] bits = nuevo byte[ ];
int index padLen
///* Guardar número de bits */
Codificar(recuento de bits) );
///* Rellenar hasta mod
index = (int) (count[ ] gt; gt; gt; ) amp x f; > padLen = (index lt; ) ? (index): (index);
md Update(PADDING padLen);
///* Agregar longitud (antes del relleno) */
md Update(bits);
///* Almacenar estado en resumen */
Encode(estado de resumen
); }
/* md Memcpy es una función de copia en bloque utilizada internamente de una matriz de bytes, que comienza desde las entradas de la entrada y copia la longitud de longitud
bytes a la posición de salida del salida
*/
private void md Memcpy(byte[] salida byte[] entrada int outpos int inpos int len) {
int i
;
for (i = ; i lt; len; i )
salida[outpos i] = entrada[inpos i]
}
/*
md Transform es el programa de transformación central de MD. El bloque de llamada md Update son los bytes originales del bloque.
*/
private void md Transform(bloque de bytes[]) {
long a = estado[ ] b = estado[ ] c = estado[ ] d = estado[ ]; ] x = new long[ ];
Decodificar(x bloque
/* Redondo */
a = FF(a b c d x[ ] S xd aa L); /* */
d = FF(d a b c x[ ] S xe c b L); /* */
c = FF(c d a b x[ ] S x dbL); /* * /
b = FF(b c d a x[ ] S xc bdceeeL); /* */
a = FF(a b c d x[ ] S xf c fafL /* *); /
p>d = FF(d a b c x[ ] S x c aL); /* */
c = FF(c d a b x[ ] S xa L); /p>
b = FF(b c d x[ ] S xfd L); /* */
a = FF(a b c d x[ ] S x d L); p>d = FF (d a b c x[ ] S x b f afL); /* */
c = FF(c d a b x[ ] S xffff bb L); = FF(b c d a x[ ] S x cd beL); /* */
a = FF(a b c d x[ ] S x b L); d a b c x[ ] S xfd L); /* */
c = FF(c d a b x[ ] S xa eL); /* */
b = FF(b c d a x[ ] S); x b L); / * */
/* Redondo */
a = GG(a b c d x[ ] S xf e L); > d = GG( d a b c x[ ] S x c b L); /* */
c = GG(c d a b x[ ] S x e a L); (b c d a x[ ] S xe b c aaL); [ ] S x L); /* */
c
= GG(c d a b x[ ] S xd a e L); /* */
b = GG(b c d a x[ ] S xe d fbc L /* */
a = GG(a b c d x[ ] S x e cde L); /* */
d = GG(d a b c x[ ] S xc d L); /* */
c = GG( c d a b x[ ] S xf d d L); /* */
b = GG(b c d a x[ ] S x a edL /* */
a = GG(a b c d x[ ] S xa e e L); /* */
d = GG(d a b c x[ ] S xfcefa f L); /* */
c = GG(c d a b x[ ] S x f d L); /* */
b = GG(b c d a x[ ] S x d a c aL /* */
/* Redondo */
a); = HH(a b c d x[ ] S xfffa L); /* */
d = HH(d a b c x[ ] S x f L); /* */
c = HH(c d a b x); [ ] S x d d L); /* */
b = HH(b c d a x[ ] S xfde cL /* */
a = HH(a b c d x[ ] S xa); beea L); /* */
d = HH(d a b c x[ ] S x bdecfa L); /* */
c = HH(c d a b x[ ] S xf bb b L); /* */
b = HH(b c d a x[ ] S xbebfbc L); /* */
a = HH(a b c d x[ ] S x b ec L); /* */
d = HH(d a b c x[ ] S xeaa faL); /* */
c = HH(c d a b x[ ] S xd ef L /* *); /
b = HH(b c d a x[ ] S x d L); /* */
a = HH(a b c d x[ ] S xd d d L); p> p>
d = HH(d a b c x[ ] S x fa cf L); /* */
c = HH(c d a b x[ ] S x fa cf L /* */);
p>
b = HH(b c d a x[ ] S xc ac L /* */
/* Redondo */
a =); II(a b c d x[ ] S xf L); /* */
d = II(d a b c x[ ] S x aff L); /* */
c = II(c d a b x) [ ] S xab a L) ; /* */
b = I
I(b c d a x[ ] S xfc a L); /* */
a = II(a b c d x[ ] S x b c L); /* */
d = II(d a b c x); [ ] S x f ccc L); /* */
c = II(c d a b x[ ] S xffeff dL); /* */
b = II(b c d a x[ ] S x dd L /* */
a = II(a b c d x[ ] S x fa e fL /* */
d = II(d a b c x[ ] S xfe); ce e L); /* */
c = II(c d a b x[ ] S xa L /* */
b = II(b c d a x[ ] S x e a L); ; /* */
a = II(a b c x[ ] S xf e L); /* */
d = II(d a b c x[ ] S xbd af L); * */
c = II(c d a b x[ ] S x ad d bbL); /* */
b = II(b c d a x[ ] S xeb d L /*); */
estado[ ] = a;
estado[ ] = b;
estado[ ] =
estado[; ] = d;
}
/*Encode divide la matriz larga en matrices de bytes en orden porque el tipo largo de Java es bit
Solo se divide el bit. se adapta al propósito de la implementación original de C
*/
private void Encode(byte[] salida long[] entrada int len) {
int i j;
for (i = j = ; j lt; len; i j = ) {
salida[j] = (byte) (entrada[i] amp; xffL
salida[j ] = (byte) ((entrada[i] gt; gt; gt; ) amp; xffL
salida[j ] = (byte) ((entrada[); i ] gt; gt; gt; ) amp; xffL);
Salida[j ] = (byte) ((entrada[i] gt; gt; gt; ) amp;
}
}
/*Decode sintetiza la matriz de bytes en una matriz larga en orden porque el tipo largo de Java es bit
Solo sintetiza bits bajos Los bits altos se borran para adaptarse el propósito de la implementación original de C
*/
private void Decode(long[] byte de salida[] entrada int len) {
int i j
para (i = j = ; j lt;
len; i j = )
salida[i] = b iu(entrada[j]) | (b iu(entrada[j]) lt; lt; ) (b iu(entrada[j]) lt; lt; )
| (b iu(entrada[j]) lt; lt;
retorno
}
/*
b iu es un programa que escribí para "actualizar" bytes de acuerdo con el principio de no considerar el signo, porque Java no tiene operaciones sin firmar
*/ < / p>
public static long b iu(byte b) {
return b lt ? > /*byteHEX() se utiliza para convertir un número de tipo byte en una representación ASCII hexadecimal
Porque byte's toString en Java no puede lograr esto y no lo tenemos en lenguaje C
sprintf(outbuf ;
char[] ob = nuevo char[ ];
ob[ ] = Dígito[(ib gt; gt; gt; ) amp; X F];
ob[ ] = Dígito[ib amp; p>
public static void main(String args[]) {
MD m = new MD (); p> if (Array getLength(args) == ) { / /Si no hay parámetros, ejecute el Test Suite estándar
System out println( MD Test suite:
); Salida del sistema println( MD (\ \ ): m getMD ofStr( ));
Salida del sistema println( MD (\ a\ ): m getMD ofStr( a )); Salida del sistema println( MD (\ abc\ ): m getMD ofStr( abc )
Salida del sistema println( MD (\ \ ): m getMD ofStr()
); Salida del sistema println( MD (\ \ ): m getMD ofStr());
Salida del sistema println( MD (\ resumen del mensaje\): m getMD ofStr( resumen del mensaje )); p>Sistema fuera println( MD (\abcdefghijklmnopqrs
tuvwxyz\ ): m getMD ofStr( abcdefghijklmnopqrstuvwxyz ));
Sistema fuera println( MD (\ ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz \ ):
ijklmnopqrstuvwxyz ));
Sistema fuera println( MD ( args[ ] )= m getMD ofStr(args[ ]));
} lishixinzhi/Article/program/Java/hx/ 201311/26604