La tecnología de cifrado múltiple MD5 y SHA256 de ASP obtiene el tipo de cifrado según la cadena. ¡Es un cifrado mixto y no hay esperanzas de obtener grandes ganancias! Portátil a C#/C/C++, ASP.NET, VB.NET U otros tipos de lenguajes están disponibles actualmente: algoritmo MD5, algoritmo SHA256, MD5 primero luego SHA256, primero SHA256 luego MD5, dos veces MD5, dos veces SHA256, primeros 8 bits del algoritmo MD5 y luego 8 bits del algoritmo SHA256, primeros 8 bits del algoritmo SHA256 El último algoritmo MD5 de 8 bits, tomando el valor AscW del último carácter de la contraseña y el resto de 8 como coeficiente del esquema de cifrado, cifrado MD5 de 16 bits, Cifrado MD5 de 32 bits, cifrado SHA256 de 8 bits, cifrado SHA256 de 16 bits, cifrado SHA256 de 24 bits, cifrado SHA256 de 32 bits, cifrado SHA256 de 40 bits, SHA de 48 bits Cifrado 256, cifrado SHA256 de 56 bits, cifrado SHA256 de 64 bits y otros algoritmos. Después de leer el código fuente, puede personalizar más combinaciones de cifrado y algoritmos de cifrado. Diga adiós al descifrado por fuerza bruta del algoritmo MD5.
código fuente cls_Encrypt.asp:
Copie el código de código de la siguiente manera:
<%
Const privada BITS_TO_A_BYTE = 8
Const privada BYTES_TO_A_WORD = 4
Const privado BITS_TO_A_WORD = 32
Clase Cls_Encrypt
MD5_m_lOnBits(30) privado
Privado MD5_m_l2Power(30)
Privado SHA256_m_lOnBits(30)
Privado SHA256_m_l2Power(30)
Privado SHA256_K(63)
Subclase privada_Inicializar
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_l2Potencia(0) = CLng(1)
MD5_m_l2Potencia(1) = CLng(2)
MD5_m_l2Potencia(2) = CLng(4)
MD5_m_l2Potencia(3) = CLng(8)
MD5_m_l2Potencia(4) = CLng(16)
MD5_m_l2Potencia(5) = CLng(32)
MD5_m_l2Potencia(6) = CLng(64)
MD5_m_l2Potencia(7) = CLng(128)
MD5_m_l2Potencia(8) = CLng(256)
MD5_m_l2Potencia(9) = CLng(512)
MD5_m_l2Potencia(10) = CLng(1024)
MD5_m_l2Potencia(11) = CLng(2048)
MD5_m_l2Potencia(12) = CLng(4096)
MD5_m_l2Potencia(13) = CLng(8192)
MD5_m_l2Potencia(14) = CLng(16384)
MD5_m_l2Potencia(15) = CLng(32768)
MD5_m_l2Potencia(16) = CLng(65536)
MD5_m_l2Potencia(17) = CLng(131072)
MD5_m_l2Potencia(18) = CLng(262144)
MD5_m_l2Potencia(19) = CLng(524288)
MD5_m_l2Potencia(20) = CLng(1048576)
MD5_m_l2Potencia(21) = CLng(2097152)
MD5_m_l2Potencia(22) = CLng(4194304)
MD5_m_l2Potencia(23) = CLng(8388608)
MD5_m_l2Potencia(24) = CLng(16777216)
MD5_m_l2Potencia(25) = CLng(33554432)
MD5_m_l2Potencia(26) = CLng(67108864)
MD5_m_l2Potencia(27) = CLng(134217728)
MD5_m_l2Potencia(28) = CLng(268435456)
MD5_m_l2Potencia(29) = CLng(536870912)
MD5_m_l2Potencia(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_l2Potencia(0) = CLng(1)
SHA256_m_l2Potencia(1) = CLng(2)
SHA256_m_l2Potencia(2) = CLng(4)
SHA256_m_l2Potencia(3) = CLng(8)
SHA256_m_l2Potencia(4) = CLng(16)
SHA256_m_l2Potencia(5) = CLng(32)
SHA256_m_l2Potencia(6) = CLng(64)
SHA256_m_l2Potencia(7) = CLng(128)
SHA256_m_l2Potencia(8) = CLng(256)
SHA256_m_l2Potencia(9) = CLng(512)
SHA256_m_l2Potencia(10) = CLng(1024)
SHA256_m_l2Potencia(11) = CLng(2048)
SHA256_m_l2Potencia(12) = CLng(4096)
SHA256_m_l2Potencia(13) = CLng(8192)
SHA256_m_l2Potencia(14) = CLng(16384)
SHA256_m_l2Potencia(15) = CLng(32768)
SHA256_m_l2Potencia(16) = CLng(65536)
SHA256_m_l2Potencia(17) = CLng(131072)
SHA256_m_l2Potencia(18) = CLng(262144)
SHA256_m_l2Potencia(19) = CLng(524288)
SHA256_m_l2Potencia(20) = CLng(1048576)
SHA256_m_l2Potencia(21) = CLng(2097152)
SHA256_m_l2Potencia(22) = CLng(4194304)
SHA256_m_l2Potencia(23) = CLng(8388608)
SHA256_m_l2Potencia(24) = CLng(16777216)
SHA256_m_l2Potencia(25) = CLng(33554432)
SHA256_m_l2Potencia(26) = CLng(67108864)
SHA256_m_l2Potencia(27) = CLng(134217728)
SHA256_m_l2Potencia(28) = CLng(268435456)
SHA256_m_l2Potencia(29) = CLng(536870912)
SHA256_m_l2Potencia(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
Subtítulo final
Subclase privada_Terminar
Subtítulo final
'Función de matriz de conversión de transferencia de caracteres
Función privada ConvertToWordArray (byVal sMessage)
Longitud del mensaje tenue
Atenuar el número de palabras
Atenuar lWordArray()
Dim lBytePosition
Dim lByteCount
Atenuar el recuento de palabras
Constante MÓDULO_BITS = 512
Constante CONGRUENT_BITS = 448
lMessageLength = Len(sMensaje)
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)
lBytePosición = 0
lByteCount = 0
Hacer hasta lByteCount >= lMessageLength
lWordCount = lByteCount / BYTES_TO_A_WORD
lBytePosition = (lByteCount Mod BYTES_TO_A_WORD) * BITS_TO_A_BYTE
lWordArray(lWordCount) = lWordArray(lWordCount) o LShift(Asc(Mid(sMessage, lByteCount + 1, 1)), lBytePosition)
lByteCount = lByteCount + 1
Bucle
lWordCount = lByteCount / BYTES_TO_A_WORD
lBytePosition = (lByteCount Mod BYTES_TO_A_WORD) * BITS_TO_A_BYTE
lWordArray(lWordCount) = lWordArray(lWordCount) o LShift(&H80, lBytePosition)
lArrayPalabras(lNúmeroDePalabras - 2) = LShift(lLongitudMensaje, 3)
lArrayPalabras(lNúmeroDePalabras - 1) = RShift(lLongitudMensaje, 29)
ConvertToWordArray = lWordArray
Función final
'Función principal de desplazamiento a la izquierda de cadena
Función privada LShift(byVal lValue, byVal iShiftBits)
Si iShiftBits = 0 Entonces
LMayús = lValor
Función de salida
De lo contrario, si iShiftBits = 31, entonces
Si lValue y 1 entonces
Cambio L = &H80000000
Demás
LMayús = 0
Terminar si
Función de salida
De lo contrario, si iShiftBits <0 o iShiftBits> 31, entonces
Err.Subir 6
Terminar si
Si (lValue y MD5_m_l2Power(31 - iShiftBits)) entonces
LShift = ((lValue y MD5_m_lOnBits(31 - (iShiftBits + 1))) * MD5_m_l2Power(iShiftBits)) o &H80000000
Demás
LShift = ((lValor y MD5_m_lOnBits(31 - iShiftBits)) * MD5_m_l2Power(iShiftBits))
Terminar si
Función final
'Función principal de desplazamiento a la derecha de cadena
Función privada RShift(byVal lValue, byVal iShiftBits)
Si iShiftBits = 0 Entonces
RMayús = lValor
Función de salida
De lo contrario, si iShiftBits = 31, entonces
Si lValue y &H80000000 entonces
Cambio R = 1
Demás
Cambio R = 0
Terminar si
Función de salida
De lo contrario, si iShiftBits <0 o iShiftBits> 31, entonces
Err.Subir 6
Terminar si
RShift = (lValor y &H7FFFFFFE) / MD5_m_l2Power(iShiftBits)
Si (lValue y &H80000000) entonces
RShift = (RShift o (&H40000000 / MD5_m_l2Power(iShiftBits - 1)))
Terminar si
Función final
'Conversión de desplazamiento de cadena, implementada mediante funciones de desplazamiento hacia la izquierda y hacia la derecha
Función privada RotateLeft(byVal lValue, byVal iShiftBits)
GirarIzquierda = LShift(lValue, iShiftBits) o RShift(lValue, (32 - iShiftBits))
Función final
'Agregar codificación hexadecimal sin firmar
Función privada AddUnsigned(byVal lX, byVal lY)
x4
y4
x8
y8
Resultado tenue
lX8 = lX Y &H80000000
lY8 = lY y &H80000000
lX4 = lX y &H40000000
lY4 = lY y &H40000000
lResultado = (lX y &H3FFFFFFF) + (lY y &H3FFFFFFF)
Si lX4 y lY4 entonces
lResultado = lResultado Xor &H80000000 Xor lX8 Xor lY8
De lo contrario, si lX4 o lY4, entonces
Si lResult y &H40000000 entonces
lResultado = lResultado Xor &HC0000000 Xor lX8 Xor lY8
Demás
lResultado = lResultado Xor &H40000000 Xor lX8 Xor lY8
Terminar si
Demás
lResultado = lResultado Xo lX8 Xo lY8
Terminar si
Agregar sin firmar = lResultado
Función final
'MD5_FF,MD5_GG,MD5_HH,MD5_II Función de codificación principal MD5
Sub privado MD5_FF(a, b, c, d, x, s, ac)
a = Agregar sin firmar (a, Agregar sin firmar (Agregar sin firmar (MD5_F (b, c, d), x), ac))
a = Girar a la izquierda (a, s)
a = Agregar sin firmar (a, b)
Subtítulo final
Sub privado MD5_GG(a, b, c, d, x, s, ac)
a = Agregar sin firmar (a, Agregar sin firmar (Agregar sin firmar (MD5_G (b, c, d), x), ac))
a = Girar a la izquierda (a, s)
a = Agregar sin firmar (a, b)
Subtítulo final
Sub privado MD5_HH(a, b, c, d, x, s, ac)
a = Agregar sin firmar (a, Agregar sin firmar (Agregar sin firmar (MD5_H (b, c, d), x), ac))
a = Girar a la izquierda (a, s)
a = Agregar sin firmar (a, b)
Subtítulo final
Sub privado MD5_II (a, b, c, d, x, s, ac)
a = Agregar sin firmar (a, Agregar sin firmar (Agregar sin firmar (MD5_I (b, c, d), x), ac))
a = Girar a la izquierda (a, s)
a = Agregar sin firmar (a, b)
Subtítulo final
'MD5_F,MD5_G,MD5_H,MD5_I Función de codificación auxiliar MD5
Función privada MD5_F(x, y, z)
MD5_F = (x e y) o ((no x) y z)
Función final
Función privada MD5_G(x, y, z)
MD5_G = (x y z) o (y y (no z))
Función final
Función privada MD5_H(x, y, z)
MD5_H = (x Xo y Xo z)
Función final
Función privada MD5_I(x, y, z)
MD5_I = (y Xor (x o (No z)))
Función final
'16 conversión de codificación hexadecimal
Función privada WordToHex (byVal lValue)
lByte tenue
recuento tenue
Para lCount = 0 a 3
lByte = RShift(lValue, lCount * BITS_TO_A_BYTE) y MD5_m_lOnBits(BITS_TO_A_BYTE - 1)
WordToHex = WordToHex & Derecha(0 & Hex(lByte), 2)
Próximo
Función final
'MD5 función principal MD5 (cadena, bits de codificación)
Función pública MD5 (byVal sMessage, byVal sType)
tenue x
tenue k
AA tenue
BB tenue
CC tenue
DimDD
atenuar un
tenue b
tenue c
tenue d
Constante S11 = 7
Constante S12 = 12
Constante S13 = 17
Constante S14 = 22
Constante S21 = 5
constante S22 = 9
Constante S23 = 14
Constante S24 = 20
Constante S31 = 4
Constante S32 = 11
Constante S33 = 16
constante S34 = 23
Constante S41 = 6
Constante S42 = 10
Constante S43 = 15
constante S44 = 21
x = ConvertToWordArray(sMessage) 'Paso de cifrado 1: conversión de matriz
a = &H67452301
b = &HEFCDAB89
c = &H98BADCFE
re = &H10325476
Para k = 0 a UBound(x) Paso 16
AA = un
BB = b
CC = c
DD = d
'Paso de cifrado 2: conversión de codificación
MD5_FF a, b, c, d, x(k + 0), S11, y HD76AA478
MD5_FF d, a, b, c, x(k + 1), S12, y HE8C7B756
MD5_FF c, 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, a, b, c, x(k + 5), S12, y H4787C62A
MD5_FF c, 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, y H698098D8
MD5_FF d, a, 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, a, b, c, x(k + 13), S12, &HFD987193
MD5_FF c, 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, a, 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, y HD62F105D
MD5_GGd, a, 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_GGd, a, 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, a, 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, a, 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, a, 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, a, 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, a, b, c, x(k + 7), S42, &H432AFF97
MD5_II c, d, a, b, x(k + 14), S43, &HAB9423A7
MD5_II b, c, d, a, x(k + 5), S44, &HFC93A039
MD5_II a, b, c, d, x(k + 12), S41, &H655B59C3
MD5_II d, a, 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, a, b, c, x(k + 15), S42, &HFE2CE6E0
MD5_II c, 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, a, 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
'Paso 3 de cifrado: agregar conversión sin firmar
a = Agregar sin firmar (a, AA)
b = Agregar sin firmar (b, BB)
c = Agregar sin firmar (c, CC)
d = Agregar sin firmar (d, DD)
Próximo
Si sType = 32 Entonces
'Paso 4 de cifrado: divida y combine cada conversión hexadecimal de 8 dígitos
MD5 = LCase(PalabraAHex(a) & PalabraAHex(b) & PalabraAHex(c) & PalabraAHex(d))
Demás
MD5 = CasoL(PalabraAHex(b) & PalabraAHex(c))
Terminar si
Función final
Función privada SHA256_LShift (byVal lValue, byVal iShiftBits)
Si iShiftBits = 0 Entonces
SHA256_LShift = valor l
Función de salida
De lo contrario, si iShiftBits = 31, entonces
Si lValue y 1 entonces
SHA256_LShift = &H80000000
Demás
SHA256_LShift = 0
Terminar si
Función de salida
De lo contrario, si iShiftBits <0 o iShiftBits> 31, entonces
Err.Subir 6
Terminar si
Si (lValue y SHA256_m_l2Power(31 - iShiftBits)) entonces
SHA256_LShift = ((lValue y SHA256_m_lOnBits(31 - (iShiftBits + 1))) * SHA256_m_l2Power(iShiftBits)) o &H80000000
Demás
SHA256_LShift = ((lValue y SHA256_m_lOnBits(31 - iShiftBits)) * SHA256_m_l2Power(iShiftBits))
Terminar si
Función final
Función privada SHA256_RShift (byVal lValue, byVal iShiftBits)
Si iShiftBits = 0 Entonces
SHA256_RShift = valor l
Función de salida
De lo contrario, si iShiftBits = 31, entonces
Si lValue y &H80000000 entonces
SHA256_RShift = 1
Demás
SHA256_RShift = 0
Terminar si
Función de salida
De lo contrario, si iShiftBits <0 o iShiftBits> 31, entonces
Err.Subir 6
Terminar si
SHA256_RShift = (lValor y &H7FFFFFFE) / SHA256_m_l2Power(iShiftBits)
Si (lValue y &H80000000) entonces
SHA256_RShift = (SHA256_RShift o (&H40000000 / SHA256_m_l2Power(iShiftBits - 1)))
Terminar si
Función final
Función privada SHA256_AddUnsigned(byVal lX, byVal lY)
x4
y4
x8
y8
Resultado tenue
lX8 = lX Y &H80000000
lY8 = lY y &H80000000
lX4 = lX Y&H40000000
lY4 = lY y &H40000000
lResultado = (lX y &H3FFFFFFF) + (lY y &H3FFFFFFF)
Si lX4 y lY4 entonces
lResultado = lResultado Xor &H80000000 Xor lX8 Xor lY8
De lo contrario, si lX4 o lY4, entonces
Si lResult y &H40000000 entonces
lResultado = lResultado Xor &HC0000000 Xor lX8 Xor lY8
Demás
lResultado = lResultado Xor &H40000000 Xor lX8 Xor lY8
Terminar si
Demás
lResultado = lResultado Xo lX8 Xo lY8
Terminar si
SHA256_AddUnsigned = lResultado
Función final
Función privada SHA256_CH(x, y, z)
SHA256_Ch = ((x e y) Xor ((no x) y z))
Función final
Función privada SHA256_Maj(x, y, z)
SHA256_Maj = ((x e y) Xor (x y z) Xor (y y z))
Función final
Función privada SHA256_S(x, n)
SHA256_S = (SHA256_RShift(x, (n y SHA256_m_lOnBits(4))) o SHA256_LShift(x, (32 - (n y SHA256_m_lOnBits(4)))))
Función final
Función privada SHA256_R(x, n)
SHA256_R = SHA256_RShift(x, cLng(n y SHA256_m_lOnBits(4)))
Función final
Función privada SHA256_Sigma0(x)
SHA256_Sigma0 = (SHA256_S(x, 2) Xo SHA256_S(x, 13) Xo SHA256_S(x, 22))
Función final
Función privada SHA256_Sigma1(x)
SHA256_Sigma1 = (SHA256_S(x, 6) Xo SHA256_S(x, 11) Xo SHA256_S(x, 25))
Función final
Función privada SHA256_Gamma0(x)
SHA256_Gamma0 = (SHA256_S(x, 7) Xo SHA256_S(x, 18) Xo SHA256_R(x, 3))
Función final
Función privada SHA256_Gamma1(x)
SHA256_Gamma1 = (SHA256_S(x, 17) Xo SHA256_S(x, 19) Xo SHA256_R(x, 10))
Función final
Función privada SHA256_ConvertToWordArray (byVal sMessage)
Longitud del mensaje tenue
Atenuar el número de palabras
Atenuar lWordArray()
Posición de lByte tenue
Dim lByteCount
Atenuar el recuento de palabras
lByte tenue
Constante MÓDULO_BITS = 512
Constante CONGRUENT_BITS = 448
lMessageLength = Len(sMensaje)
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)
lBytePosición = 0
lByteCount = 0
Hacer hasta 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) o SHA256_LShift(lByte, lBytePosition)
lByteCount = lByteCount + 1
Bucle
lWordCount = lByteCount / BYTES_TO_A_WORD
lBytePosition = (3 - (lByteCount Mod BYTES_TO_A_WORD)) * BITS_TO_A_BYTE
lWordArray(lWordCount) = lWordArray(lWordCount) o SHA256_LShift(&H80, lBytePosition)
lWordArray(lNumberOfWords - 1) = SHA256_LShift(lMessageLength, 3)
lWordArray(lNumberOfWords - 2) = SHA256_RShift(lMessageLength, 29)
SHA256_ConvertToWordArray = lWordArray
Función final
' =================================================== ===========================================
'Algoritmo de cifrado SHA256
' =================================================== =========================================
'Método de llamada:
' SHA256(sMensaje, p_Len)
' p_Len controla la longitud de la cadena generada, 1 es 8 bits, 2 es 16 bits, el valor máximo es 8, es decir, la longitud después del cifrado es 64 bits
'Control de cifrado de 8 bits/16 bits/24 bits/32 bits/40 bits/48 bits/56 bits/64 bits
Función pública SHA256 (byVal sMessage, byVal p_Len)
HASH tenue(7)
Oscuro
Oscuro W(63)
atenuar un
tenue b
tenue c
tenue d
Diez centavos
F
DiMg
h
Yo tenue
j
T1 tenue
T2 tenue
HASH(0) = &H6A09E667
HASH(1) = &HBB67AE85
HASH(2) = &H3C6EF372
HASH(3) = &HA54FF53A
HASH(4) = &H510E527F
HASH(5) = &H9B05688C
HASH(6) = &H1F83D9AB
HASH(7) = &H5BE0CD19
M = SHA256_ConvertToWordArray(sMensaje)
Para i = 0 a UBound(M) Paso 16
a = picadillo(0)
b = picadillo(1)
c = picadillo(2)
d = picadillo(3)
e = picadillo(4)
f = picadillo(5)
g = picadillo(6)
h = picadillo(7)
Para j = 0 a 63
Si j < 16 Entonces
W(j) = M(j + yo)
Demás
W(j) = SHA256_AddUnsigned(SHA256_AddUnsigned(SHA256_AddUnsigned(SHA256_Gamma1(W(j - 2)), W(j - 7)), SHA256_Gamma0(W(j - 15))), W(j - 16))
Terminar 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 = gramo
gramo = f
f = mi
mi = SHA256_AddUnsigned(d, T1)
re = c
c = segundo
segundo = un
a = SHA256_AddUnsigned(T1, T2)
Próximo
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))
Próximo
SHA256 =
Si p_Len >= 8 Entonces p_Len = 8
Si p_Len <= 0 Entonces p_Len = 2
Para i = 0 Para p_Len - 1
SHA256 = SHA256 y Derecha(00000000 y Hexadecimal(HASH(i)), 8)
Próximo
SHA256 = Caso L(SHA256)
Función final
Modo de cifrado de función pública (ByVal p_String, ByVal p_Type)
Atenuar E1, E2
E1s = 16 'La longitud del primer algoritmo de cifrado MD5 o longitud del cifrado MD5 de 16 bits
E2s = 2 ' La longitud del segundo cifrado del algoritmo SHA256 es 2*8=16 bits Longitud del cifrado SHA256, la longitud máxima de cifrado es 8*8=64 bits
Si no es numérico (p_Type) entonces
tipo_p = 1
De lo contrario, si p_Type > 7 o p_Type < 0, entonces 'Juzga el número de planes según el valor máximo de p_Type
tipo_p = 1
Terminar si
Si no es numérico (E1s) entonces
E1 = 16
De lo contrario, si E1s <> 16 y E1s <> 32, entonces
E1 = 16
Terminar si
Si no es numérico (E2s) entonces
E2 = 2
De lo contrario, si E2s > 8 o E2s < 0, entonces
E2 = 2
Terminar si
' =============================================
'Es mejor ajustar el esquema de cifrado cuando lo implemente por primera vez. Actualmente hay hasta 8 esquemas.
'La longitud de la cadena cifrada es de 16 bits, que se puede ajustar durante el uso.
' =============================================
Seleccione Caso p_Type
Caso 0 'Algoritmo MD5
ModoCifrado = MD5(p_String, E1s)
Caso 1 'Algoritmo SHA256
Modo de cifrado = SHA256 (p_String, E2s)
Caso 2 'MD5 primero, luego SHA256
Modo de cifrado = SHA256(MD5(p_String, E1s), E2s)
Caso 3 'SHA256 primero, luego MD5
Modo de cifrado = MD5(SHA256(p_String, E2s), E1s)
Caso 4' MD5 dos veces
ModoCifrado = MD5(MD5(p_String, E1s), E2s)
Caso 5 ' SHA256 dos veces
Modo de cifrado = SHA256(SHA256(p_String, E1s), E2s)
Caso 6 'Los primeros 8 bits del algoritmo MD5 y los últimos 8 bits del algoritmo SHA256
EncryptMode = Izquierda (MD5 (p_String, E1s), 8) y Derecha (SHA256 (p_String, E2s), 8)
Caso 7 ' Los primeros 8 bits del algoritmo SHA256 y los últimos 8 bits del algoritmo MD5
EncryptMode = Izquierda (SHA256 (p_String, E2s), 8) y Derecha (MD5 (p_String, E1s), 8)
Seleccionar fin
Función final
' ===============================================
'Función de cifrado universal para todas las contraseñas del sitio
' ===============================================
Función pública PassWordEnt (ByVal p_String)
Si p_String = o IsNull(p_String) Entonces p_String = 1
' Tome el resto del valor AscW del último carácter de la contraseña y 8 como coeficiente del esquema de cifrado
PassWordEnt = EncryptMode(p_String, AscW(LCase(Right(p_String, 1))) Mod 8)
Función final
Fin de clase
%>
Manifestación:
Copie el código de código de la siguiente manera:
<!--#include file=cls_Encrypt.asp-->
<%
tenue o
Establecer o = nuevo Cls_Encrypt
Algoritmo MD5 Response.write: & o.EncryptMode(admin,0) & <br />
Algoritmo Response.write SHA256: & o.EncryptMode(admin,1) & <br />
Response.write primero MD5 y luego SHA256: & o.EncryptMode(admin,2) & <br />
Response.write primero SHA256 y luego MD5: & o.EncryptMode(admin,3) & <br />
Respuesta.escribir MD5 dos veces: & o.EncryptMode(admin,4) & <br />
Respuesta.escribir SHA256 dos veces: & o.EncryptMode(admin,5) & <br />
Response.write Los primeros 8 dígitos del algoritmo MD5 y los últimos 8 dígitos del algoritmo SHA256: & o.EncryptMode(admin,6) & <br />
Response.write Los primeros 8 bits del algoritmo SHA256 y los últimos 8 bits del algoritmo MD5: & o.EncryptMode(admin,7) & <br /><hr />
Response.write toma el valor AscW del último carácter de la contraseña y el resto de 8 como coeficiente del esquema de cifrado: & o.PassWordEnt(admin) & <br /><hr />
Cifrado MD5 de 16 bits de Response.write: & o.md5(admin,16) & <br />
Cifrado MD5 de 32 bits Response.write: & o.md5(admin,32) & <br /><hr />
Cifrado Response.write SHA256 de 8 bits: & o.sha256(admin,1) & <br />
Cifrado Response.write SHA256 de 16 bits: & o.sha256(admin,2) & <br />
Cifrado Response.write SHA256 de 24 bits: & o.sha256(admin,3) & <br />
Cifrado SHA256 de 32 bits Response.write: & o.sha256(admin,4) & <br />
Cifrado Response.write SHA256 de 40 bits: & o.sha256(admin,5) & <br />
Cifrado Response.write SHA256 de 48 bits: & o.sha256(admin,6) & <br />
Cifrado SHA256 de 56 bits Response.write: & o.sha256(admin,7) & <br />
Cifrado Response.write SHA256 de 64 bits: & o.sha256(admin,8) & <br />
Establecer o = nada
%>