Este artículo describe el método de implementación del algoritmo SHA-1 en Java. Compártelo para su referencia. El método de implementación específico es el siguiente:
Copie el código de la siguiente manera: clase pública sha1util {
Hexcase booleano final estático privado = falso;
Cadena final estática privada b64pad = "=";
Private estático final int chrsz = 8;
// Método para obtener el valor SHA-1 de la cadena
Public static string hex_sha1 (string s) {
s = (s == nulo)?
return binb2hex (core_sha1 (str2binb (s), s.length () * chrsz));
}
Cadena pública estática B64_HMAC_SHA1 (tecla de cadena, datos de cadena) {
return binb2b64 (core_hmac_sha1 (clave, datos));
}
Cadena estática pública B64_SHA1 (String S) {
s = (s == nulo)?
return binb2b64 (core_sha1 (str2binb (s), s.length () * chrsz));
}
cadena estática privada binb2b64 (int [] binarray) {
String tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/";
Cadena str = "";
binarray = strechbinarray (binarray, binarray.length * 4);
para (int i = 0; i <binary.length * 4; i += 3) {
int triplet = (((binarray [i >> 2] >> 8 * (3 - i % 4)) y 0xff) << 16)
|
|
para (int j = 0; j <4; j ++) {
if (i * 8 + j * 6> binary.length * 32) {
str += b64pad;
} demás {
str += tab.charat ((triplete >> 6 * (3 - j)) y 0x3f);
}
}
}
devolver CleanB64Str (STR);
}
cadena estática privada binb2Hex (int [] binarray) {
Cadena hex_tab = hexcase?
Cadena str = "";
para (int i = 0; i <binary.length * 4; i ++) {
char a = (char) hex_tab.charat ((binarray [i >> 2] >> ((3 - i % 4) * 8 + 4)) & 0xf);
char b = (char) hex_tab.charat ((binarray [i >> 2] >> ((3 - i % 4) * 8)) y 0xf);
str + = (nuevo carácter (a) .ToString () + nuevo carácter (b) .ToString ());
}
regresar str;
}
cadena estática privada binb2str (int [] bin) {
Cadena str = "";
int mask = (1 << chrsz) - 1;
para (int i = 0; i <bin.length * 32; i += chrsz) {
str += (char) ((bin [i >> 5] >>> (24 - i % 32)) y máscara);
}
regresar str;
}
privado static int bit_rol (int num, int cnt) {
return (num << cnt) |
}
Cadena estática privada CleanB64Str (String Str) {
str = (str == nulo)?
int len = str.length ();
if (len <= 1) {
regresar str;
}
Char Trailchar = str.charat (len - 1);
String TrailStr = "";
para (int i = len-1; i> = 0 && str.charat (i) == Trailchar; i--) {
Trailstr += str.charat (i);
}
return str.substring (0, str.indexof (trailstr));
}
privado static int [] completo216 (int [] Oldbin) {
if (oldbin.length> = 16) {
devolver Oldbin;
}
int [] newbin = new int [16 - Oldbin.length];
para (int i = 0; i <newbin.length; newbin [i] = 0, i ++)
;
Devolver Concat (Oldbin, Newbin);
}
privado static int [] concat (int [] Oldbin, int [] newbin) {
int [] retval = new int [oldbin.length + newbin.length];
para (int i = 0; i <(oldbin.length+newbin.length); i ++) {
if (i <oldbin.length) {
Retval [i] = Oldbin [i];
} demás {
retval [i] = newbin [i - oldbin.length];
}
}
devolver return regresar;
}
privado static int [] core_hmac_sha1 (tecla de cadena, datos de cadena) {
Key = (Key == NULL)?
data = (data == nulo)?
int [] bkey = completo216 (str2binb (clave));
if (bkey.length> 16) {
bkey = core_sha1 (bkey, key.length () * chrsz);
}
int [] iPad = new int [16];
int [] opad = new int [16];
para (int i = 0; i <16; iPad [i] = 0, opad [i] = 0, i ++)
;
para (int i = 0; i <16; i ++) {
iPad [i] = bkey [i] ^ 0x36363636;
opad [i] = bkey [i] ^ 0x5c5c5c5c;
}
int [] hash = core_sha1 (concat (iPad, str2binb (data)), 512 + data.length () * chrsz);
return core_sha1 (concat (Opad, hash), 512 + 160);
}
privado static int [] core_sha1 (int [] x, int len) {
int tize = (len >> 5);
x = estiramiento de estiramiento (x, tamaño);
x [len >> 5] | = 0x80 << (24 - len % 32);
tamaño = ((len + 64 >> 9) << 4) + 15;
x = estiramiento de estiramiento (x, tamaño);
x [((len + 64 >> 9) << 4) + 15] = len;
int [] w = new int [80];
int a = 1732584193;
int b = -2717333879;
int c = -1732584194;
int d = 2717333878;
int e = -1009589776;
para (int i = 0; i <x.length; i += 16) {
int OldA = a;
int
int
int
int
para (int j = 0; j <80; j ++) {
if (j <16) {
w [j] = x [i + j];
} demás {
w [j] = rol (w [j - 3] ^ w [j - 8] ^ w [j - 14] ^ w [j - 16], 1);
}
int t = safe_add (safe_add (rol (a, 5), sha1_ft (j, b, c, d)), safe_add (safe_add (e, w [j]), sha1_kt (j)));
e = d;
d = c;
c = rol (b, 30);
b = a;
a = t;
}
a = safe_add (a, OldA);
b = safe_add (b, Oldb);
c = safe_add (c, oldc);
d = safe_add (d, oldd);
e = safe_add (e, Olde);
}
int [] retval = new int [5];
Retval [0] = a;
Retval [1] = B;
Retval [2] = C;
Retval [3] = D;
Retval [4] = E;
devolver return regresar;
}
vacío estático privado dotest () {
Clave de cadena = "tecla";
String data = "data";
System.out.println ("hex_sha1 (" + data + ") =" + hex_sha1 (data));
System.out.println ("B64_SHA1 (" + data + ") =" + B64_SHA1 (datos));
System.out.println ("str_sha1 (" + data + ") =" + str_sha1 (data));
System.out.println ("hex_hmac_sha1 (" + key + "," + data + ") =" + hex_hmac_sha1 (clave, datos));
System.out.println ("B64_HMAC_SHA1 (" + Key + "," + Data + ") =" + B64_HMAC_SHA1 (Key, Data));
System.out.println ("str_hmac_sha1 (" + key + "," + data + ") =" + str_hmac_sha1 (clave, datos));
}
public static String hex_hmac_sha1 (tecla de cadena, datos de cadena) {
return binb2hex (core_hmac_sha1 (clave, datos));
}
privado static int rol (int num, int cnt) {
return (num << cnt) |
}
privado static int safe_add (int x, int y) {
int lsw = (int) (x & 0xffff) + (int) (y & 0xffff);
int msw = (x >> 16) + (y >> 16) + (LSW >> 16);
return (MSW << 16) |
}
static private int sha1_ft (int t, int b, int c, int d) {
if (t <20)
retorno (B&C) |
if (t <40)
regreso b ^ c ^ d;
if (t <60)
retorno (B&C) |
regreso b ^ c ^ d;
}
static private int sha1_kt (int t) {
Return (T <20)?
}
privado static boolean sha1_vm_test () {
return hexcase?
"A9993E364706816ABA3E25717850C26C9CD0D89D");
}
Cadena pública estática str_hmac_sha1 (tecla de cadena, datos de cadena) {
return binb2str (core_hmac_sha1 (clave, datos));
}
Cadena pública estática str_sha1 (String S) {
s = (s == nulo)?
return binb2str (core_sha1 (str2binb (s), s.length () * chrsz));
}
privado static int [] str2binb (string str) {
str = (str == nulo)?
int [] tmp = new int [str.length () * chrsz];
int mask = (1 << chrsz) - 1;
para (int i = 0; i <str.length () * chrsz; i += chrsz) {
tmp [i >> 5] | = ((int) (str.charat (i / chrsz)) y máscara) << (24 - i % 32);
}
int len = 0;
para (int i = 0; i <tmp.length && tmp [i]! = 0; i ++, len ++)
;
int [] bin = new int [len];
para (int i = 0; i <len; i ++) {
bin [i] = tmp [i];
}
Bin de regreso;
}
Private static int [] stretchbinarray (int [] Oldbin, int size) {
int Currlen = Oldbin.length;
if (currlen> = size + 1) {
devolver Oldbin;
}
int [] newbin = new int [size + 1];
para (int i = 0; i <size; newbin [i] = 0, i ++)
;
para (int i = 0; i <Currlen; i ++) {
Newbin [i] = Oldbin [i];
}
devolver newbin;
}
public static void main (string args []) {
System.out.println ("El valor SHA1 del administrador es:" + hex_sha1 ("admin") + ", longitud =" + hex_sha1 ("admin"). Longitud ());
}
}
Espero que este artículo sea útil para la programación Java de todos.