La technologie de cryptage multiple MD5 et SHA256 d'ASP obtient le type de cryptage basé sur la chaîne. Il s'agit d'un cryptage mixte et il n'y a aucun espoir de profits énormes ! Portable vers C#/C/C++, ASP.NET, VB.NET Ou d'autres types de langages sont actuellement disponibles : algorithme MD5, algorithme SHA256, MD5 d'abord puis SHA256, d'abord SHA256 puis MD5, deux fois MD5, deux fois SHA256, d'abord 8 bits d'algorithme MD5 puis 8 bits d'algorithme SHA256, d'abord 8 bits de l'algorithme SHA256 Le dernier algorithme MD5 8 bits, prenant la valeur AscW du dernier caractère du mot de passe et le reste de 8 comme coefficient du schéma de cryptage, cryptage MD5 16 bits, Cryptage MD5 32 bits, cryptage SHA256 8 bits, cryptage SHA256 16 bits, cryptage SHA256 24 bits, cryptage SHA256 32 bits, cryptage SHA256 40 bits, SHA 48 bits 256, cryptage SHA256 56 bits, cryptage SHA256 64 bits et autres algorithmes Après avoir lu le code source, vous pouvez personnaliser davantage de combinaisons de cryptage et d'algorithmes de cryptage. Dites adieu au craquage par force brute de l'algorithme MD5 ~~.
Code source de cls_Encrypt.asp :
Copiez le code comme suit :
<%
Const privée BITS_TO_A_BYTE = 8
Const privé BYTES_TO_A_WORD = 4
Const privée BITS_TO_A_WORD = 32
Classe Cls_Encrypt
Privé MD5_m_lOnBits(30)
Privé MD5_m_l2Power(30)
Privé SHA256_m_lOnBits(30)
Privé SHA256_m_l2Power(30)
Privé SHA256_K(63)
Sous-classe privée_Initialize
MD5_m_lOnBits(0) = CLng(1)
MD5_m_lOnBits(1) = CLng(3)
MD5_m_lOnBits(2) = CLng(7)
MD5_m_lOnBits(3) = CLng(15)
MD5_m_lOnBits(4) = CLng(31)
MD5_m_lOnBits(5) = CLng(63)
MD5_m_lOnBits(6) = CLng(127)
MD5_m_lOnBits(7) = CLng(255)
MD5_m_lOnBits(8) = CLng(511)
MD5_m_lOnBits(9) = CLng(1023)
MD5_m_lOnBits(10) = CLng(2047)
MD5_m_lOnBits(11) = CLng(4095)
MD5_m_lOnBits(12) = CLng(8191)
MD5_m_lOnBits(13) = CLng(16383)
MD5_m_lOnBits(14) = CLng(32767)
MD5_m_lOnBits(15) = CLng(65535)
MD5_m_lOnBits(16) = CLng(131071)
MD5_m_lOnBits(17) = CLng(262143)
MD5_m_lOnBits(18) = CLng(524287)
MD5_m_lOnBits(19) = CLng(1048575)
MD5_m_lOnBits(20) = CLng(2097151)
MD5_m_lOnBits(21) = CLng(4194303)
MD5_m_lOnBits(22) = CLng(8388607)
MD5_m_lOnBits(23) = CLng(16777215)
MD5_m_lOnBits(24) = CLng(33554431)
MD5_m_lOnBits(25) = CLng(67108863)
MD5_m_lOnBits(26) = CLng(134217727)
MD5_m_lOnBits(27) = CLng(268435455)
MD5_m_lOnBits(28) = CLng(536870911)
MD5_m_lOnBits(29) = CLng(1073741823)
MD5_m_lOnBits(30) = CLng(2147483647)
MD5_m_l2Power(0) = CLng(1)
MD5_m_l2Power(1) = CLng(2)
MD5_m_l2Power(2) = CLng(4)
MD5_m_l2Power(3) = CLng(8)
MD5_m_l2Power(4) = CLng(16)
MD5_m_l2Power(5) = CLng(32)
MD5_m_l2Power(6) = CLng(64)
MD5_m_l2Power(7) = CLng(128)
MD5_m_l2Power(8) = CLng(256)
MD5_m_l2Power(9) = CLng(512)
MD5_m_l2Power(10) = CLng(1024)
MD5_m_l2Power(11) = CLng(2048)
MD5_m_l2Power(12) = CLng(4096)
MD5_m_l2Power(13) = CLng(8192)
MD5_m_l2Power(14) = CLng(16384)
MD5_m_l2Power(15) = CLng(32768)
MD5_m_l2Power(16) = CLng(65536)
MD5_m_l2Power(17) = CLng(131072)
MD5_m_l2Power(18) = CLng(262144)
MD5_m_l2Power(19) = CLng(524288)
MD5_m_l2Power(20) = CLng(1048576)
MD5_m_l2Power(21) = CLng(2097152)
MD5_m_l2Power(22) = CLng(4194304)
MD5_m_l2Power(23) = CLng(8388608)
MD5_m_l2Power(24) = CLng(16777216)
MD5_m_l2Power(25) = CLng(33554432)
MD5_m_l2Power(26) = CLng(67108864)
MD5_m_l2Power(27) = CLng(134217728)
MD5_m_l2Power(28) = CLng(268435456)
MD5_m_l2Power(29) = CLng(536870912)
MD5_m_l2Power(30) = CLng(1073741824)
SHA256_m_lOnBits(0) = CLng(1)
SHA256_m_lOnBits(1) = CLng(3)
SHA256_m_lOnBits(2) = CLng(7)
SHA256_m_lOnBits(3) = CLng(15)
SHA256_m_lOnBits(4) = CLng(31)
SHA256_m_lOnBits(5) = CLng(63)
SHA256_m_lOnBits(6) = CLng(127)
SHA256_m_lOnBits(7) = CLng(255)
SHA256_m_lOnBits(8) = CLng(511)
SHA256_m_lOnBits(9) = CLng(1023)
SHA256_m_lOnBits(10) = CLng(2047)
SHA256_m_lOnBits(11) = CLng(4095)
SHA256_m_lOnBits(12) = CLng(8191)
SHA256_m_lOnBits(13) = CLng(16383)
SHA256_m_lOnBits(14) = CLng(32767)
SHA256_m_lOnBits(15) = CLng(65535)
SHA256_m_lOnBits(16) = CLng(131071)
SHA256_m_lOnBits(17) = CLng(262143)
SHA256_m_lOnBits(18) = CLng(524287)
SHA256_m_lOnBits(19) = CLng(1048575)
SHA256_m_lOnBits(20) = CLng(2097151)
SHA256_m_lOnBits(21) = CLng(4194303)
SHA256_m_lOnBits(22) = CLng(8388607)
SHA256_m_lOnBits(23) = CLng(16777215)
SHA256_m_lOnBits(24) = CLng(33554431)
SHA256_m_lOnBits(25) = CLng(67108863)
SHA256_m_lOnBits(26) = CLng(134217727)
SHA256_m_lOnBits(27) = CLng(268435455)
SHA256_m_lOnBits(28) = CLng(536870911)
SHA256_m_lOnBits(29) = CLng(1073741823)
SHA256_m_lOnBits(30) = CLng(2147483647)
SHA256_m_l2Power(0) = CLng(1)
SHA256_m_l2Power(1) = CLng(2)
SHA256_m_l2Power(2) = CLng(4)
SHA256_m_l2Power(3) = CLng(8)
SHA256_m_l2Power(4) = CLng(16)
SHA256_m_l2Power(5) = CLng(32)
SHA256_m_l2Power(6) = CLng(64)
SHA256_m_l2Power(7) = CLng(128)
SHA256_m_l2Power(8) = CLng(256)
SHA256_m_l2Power(9) = CLng(512)
SHA256_m_l2Power(10) = CLng(1024)
SHA256_m_l2Power(11) = CLng(2048)
SHA256_m_l2Power(12) = CLng(4096)
SHA256_m_l2Power(13) = CLng(8192)
SHA256_m_l2Power(14) = CLng(16384)
SHA256_m_l2Power(15) = CLng(32768)
SHA256_m_l2Power(16) = CLng(65536)
SHA256_m_l2Power(17) = CLng(131072)
SHA256_m_l2Power(18) = CLng(262144)
SHA256_m_l2Power(19) = CLng(524288)
SHA256_m_l2Power(20) = CLng(1048576)
SHA256_m_l2Power(21) = CLng(2097152)
SHA256_m_l2Power(22) = CLng(4194304)
SHA256_m_l2Power(23) = CLng(8388608)
SHA256_m_l2Power(24) = CLng(16777216)
SHA256_m_l2Power(25) = CLng(33554432)
SHA256_m_l2Power(26) = CLng(67108864)
SHA256_m_l2Power(27) = CLng(134217728)
SHA256_m_l2Power(28) = CLng(268435456)
SHA256_m_l2Power(29) = CLng(536870912)
SHA256_m_l2Power(30) = CLng(1073741824)
SHA256_K(0) = &H428A2F98
SHA256_K(1) = &H71374491
SHA256_K(2) = &HB5C0FBCF
SHA256_K(3) = &HE9B5DBA5
SHA256_K(4) = &H3956C25B
SHA256_K(5) = &H59F111F1
SHA256_K(6) = &H923F82A4
SHA256_K(7) = &HAB1C5ED5
SHA256_K(8) = &HD807AA98
SHA256_K(9) = &H12835B01
SHA256_K(10) = &H243185BE
SHA256_K(11) = &H550C7DC3
SHA256_K(12) = &H72BE5D74
SHA256_K(13) = &H80DEB1FE
SHA256_K(14) = &H9BDC06A7
SHA256_K(15) = &HC19BF174
SHA256_K(16) = &HE49B69C1
SHA256_K(17) = &HEFBE4786
SHA256_K(18) = &HFC19DC6
SHA256_K(19) = &H240CA1CC
SHA256_K(20) = &H2DE92C6F
SHA256_K(21) = &H4A7484AA
SHA256_K(22) = &H5CB0A9DC
SHA256_K(23) = &H76F988DA
SHA256_K(24) = &H983E5152
SHA256_K(25) = &HA831C66D
SHA256_K(26) = &HB00327C8
SHA256_K(27) = &HBF597FC7
SHA256_K(28) = &HC6E00BF3
SHA256_K(29) = &HD5A79147
SHA256_K(30) = &H6CA6351
SHA256_K(31) = &H14292967
SHA256_K(32) = &H27B70A85
SHA256_K(33) = &H2E1B2138
SHA256_K(34) = &H4D2C6DFC
SHA256_K(35) = &H53380D13
SHA256_K(36) = &H650A7354
SHA256_K(37) = &H766A0ABB
SHA256_K(38) = &H81C2C92E
SHA256_K(39) = &H92722C85
SHA256_K(40) = &HA2BFE8A1
SHA256_K(41) = &HA81A664B
SHA256_K(42) = &HC24B8B70
SHA256_K(43) = &HC76C51A3
SHA256_K(44) = &HD192E819
SHA256_K(45) = &HD6990624
SHA256_K(46) = &HF40E3585
SHA256_K(47) = &H106AA070
SHA256_K(48) = &H19A4C116
SHA256_K(49) = &H1E376C08
SHA256_K(50) = &H2748774C
SHA256_K(51) = &H34B0BCB5
SHA256_K(52) = &H391C0CB3
SHA256_K(53) = &H4ED8AA4A
SHA256_K(54) = &H5B9CCA4F
SHA256_K(55) = &H682E6FF3
SHA256_K(56) = &H748F82EE
SHA256_K(57) = &H78A5636F
SHA256_K(58) = &H84C87814
SHA256_K(59) = &H8CC70208
SHA256_K(60) = &H90BEFFFA
SHA256_K(61) = &HA4506CEB
SHA256_K(62) = &HBEF9A3F7
SHA256_K(63) = &HC67178F2
Fin du sous-marin
Sous-classe privée_Terminate
Fin du sous-marin
'Fonction de tableau de conversion de transfert de caractères
Fonction privée ConvertToWordArray (byVal sMessage)
Dim lMessageLength
Dim lNombreDeMots
Faible lWordArray()
Dim lBytePosition
Dim lByteCount
Dim lWordCount
Const MODULUS_BITS = 512
Const CONGRUENT_BITS = 448
lMessageLength = Longueur(sMessage)
lNumberOfWords = (((lMessageLength + ((MODULUS_BITS - CONGRUENT_BITS) / BITS_TO_A_BYTE)) / (MODULUS_BITS / BITS_TO_A_BYTE)) + 1) * (MODULUS_BITS / BITS_TO_A_WORD)
ReDim lWordArray(lNumberOfWords - 1)
lBytePosition = 0
lByteCount = 0
Faire jusqu'à ce que lByteCount >= lMessageLength
lWordCount = lByteCount / BYTES_TO_A_WORD
lBytePosition = (lByteCount Mod BYTES_TO_A_WORD) * BITS_TO_A_BYTE
lWordArray(lWordCount) = lWordArray(lWordCount) ou LShift(Asc(Mid(sMessage, lByteCount + 1, 1)), lBytePosition)
lByteCount = lByteCount + 1
Boucle
lWordCount = lByteCount / BYTES_TO_A_WORD
lBytePosition = (lByteCount Mod BYTES_TO_A_WORD) * BITS_TO_A_BYTE
lWordArray(lWordCount) = lWordArray(lWordCount) ou LShift(&H80, lBytePosition)
lWordArray(lNumberOfWords - 2) = LShift(lMessageLength, 3)
lWordArray(lNumberOfWords - 1) = RShift(lMessageLength, 29)
ConvertToWordArray = lWordArray
Fonction de fin
'Fonction principale de décalage à gauche de la chaîne
Fonction privée LShift (byVal lValue, byVal iShiftBits)
Si iShiftBits = 0 Alors
LShift = lValeur
Fonction de sortie
SinonSi iShiftBits = 31 Alors
Si lValeur et 1 alors
LShift = &H80000000
Autre
LShift = 0
Fin si
Fonction de sortie
SinonSi iShiftBits < 0 ou iShiftBits > 31 Alors
Err.Raise 6
Fin si
Si (lValue et MD5_m_l2Power(31 - iShiftBits)) Alors
LShift = ((lValue And MD5_m_lOnBits(31 - (iShiftBits + 1))) * MD5_m_l2Power(iShiftBits)) ou &H80000000
Autre
LShift = ((lValue et MD5_m_lOnBits(31 - iShiftBits)) * MD5_m_l2Power(iShiftBits))
Fin si
Fonction de fin
'Fonction principale de décalage à droite de la chaîne
Fonction privée RShift (byVal lValue, byVal iShiftBits)
Si iShiftBits = 0 Alors
RShift = lValeur
Fonction de sortie
SinonSi iShiftBits = 31 Alors
Si lValue et &H80000000 alors
RSShift = 1
Autre
RSShift = 0
Fin si
Fonction de sortie
SinonSi iShiftBits < 0 ou iShiftBits > 31 Alors
Err.Raise 6
Fin si
RShift = (lValue et &H7FFFFFFE) / MD5_m_l2Power(iShiftBits)
Si (lValeur et &H80000000) Alors
RShift = (RShift ou (&H40000000 / MD5_m_l2Power(iShiftBits - 1)))
Fin si
Fonction de fin
'Conversion de décalage de chaîne, implémentée via les fonctions de décalage gauche et droite
Fonction privée RotateLeft (byVal lValue, byVal iShiftBits)
RotateLeft = LShift(lValue, iShiftBits) ou RShift(lValue, (32 - iShiftBits))
Fonction de fin
'Ajouter un codage hexadécimal non signé
Fonction privée AddUnsigned (byVal lX, byVal lY)
x4
y4
x8
y8
Dim lRésultat
lX8 = lX Et &H80000000
lY8 = lY et &H80000000
lX4 = lX Et &H40000000
lY4 = lY et &H40000000
lRésultat = (lX Et &H3FFFFFFF) + (lY Et &H3FFFFFFF)
Si lX4 et lY4 Alors
lRésultat = lRésultat Xor &H80000000 Xor lX8 Xor lY8
SinonSi lX4 ou lY4 Alors
Si lResult Et &H40000000 Alors
lRésultat = lRésultat Xor &HC0000000 Xor lX8 Xor lY8
Autre
lRésultat = lRésultat Xor &H40000000 Xor lX8 Xor lY8
Fin si
Autre
lRésultat = lRésultat Xou lX8 Xou lY8
Fin si
AddUnsigned = lResult
Fonction de fin
'MD5_FF,MD5_GG,MD5_HH,MD5_II Fonction d'encodage principale MD5
Sous-privé MD5_FF (a, b, c, d, x, s, ac)
a = AddUnsigned(a, AddUnsigned(AddUnsigned(MD5_F(b, c, d), x), ac))
a = RotationGauche(a, s)
a = AjouterUnsigned(a, b)
Fin du sous-marin
Sous-privé MD5_GG(a, b, c, d, x, s, ac)
a = AddUnsigned(a, AddUnsigned(AddUnsigned(MD5_G(b, c, d), x), ac))
a = RotationGauche(a, s)
a = AjouterUnsigned(a, b)
Fin du sous-marin
Sous-privé MD5_HH(a, b, c, d, x, s, ac)
a = AddUnsigned(a, AddUnsigned(AddUnsigned(MD5_H(b, c, d), x), ac))
a = RotationGauche(a, s)
a = AjouterUnsigned(a, b)
Fin du sous-marin
Sous-marin privé MD5_II (a, b, c, d, x, s, ac)
a = AddUnsigned(a, AddUnsigned(AddUnsigned(MD5_I(b, c, d), x), ac))
a = RotationGauche(a, s)
a = AjouterUnsigned(a, b)
Fin du sous-marin
'MD5_F,MD5_G,MD5_H,MD5_I Fonction de codage auxiliaire MD5
Fonction privée MD5_F(x, y, z)
MD5_F = (x et y) ou ((pas x) et z)
Fonction de fin
Fonction privée MD5_G(x, y, z)
MD5_G = (x et z) ou (y et (pas z))
Fonction de fin
Fonction privée MD5_H(x, y, z)
MD5_H = (x Xor y Xor z)
Fonction de fin
Fonction privée MD5_I(x, y, z)
MD5_I = (y Xor (x ou (Not z)))
Fonction de fin
'16 conversion de codage hexadécimal
Fonction privée WordToHex (byVal lValue)
Dim lOctet
Dim lCount
Pour lCount = 0 à 3
lByte = RShift(lValue, lCount * BITS_TO_A_BYTE) Et MD5_m_lOnBits(BITS_TO_A_BYTE - 1)
MotVersHex = MotVersHex & Droite(0 & Hex(lByte), 2)
Suivant
Fonction de fin
'Fonction principale MD5 MD5 (chaîne, bits d'encodage)
Fonction publique MD5 (byVal sMessage, byVal sType)
Dim x
Dim k
Faible AA
Dim BB
Faible CC
DimJJ
Atténuer un
Faible b
Faible c
Faible d
Const S11 = 7
Const S12 = 12
Const S13 = 17
Const S14 = 22
Const S21 = 5
Const S22 = 9
Const S23 = 14
Const S24 = 20
Const S31 = 4
Const S32 = 11
Const S33 = 16
Const S34 = 23
Const S41 = 6
Const S42 = 10
Const S43 = 15
Const S44 = 21
x = ConvertToWordArray(sMessage) 'Étape de chiffrement 1 : conversion du tableau
une = &H67452301
b = &HEFCDAB89
c = &H98BADCFE
d = &H10325476
Pour k = 0 À UBound(x) Étape 16
AA = un
BB = b
CC = c
DD = ré
'Étape 2 du cryptage : conversion du codage
MD5_FF a, b, c, d, x(k + 0), S11, &HD76AA478
MD5_FF d, une, b, c, x(k + 1), S12, &HE8C7B756
MD5_FFc, d, a, b, x(k + 2), S13, &H242070DB
MD5_FF b, c, d, a, x(k + 3), S14, &HC1BDCEEE
MD5_FF a, b, c, d, x(k + 4), S11, &HF57C0FAF
MD5_FF d, une, b, c, x(k + 5), S12, &H4787C62A
MD5_FFc, d, a, b, x(k + 6), S13, &HA8304613
MD5_FF b, c, d, a, x(k + 7), S14, &HFD469501
MD5_FF a, b, c, d, x(k + 8), S11, &H698098D8
MD5_FF d, une, b, c, x(k + 9), S12, &H8B44F7AF
MD5_FF c, d, a, b, x(k + 10), S13, &HFFFF5BB1
MD5_FF b, c, d, a, x(k + 11), S14, &H895CD7BE
MD5_FF a, b, c, d, x(k + 12), S11, &H6B901122
MD5_FF d, une, b, c, x(k + 13), S12, &HFD987193
MD5_FFc, d, a, b, x(k + 14), S13, &HA679438E
MD5_FF b, c, d, a, x(k + 15), S14, &H49B40821
MD5_GG a, b, c, d, x(k + 1), S21, &HF61E2562
MD5_GG d, une, b, c, x(k + 6), S22, &HC040B340
MD5_GG c, d, a, b, x(k + 11), S23, &H265E5A51
MD5_GG b, c, d, a, x(k + 0), S24, &HE9B6C7AA
MD5_GG a, b, c, d, x(k + 5), S21, &HD62F105D
MD5_GG d, une, b, c, x(k + 10), S22, &H2441453
MD5_GG c, d, a, b, x(k + 15), S23, &HD8A1E681
MD5_GG b, c, d, a, x(k + 4), S24, &HE7D3FBC8
MD5_GG a, b, c, d, x(k + 9), S21, &H21E1CDE6
MD5_GG d, une, b, c, x(k + 14), S22, &HC33707D6
MD5_GG c, d, a, b, x(k + 3), S23, &HF4D50D87
MD5_GG b, c, d, a, x(k + 8), S24, &H455A14ED
MD5_GG a, b, c, d, x(k + 13), S21, &HA9E3E905
MD5_GG d, a, b, c, x(k + 2), S22, &HFCEFA3F8
MD5_GG c, d, a, b, x(k + 7), S23, &H676F02D9
MD5_GG b, c, d, a, x(k + 12), S24, &H8D2A4C8A
MD5_HH a, b, c, d, x(k + 5), S31, &HFFFA3942
MD5_HH d, une, b, c, x(k + 8), S32, &H8771F681
MD5_HH c, d, a, b, x(k + 11), S33, &H6D9D6122
MD5_HH b, c, d, a, x(k + 14), S34, &HFDE5380C
MD5_HH a, b, c, d, x(k + 1), S31, &HA4BEEA44
MD5_HH d, une, b, c, x(k + 4), S32, &H4BDECFA9
MD5_HH c, d, a, b, x(k + 7), S33, &HF6BB4B60
MD5_HH b, c, d, a, x(k + 10), S34, &HBEBFBC70
MD5_HH a, b, c, d, x(k + 13), S31, &H289B7EC6
MD5_HH d, une, b, c, x(k + 0), S32, &HEAA127FA
MD5_HH c, d, a, b, x(k + 3), S33, &HD4EF3085
MD5_HH b, c, d, a, x(k + 6), S34, &H4881D05
MD5_HH a, b, c, d, x(k + 9), S31, &HD9D4D039
MD5_HH d, une, b, c, x(k + 12), S32, &HE6DB99E5
MD5_HH c, d, a, b, x(k + 15), S33, &H1FA27CF8
MD5_HH b, c, d, a, x(k + 2), S34, &HC4AC5665
MD5_II a, b, c, d, x(k + 0), S41, &HF4292244
MD5_II d, une, b, c, x(k + 7), S42, &H432AFF97
MD5_II c, d, a, b, x(k + 14), S43, &HAB9423A7
MD5_IIb, c, d, a, x(k + 5), S44, &HFC93A039
MD5_II a, b, c, d, x(k + 12), S41, &H655B59C3
MD5_II d, une, b, c, x(k + 3), S42, &H8F0CCC92
MD5_II c, d, a, b, x(k + 10), S43, &HFFEFF47D
MD5_II b, c, d, a, x(k + 1), S44, &H85845DD1
MD5_II a, b, c, d, x(k + 8), S41, &H6FA87E4F
MD5_II d, une, b, c, x(k + 15), S42, &HFE2CE6E0
MD5_IIc, d, a, b, x(k + 6), S43, &HA3014314
MD5_II b, c, d, a, x(k + 13), S44, &H4E0811A1
MD5_II a, b, c, d, x(k + 4), S41, &HF7537E82
MD5_II d, une, b, c, x(k + 11), S42, &HBD3AF235
MD5_II c, d, a, b, x(k + 2), S43, &H2AD7D2BB
MD5_II b, c, d, a, x(k + 9), S44, &HEB86D391
'Étape de chiffrement 3 : ajouter une conversion non signée
a = AjouterUnsigned(a, AA)
b = AjouterUnsigned(b, BB)
c = AjouterUnsigned(c, CC)
d = AjouterUnsigned(d, DD)
Suivant
Si sType = 32 Alors
'Étape de cryptage 4 : diviser et combiner chaque conversion hexadécimale à 8 chiffres
MD5 = LCase (MotVersHex(a) & MotVersHex(b) & MotVersHex(c) & MotVersHex(d))
Autre
MD5 = LCase (MotVersHex(b) & MotVersHex(c))
Fin si
Fonction de fin
Fonction privée SHA256_LShift (byVal lValue, byVal iShiftBits)
Si iShiftBits = 0 Alors
SHA256_LShift = lValeur
Fonction de sortie
SinonSi iShiftBits = 31 Alors
Si lValeur et 1 alors
SHA256_LSift = &H80000000
Autre
SHA256_LSift = 0
Fin si
Fonction de sortie
SinonSi iShiftBits < 0 ou iShiftBits > 31 Alors
Err.Raise 6
Fin si
Si (lValue et SHA256_m_l2Power(31 - iShiftBits)) Alors
SHA256_LShift = ((lValue et SHA256_m_lOnBits(31 - (iShiftBits + 1))) * SHA256_m_l2Power(iShiftBits)) ou &H80000000
Autre
SHA256_LShift = ((lValue et SHA256_m_lOnBits(31 - iShiftBits)) * SHA256_m_l2Power(iShiftBits))
Fin si
Fonction de fin
Fonction privée SHA256_RShift (byVal lValue, byVal iShiftBits)
Si iShiftBits = 0 Alors
SHA256_RShift = lValeur
Fonction de sortie
SinonSi iShiftBits = 31 Alors
Si lValue et &H80000000 alors
SHA256_RShift = 1
Autre
SHA256_RShift = 0
Fin si
Fonction de sortie
SinonSi iShiftBits < 0 ou iShiftBits > 31 Alors
Err.Raise 6
Fin si
SHA256_RShift = (lValue et &H7FFFFFFE) / SHA256_m_l2Power(iShiftBits)
Si (lValeur et &H80000000) Alors
SHA256_RShift = (SHA256_RShift ou (&H40000000 / SHA256_m_l2Power(iShiftBits - 1)))
Fin si
Fonction de fin
Fonction privée SHA256_AddUnsigned (byVal lX, byVal lY)
x4
y4
x8
y8
Dim lRésultat
lX8 = lX Et &H80000000
lY8 = lY et &H80000000
lX4 = lX Et &H40000000
lY4 = lY et &H40000000
lRésultat = (lX Et &H3FFFFFFF) + (lY Et &H3FFFFFFF)
Si lX4 et lY4 Alors
lRésultat = lRésultat Xor &H80000000 Xor lX8 Xor lY8
SinonSi lX4 ou lY4 Alors
Si lResult Et &H40000000 Alors
lRésultat = lRésultat Xor &HC0000000 Xor lX8 Xor lY8
Autre
lRésultat = lRésultat Xor &H40000000 Xor lX8 Xor lY8
Fin si
Autre
lRésultat = lRésultat Xou lX8 Xou lY8
Fin si
SHA256_AddUnsigned = lRésultat
Fonction de fin
Fonction privée SHA256_CH(x, y, z)
SHA256_Ch = ((x et y) Xor ((pas x) et z))
Fonction de fin
Fonction privée SHA256_Maj(x, y, z)
SHA256_Maj = ((x et y) Xor (x et z) Xor (y et z))
Fonction de fin
Fonction privée SHA256_S(x, n)
SHA256_S = (SHA256_RShift(x, (n et SHA256_m_lOnBits(4))) ou SHA256_LShift(x, (32 - (n et SHA256_m_lOnBits(4)))))
Fonction de fin
Fonction privée SHA256_R(x, n)
SHA256_R = SHA256_RShift(x, cLng(n et SHA256_m_lOnBits(4)))
Fonction de fin
Fonction privée SHA256_Sigma0(x)
SHA256_Sigma0 = (SHA256_S(x, 2) Xou SHA256_S(x, 13) Xou SHA256_S(x, 22))
Fonction de fin
Fonction privée SHA256_Sigma1(x)
SHA256_Sigma1 = (SHA256_S(x, 6) Xou SHA256_S(x, 11) Xou SHA256_S(x, 25))
Fonction de fin
Fonction privée SHA256_Gamma0(x)
SHA256_Gamma0 = (SHA256_S(x, 7) Xou SHA256_S(x, 18) Xou SHA256_R(x, 3))
Fonction de fin
Fonction privée SHA256_Gamma1(x)
SHA256_Gamma1 = (SHA256_S(x, 17) Xou SHA256_S(x, 19) Xou SHA256_R(x, 10))
Fonction de fin
Fonction privée SHA256_ConvertToWordArray (byVal sMessage)
Dim lMessageLength
Dim lNombreDeMots
Faible lWordArray()
Dim lBytePosition
Dim lByteCount
Dim lWordCount
Dim lOctet
Const MODULUS_BITS = 512
Const CONGRUENT_BITS = 448
lMessageLength = Longueur(sMessage)
lNumberOfWords = (((lMessageLength + ((MODULUS_BITS - CONGRUENT_BITS) / BITS_TO_A_BYTE)) / (MODULUS_BITS / BITS_TO_A_BYTE)) + 1) * (MODULUS_BITS / BITS_TO_A_WORD)
ReDim lWordArray(lNumberOfWords - 1)
lBytePosition = 0
lByteCount = 0
Faire jusqu'à ce que lByteCount >= lMessageLength
lWordCount = lByteCount / BYTES_TO_A_WORD
lBytePosition = (3 - (lByteCount Mod BYTES_TO_A_WORD)) * BITS_TO_A_BYTE
lByte = AscB(Mid(sMessage, lByteCount + 1, 1))
lWordArray(lWordCount) = lWordArray(lWordCount) ou SHA256_LShift(lByte, lBytePosition)
lByteCount = lByteCount + 1
Boucle
lWordCount = lByteCount / BYTES_TO_A_WORD
lBytePosition = (3 - (lByteCount Mod BYTES_TO_A_WORD)) * BITS_TO_A_BYTE
lWordArray(lWordCount) = lWordArray(lWordCount) ou SHA256_LShift(&H80, lBytePosition)
lWordArray(lNumberOfWords - 1) = SHA256_LShift(lMessageLength, 3)
lWordArray(lNumberOfWords - 2) = SHA256_RShift(lMessageLength, 29)
SHA256_ConvertToWordArray = lWordArray
Fonction de fin
' ================================================== =========================================
' Algorithme de chiffrement SHA256
' ================================================== =======================================
'Méthode d'appel :
' SHA256(sMessage, p_Len)
' p_Len contrôle la longueur de la chaîne générée, 1 est de 8 bits, 2 est de 16 bits, la valeur maximale est de 8, c'est-à-dire que la longueur après cryptage est de 64 bits
'Contrôle du cryptage 8 bits/16 bits/24 bits/32 bits/40 bits/48 bits/56 bits/64 bits
Fonction publique SHA256 (byVal sMessage, byVal p_Len)
Faible HASH(7)
Faible
Dim. W(63)
Atténuer un
Faible b
Faible c
Faible d
Dim e
f
DiM g
h
Faible je
j
Dim T1
Dim T2
HACHAGE(0) = &H6A09E667
HACHAGE(1) = &HBB67AE85
HACHAGE(2) = &H3C6EF372
HACHAGE(3) = &HA54FF53A
HACHAGE(4) = &H510E527F
HACHAGE(5) = &H9B05688C
HACHAGE(6) = &H1F83D9AB
HACHAGE(7) = &H5BE0CD19
M = SHA256_ConvertToWordArray(sMessage)
Pour i = 0 Vers UBound(M) Étape 16
une = HACHAGE(0)
b = HACHAGE(1)
c = HACHAGE(2)
d = HACHAGE(3)
e = HACHAGE(4)
f = HACHAGE(5)
g = HACHAGE(6)
h = HACHAGE(7)
Pour j = 0 à 63
Si j < 16 Alors
W(j) = M(j + je)
Autre
W(j) = SHA256_AddUnsigned(SHA256_AddUnsigned(SHA256_AddUnsigned(SHA256_Gamma1(W(j - 2)), W(j - 7)), SHA256_Gamma0(W(j - 15))), W(j - 16))
Fin si
T1 = SHA256_AddUnsigned(SHA256_AddUnsigned(SHA256_AddUnsigned(SHA256_AddUnsigned(h, SHA256_Sigma1(e)), SHA256_CH(e, f, g)), SHA256_K(j)), W(j))
T2 = SHA256_AddUnsigned(SHA256_Sigma0(a), SHA256_Maj(a, b, c))
h = g
g = f
f = e
e = SHA256_AddUnsigned(d, T1)
d = c
c = b
b = une
une = SHA256_AddUnsigned(T1, T2)
Suivant
HASH(0) = SHA256_AddUnsigned(a, HASH(0))
HASH(1) = SHA256_AddUnsigned(b, HASH(1))
HASH(2) = SHA256_AddUnsigned(c, HASH(2))
HASH(3) = SHA256_AddUnsigned(d, HASH(3))
HASH(4) = SHA256_AddUnsigned(e, HASH(4))
HASH(5) = SHA256_AddUnsigned(f, HASH(5))
HASH(6) = SHA256_AddUnsigned(g, HASH(6))
HASH(7) = SHA256_AddUnsigned(h, HASH(7))
Suivant
SHA256 =
Si p_Len >= 8 Alors p_Len = 8
Si p_Len <= 0 Alors p_Len = 2
Pour i = 0 À p_Len - 1
SHA256 = SHA256 & Droite(00000000 & Hex(HASH(i)), 8)
Suivant
SHA256 = LCas(SHA256)
Fonction de fin
Fonction publique EncryptMode (ByVal p_String, ByVal p_Type)
Dim E1, E2
E1s = 16 'La longueur du premier cryptage de l'algorithme MD5 Longueur de cryptage MD5 16 bits
E2s = 2 ' La longueur du deuxième cryptage ou de l'algorithme SHA256 est de 2*8=16 bits Longueur de cryptage SHA256, la longueur maximale de cryptage est de 8*8=64 bits
Si ce n'est pas IsNumeric(p_Type) Alors
p_Type = 1
ElseIf p_Type > 7 ou p_Type < 0 Then 'Jugez le nombre de plans en fonction de la valeur maximale de p_Type
p_Type = 1
Fin si
Si ce n'est pas EstNumérique (E1s) Alors
E1 = 16
SinonSi E1s <> 16 Et E1s <> 32 Alors
E1 = 16
Fin si
Si ce n'est pas IsNumeric (E2s), alors
E2s = 2
SinonSi E2s > 8 ou E2s < 0 Alors
E2s = 2
Fin si
' ===========================================
« Il est préférable d'ajuster le schéma de cryptage lors du premier déploiement. Il existe actuellement jusqu'à 8 schémas.
« La longueur de la chaîne cryptée est de 16 bits, qui peut être ajustée en cours d'utilisation.
' ===========================================
Sélectionnez le cas p_Type
Cas 0 'Algorithme MD5
ModeCryptage = MD5(p_String, E1s)
Cas 1 'Algorithme SHA256
ModeCryptage = SHA256(p_String, E2s)
Cas 2 'MD5 d'abord, puis SHA256
ModeCryptage = SHA256(MD5(p_String, E1s), E2s)
Cas 3 : SHA256 d’abord, puis MD5
ModeCryptage = MD5(SHA256(p_String, E2s), E1s)
Cas 4' MD5 deux fois
ModeCryptage = MD5(MD5(p_String, E1s), E2s)
Cas 5' SHA256 deux fois
ModeCryptage = SHA256(SHA256(p_String, E1s), E2s)
Cas 6 'Les 8 premiers bits de l'algorithme MD5 et les 8 derniers bits de l'algorithme SHA256
EncryptMode = Gauche (MD5 (p_String, E1s), 8) et Droite (SHA256 (p_String, E2s), 8)
Cas 7 'Les 8 premiers bits de l'algorithme SHA256 et les 8 derniers bits de l'algorithme MD5
EncryptMode = Gauche (SHA256 (p_String, E2s), 8) et Droite (MD5 (p_String, E1s), 8)
Fin de la sélection
Fonction de fin
' =============================================
'Fonction de cryptage universelle pour tous les mots de passe du site
' =============================================
Fonction publique PassWordEnt (ByVal p_String)
Si p_String = ou IsNull(p_String) Alors p_String = 1
' Prendre le reste de la valeur AscW du dernier caractère du mot de passe et 8 comme coefficient du schéma de cryptage
PassWordEnt = EncryptMode(p_String, AscW(LCase(Right(p_String, 1))) Mod 8)
Fonction de fin
Fin du cours
%>
Démo :
Copiez le code comme suit :
<!--#include file=cls_Encrypt.asp-->
<%
Dim o
Définir o = nouveau Cls_Encrypt
Algorithme Response.write MD5 : & o.EncryptMode(admin,0) & <br />
Algorithme Response.write SHA256 : & o.EncryptMode(admin,1) & <br />
Response.write d'abord MD5 puis SHA256 : & o.EncryptMode(admin,2) & <br />
Response.write d'abord SHA256 puis MD5 : & o.EncryptMode(admin,3) & <br />
Response.write MD5 deux fois : & o.EncryptMode(admin,4) & <br />
Response.write SHA256 deux fois : & o.EncryptMode(admin,5) & <br />
Response.write Les 8 premiers chiffres de l'algorithme MD5 et les 8 derniers chiffres de l'algorithme SHA256 : & o.EncryptMode(admin,6) & <br />
Response.write Les 8 premiers bits de l'algorithme SHA256 et les 8 derniers bits de l'algorithme MD5 : & o.EncryptMode(admin,7) & <br /><hr />
Response.write prend la valeur AscW du dernier caractère du mot de passe et le reste de 8 comme coefficient du schéma de chiffrement : & o.PassWordEnt(admin) & <br /><hr />
Cryptage MD5 16 bits Response.write : & o.md5(admin,16) & <br />
Cryptage MD5 32 bits Response.write : & o.md5(admin,32) & <br /><hr />
Cryptage SHA256 8 bits Response.write : & o.sha256(admin,1) & <br />
Cryptage SHA256 16 bits Response.write : & o.sha256(admin,2) & <br />
Cryptage SHA256 24 bits Response.write : & o.sha256(admin,3) & <br />
Cryptage SHA256 32 bits Response.write : & o.sha256(admin,4) & <br />
Cryptage SHA256 40 bits Response.write : & o.sha256(admin,5) & <br />
Cryptage SHA256 48 bits Response.write : & o.sha256(admin,6) & <br />
Cryptage SHA256 56 bits Response.write : & o.sha256(admin,7) & <br />
Cryptage SHA256 64 bits Response.write : & o.sha256(admin,8) & <br />
Mettre o = rien
%>