Cet article décrit la méthode d'implémentation de l'algorithme de cryptage SHA-1 dans JavaScript. Partagez-le pour votre référence. La méthode de mise en œuvre spécifique est la suivante:
Just Call Method: HEX_SHA1.
Copiez le code comme suit: / *
*
* Une implémentation JavaScript de l'algorithme de hachage sécurisé, SHA-1, tel que défini
* Dans FIPS Pub 180-1
*
* Par Lizq
*
* 2006-11-11
*
* /
/ *
*
* Variables configurables.
*
* /
var hexcase = 0; / * Format de sortie hexadécimal. 0 - minuscules; 1 - majuscules * /
var chrsz = 8; / * bits par caractère d'entrée. 8 - ASCII; 16 - Unicode * /
/ *
*
* La fonction principale pour calculer le message du message
*
* /
fonction hex_sha1 (s) {
return binb2hex (core_sha1 (alignesha1 (s)));
}
/ *
*
* Effectuez un auto-test simple pour voir si la machine virtuelle fonctionne
*
* /
fonction sha1_vm_test () {
RETOUR HEX_SHA1 ("ABC") == "A9993E364706816ABA3E25717850C26C9CD0D89D";
}
/ *
*
* Calculez le SHA-1 d'un tableau de mots Big-Endan, et un peu longueur
*
* /
fonction core_sha1 (blockArray) {
var x = blockArray; // Ajouter un rembourrage
var w = tableau (80);
var a = 1732584193;
var b = -271733879;
var c = -1732584194;
var d = 271733878;
var e = -1009589776;
pour (var i = 0; i <x.length; i + = 16) // 512 bits 16 * 32 traitement à chaque fois
{
var olda = a;
var oldb = b;
var oldc = c;
var oldd = d;
var olde = e;
pour (var j = 0; j <80; j ++) // effectuer 80 étapes pour chaque 512 bits
{
si (j <16)
w [j] = x [i + j];
autre
w [j] = rol (w [j - 3] ^ w [j - 8] ^ w [j - 14] ^ w [j - 16], 1);
var 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);
}
retourner un nouveau tableau (a, b, c, d, e);
}
/ *
*
* Effectuez la fonction de combinaison de triplet appropriée pour le courant
* itération
*
* Renvoie la valeur de la fonction F correspondante
*
* /
fonction sha1_ft (t, b, c, d) {
si (t <20)
retour (b & c) | ((~ b) & d);
si (t <40)
retour b ^ c ^ d;
si (t <60)
retour (b & c) | (B&D) | (C&D);
retour b ^ c ^ d; // t <80
}
/ *
*
* Déterminez la constante supplémentaire appropriée pour l'itération actuelle
*
* Renvoie la valeur KT correspondante
*
* /
fonction sha1_kt (t) {
retour (t <20)? 1518500249: (t <40)? 1859775393: (t <60)? -1894007588: -899497514;
}
/ *
*
* Ajouter des entiers, enveloppé à 2 ^ 32. Cela utilise des opérations 16 bits en interne
*
* Travailler autour des bugs dans certains interprètes JS.
*
* Divisez le numéro 32 bits en 16 bits supérieur et le 16 bits inférieur respectivement pour l'addition, réalisant ainsi l'ajout de Mod 2 ^ 32
*
* /
fonction safe_add (x, y) {
var lsw = (x & 0xffff) + (y & 0xfff);
var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
retour (MSW << 16) | (lsw & 0xffff);
}
/ *
*
* Faites pivoter un numéro de 32 bits vers la gauche.
*
* Boucle binaire 32 bits Shift gauche
*
* /
fonction rol (num, cnt) {
return (num << cnt) | (num >>> (32 - cnt));
}
/ *
*
* Le SHA1 standard a besoin de la chaîne d'entrée pour s'adapter dans un bloc
*
* Cette fonction aligne la chaîne d'entrée pour répondre à l'exigence
*
* /
fonction aligneSha1 (str) {
var nblk = ((str.length + 8) >> 6) + 1, blks = nouveau tableau (nblk * 16);
pour (var i = 0; i <nblk * 16; i ++)
blks [i] = 0;
pour (i = 0; i <str.length; i ++)
blks [i >> 2] | = str.charcodeat (i) << (24 - (i & 3) * 8);
blks [i >> 2] | = 0x80 << (24 - (i & 3) * 8);
blks [nblk * 16 - 1] = str.length * 8;
retour blks;
}
/ *
*
* Convertissez un tableau de mots big-endian en une chaîne hexagonale.
*
* /
fonction binb2hex (binarray) {
var hex_tab = hexcase? "0123456789AbcDef": "0123456789ABCDEF";
var str = "";
pour (var i = 0; i <binary.length * 4; i ++) {
str + = hex_tab.charat ((binarray [i >> 2] >> ((3 - i% 4) * 8 + 4)) & 0xf) +
hex_tab.charat ((binarray [i >> 2] >> ((3 - i% 4) * 8)) & 0xf);
}
retour STR;
}
/ *
*
* Calculer MessagediGest en fonction du message source qui entrait
*
* /
fonction calcdigest () {
var digestm = hex_sha1 (document.shaform.sourcemesage.value);
document.shaform.MessagediGest.Value = Digestm;
}
J'espère que cet article sera utile à la programmation JavaScript de tous.