Este artigo descreve o método de implementar o algoritmo SHA-1 em Java. Compartilhe para sua referência. O método de implementação específico é o seguinte:
Copie o código da seguinte forma: classe pública sha1util {
hexcase booleano final estático privado = false;
String final estática privada B64pad = "=";
private estático final int chrsz = 8;
// Método para obter o valor SHA-1 da string
public static string hex_sha1 (strings s) {
s = (s == null)? "": s;
retornar binb2hex (core_sha1 (str2binb (s), s.length () * chrsz));
}
public static string b64_hmac_sha1 (chave de string, dados da string) {
retornar binb2b64 (core_hmac_sha1 (chave, dados));
}
public static string b64_sha1 (strings s) {
s = (s == null)? "": s;
Retorno Binb2B64 (Core_Sha1 (STR2BINB (S), S.Length () * Chrsz));
}
Private Static String Binb2b64 (int [] binarray) {
String tab = "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz0123456789+/";
String str = "";
binarray = strechbinArray (binarray, binarray.length * 4);
for (int i = 0; i <binário.length * 4; i += 3) {
int triplet = (((binary [i >> 2] >> 8 * (3 - i % 4)) e 0xff) << 16)
|.
|.
for (int j = 0; j <4; j ++) {
if (i * 8 + j * 6> binário.length * 32) {
str += b64pad;
} outro {
str += tab.charat ((trigêmeo >> 6 * (3 - j)) & 0x3f);
}
}
}
return limpob64str (str);
}
Private Static String binb2hex (int [] binarray) {
String hex_tab = hexcase?
String str = "";
for (int i = 0; i <binário.length * 4; i ++) {
char a = (char) hex_tab.charat ((binary [i >> 2] >> ((3 - i % 4) * 8 + 4)) e 0xf);
char b = (char) hex_tab.charat ((binary [i >> 2] >> ((3 - i % 4) * 8)) e 0xf);
str + = (novo caractere (a) .ToString () + novo caractere (b) .ToString ());
}
retornar str;
}
Private Static String Binb2str (int [] bin) {
String str = "";
int máscara = (1 << Chrsz) - 1;
for (int i = 0; i <bin.length * 32; i += chrsz) {
str += (char) ((bin [i >> 5] >>> (24 - i % 32)) e máscara);
}
retornar str;
}
private static int bit_rol (int num, int cnt) {
retornar (num << cnt) | (num >>> (32 - cnt));
}
String estática privada CleanB64str (String str) {
str = (str == nulo)? "": str;
int len = str.Length ();
if (len <= 1) {
retornar str;
}
Char Trailchar = Str.Charat (Len - 1);
String trackstr = "";
for (int i = len-1; i> = 0 && str.charat (i) == trackchar; i--) {
trackstr += str.Charat (i);
}
retornar str.substring (0, str.IndexOF (trackstr));
}
private static int [] completo216 (int [] Oldbin) {
if (Oldbin.Length> = 16) {
retornar Oldbin;
}
int [] newbin = new int [16 - Oldbin.length];
for (int i = 0; i <newbin.length; newbin [i] = 0, i ++)
;
Retornar Concat (Oldbin, Newbin);
}
private static int [] concat (int [] Oldbin, int [] newbin) {
int [] retVal = new int [Oldbin.length + newbin.length];
for (int i = 0; i <(Oldbin.length+newbin.length); i ++) {
if (i <Oldbin.length) {
retval [i] = Oldbin [i];
} outro {
retval [i] = newbin [i - Oldbin.length];
}
}
retorno de retorno de retorno;
}
private static int [] core_hmac_sha1 (chave de string, dados de string) {
chave = (chave == null)? "": chave;
dados = (dados == NULL)? "": dados;
int [] bkey = completo216 (str2binb (chave));
if (bkey.length> 16) {
bkey = core_sha1 (bkey, key.length () * chrsz);
}
int [] ipad = new int [16];
int [] opad = new int [16];
for (int i = 0; i <16; ipad [i] = 0, opad [i] = 0, i ++)
;
for (int i = 0; i <16; i ++) {
ipad [i] = bkey [i] ^ 0x36363636;
opad [i] = bkey [i] ^ 0x5c5c5c5c;
}
int [] hash = core_sha1 (concat (ipad, str2binb (dados)), 512 + data.length () * chrsz);
Return Core_Sha1 (Concat (Opad, Hash), 512 + 160);
}
private static int [] core_sha1 (int [] x, int len) {
int size = (len >> 5);
x = StretchBinArray (x, tamanho);
x [len >> 5] | = 0x80 << (24 - Len % 32);
tamanho = ((len + 64 >> 9) << 4) + 15;
x = StretchBinArray (x, tamanho);
x [((len + 64 >> 9) << 4) + 15] = len;
int [] w = novo int [80];
int a = 1732584193;
int b = -271733879;
int c = -1732584194;
int d = 271733878;
int e = -1009589776;
for (int i = 0; i <x.length; i += 16) {
int a Olde = a;
int oldB = b;
int anticc = c;
int Oldd = D;
int Olde = e;
for (int j = 0; j <80; j ++) {
if (j <16) {
w [j] = x [i + j];
} outro {
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 (spear_add (e, w [j]), sha1_kt (j)));
e = d;
d = c;
c = rol (b, 30);
b = a;
a = t;
}
a = safe_add (a, antiga);
b = safe_add (b, OldB);
c = safe_add (c, antigo);
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;
retorno de retorno de retorno;
}
private estático vazio dotest () {
String key = "key";
String data = "dados";
System.out.println ("hex_sha1 (" + dados + ") =" + hex_sha1 (dados));
System.out.println ("b64_sha1 (" + dados + ") =" + b64_sha1 (dados));
System.out.println ("str_sha1 (" + dados + ") =" + str_sha1 (dados));
System.out.println ("hex_hmac_sha1 (" + key + "," + dados + ") =" + hex_hmac_sha1 (chave, dados));
System.out.println ("b64_hmac_sha1 (" + key + "," + dados + ") =" + b64_hmac_sha1 (chave, dados));
System.out.println ("str_hmac_sha1 (" + key + "," + dados + ") =" + str_hmac_sha1 (chave, dados));
}
public static string hex_hmac_sha1 (chave de string, dados de string) {
retornar binb2hex (core_hmac_sha1 (chave, dados));
}
private static int rol (int num, int cnt) {
retornar (num << cnt) | (num >>> (32 - cnt));
}
private static int safe_add (int x, int y) {
int lsw = (int) (x & 0xffff) + (int) (y & 0xffff);
int ms = (x >> 16) + (y >> 16) + (LSW >> 16);
Retorno (RSW << 16) | (LSW & 0XFFFF);
}
private static int sha1_ft (int t, int b, int c, int d) {
se (t <20)
Retorno (B&C) |
se (t <40)
retornar b ^ c ^ d;
se (t <60)
Retorno (B&C) |
retornar b ^ c ^ d;
}
private static int sha1_kt (int t) {
Retorno (T <20)?
}
private estático booleano sha1_vm_test () {
Retorno HexCase?
"A9993E364706816ABA3E25717850C26C9CD0D89D");
}
public static string str_hmac_sha1 (chave de string, dados de string) {
retornar binb2str (core_hmac_sha1 (chave, dados));
}
public static string str_sha1 (strings) {
s = (s == null)? "": s;
retorno binb2str (core_sha1 (str2binb (s), s.length () * chrsz));
}
private static int [] str2binb (string str) {
str = (str == nulo)? "": str;
int [] tmp = new int [str.Length () * Chrsz];
int máscara = (1 << Chrsz) - 1;
for (int i = 0; i <str.Length () * Chrsz; i += Chrsz) {
tmp [i >> 5] | = ((int) (str.charat (i / chrsz) e máscara) << (24 - i % 32);
}
int len = 0;
for (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];
}
lixo de retorno;
}
private static int [] alongbinarray (int [] Oldbin, int size) {
int currlen = Oldbin.length;
if (currlen> = size + 1) {
retornar Oldbin;
}
int [] newbin = new int [tamanho + 1];
for (int i = 0; i <tamanho; newbin [i] = 0, i ++)
;
for (int i = 0; i <currlen; i ++) {
newbin [i] = Oldbin [i];
}
retornar Newbin;
}
public static void main (string args []) {
System.out.println ("O valor do SHA1 do administrador é:" + hex_sha1 ("admin") + ", length =" + hex_sha1 ("admin"). Length ());
}
}
Espero que este artigo seja útil para a programação Java de todos.