A tecnologia de criptografia múltipla MD5 e SHA256 do ASP obtém o tipo de criptografia com base na string. É uma criptografia mista e não há esperança de grandes lucros! Portátil para C#/C/C++, ASP.NET, VB.NET Ou outros tipos de linguagens estão disponíveis atualmente: algoritmo MD5, algoritmo SHA256, MD5 primeiro depois SHA256, primeiro SHA256 depois MD5, duas vezes MD5, duas vezes SHA256, primeiros 8 bits do algoritmo MD5 e depois 8 bits do algoritmo SHA256, primeiros 8 bits do algoritmo SHA256 O último algoritmo MD5 de 8 bits, tomando o valor AscW do último caractere da senha e o restante de 8 como o coeficiente do esquema de criptografia, criptografia MD5 de 16 bits, Criptografia MD5 de 32 bits, criptografia SHA256 de 8 bits, criptografia SHA256 de 16 bits, criptografia SHA256 de 24 bits, criptografia SHA256 de 32 bits, criptografia SHA256 de 40 bits, SHA de 48 bits Criptografia 256, criptografia SHA256 de 56 bits, criptografia SHA256 de 64 bits e outros algoritmos Depois de ler o código-fonte, você pode personalizar mais combinações de criptografia e algoritmos de criptografia.
Código-fonte cls_Encrypt.asp:
Copie o código do código da seguinte forma:
<%
Const privado BITS_TO_A_BYTE = 8
Privado Const BYTES_TO_A_WORD = 4
Const privada BITS_TO_A_WORD = 32
Classe Cls_Encrypt
MD5_m_lOnBits privado(30)
Privado MD5_m_l2Power(30)
SHA256_m_lOnBits privado(30)
Privado SHA256_m_l2Power(30)
Privado SHA256_K(63)
Subclasse Privada_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_l2Potência(0) = CLng(1)
MD5_m_l2Potência(1) = CLng(2)
MD5_m_l2Potência(2) = CLng(4)
MD5_m_l2Potência(3) = CLng(8)
MD5_m_l2Potência(4) = CLng(16)
MD5_m_l2Potência(5) = CLng(32)
MD5_m_l2Potência(6) = CLng(64)
MD5_m_l2Potência(7) = CLng(128)
MD5_m_l2Potência(8) = CLng(256)
MD5_m_l2Potência(9) = CLng(512)
MD5_m_l2Potência(10) = CLng(1024)
MD5_m_l2Power(11) = CLng(2048)
MD5_m_l2Power(12) = CLng(4096)
MD5_m_l2Power(13) = CLng(8192)
MD5_m_l2Potência(14) = CLng(16384)
MD5_m_l2Potência(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_l2Potência(24) = CLng(16777216)
MD5_m_l2Potência(25) = CLng(33554432)
MD5_m_l2Power(26) = CLng(67108864)
MD5_m_l2Power(27) = CLng(134217728)
MD5_m_l2Potência(28) = CLng(268435456)
MD5_m_l2Power(29) = CLng(536870912)
MD5_m_l2Potência(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
Finalizar sub
Subclasse Privada_Terminate
Finalizar sub
'Função de matriz de conversão de transferência de caracteres
Função privada ConvertToWordArray (byVal sMessage)
Escurecer lMessageLength
Dim lNumberOfWords
Dim lWordArray()
Dim lBytePosition
Dim lByteCount
Dim lWordCount
Const MODULUS_BITS = 512
Const CONGRUENT_BITS = 448
lMessageLength = Len(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)
lBytePosição = 0
lByteCount = 0
Faça até 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
Laço
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
Função final
'Função principal do deslocamento para a esquerda da string
Função privada LShift (byVal lValue, byVal iShiftBits)
Se iShiftBits = 0 Então
LShift = lValor
Função de saída
ElseIf iShiftBits = 31 Então
Se lValue e 1 então
LShift = &H80000000
Outro
LShift = 0
Terminar se
Função de saída
ElseIf iShiftBits < 0 ou iShiftBits > 31 Então
Errar.Aumentar 6
Terminar se
Se (lValue e MD5_m_l2Power(31 - iShiftBits)) Então
LShift = ((lValor e MD5_m_lOnBits(31 - (iShiftBits + 1))) * MD5_m_l2Power(iShiftBits)) ou &H80000000
Outro
LShift = ((lValor e MD5_m_lOnBits(31 - iShiftBits)) * MD5_m_l2Power(iShiftBits))
Terminar se
Função final
'Função principal do deslocamento para a direita da string
Função privada RShift (byVal lValue, byVal iShiftBits)
Se iShiftBits = 0 Então
RShift = lValor
Função de saída
ElseIf iShiftBits = 31 Então
Se lValue e &H80000000 então
RShift = 1
Outro
RShift = 0
Terminar se
Função de saída
ElseIf iShiftBits < 0 ou iShiftBits > 31 Então
Errar.Aumentar 6
Terminar se
RShift = (lValor e &H7FFFFFFE) / MD5_m_l2Power(iShiftBits)
Se (lValor e &H80000000) Então
RShift = (RShift ou (&H40000000 / MD5_m_l2Power(iShiftBits - 1)))
Terminar se
Função final
'Conversão de deslocamento de string, implementada através de funções de deslocamento para a esquerda e para a direita
Função privada RotateLeft (byVal lValue, byVal iShiftBits)
RotateLeft = LShift(lValue, iShiftBits) ou RShift(lValue, (32 - iShiftBits))
Função final
'Acrescenta codificação hexadecimal não assinada
Função privada AddUnsigned(byVal lX, byVal lY)
x4
y4
x8
y8
Dim lResult
lX8 = lX E &H80000000
ly8 = ly e &h80000000
lX4 = lX E &H40000000
ly4 = ly e &h40000000
lResult = (lX E &H3FFFFFFF) + (lY E &H3FFFFFFF)
Se lX4 e lY4 então
lResultado = lResultado Xou &H80000000 Xou lX8 Xou lY8
ElseIf lX4 ou lY4 Então
Se lResult e &H40000000 então
lResultado = lResultado Xor &HC0000000 Xou lX8 Xou lY8
Outro
lResultado = lResultado Xou &H40000000 Xou lX8 Xou lY8
Terminar se
Outro
lResultado = lResultado Xou lX8 Xou lY8
Terminar se
AddUnsigned = lResultado
Função final
'MD5_FF,MD5_GG,MD5_HH,MD5_II Função de codificação principal MD5
Subprivado MD5_FF(a, b, c, d, x, s, ac)
a = AddUnsigned(a, AddUnsigned(AddUnsigned(MD5_F(b, c, d), x), ac))
a = Girar para a esquerda (a, s)
a = AdicionarUnsigned(a, b)
Finalizar sub
Subprivado MD5_GG(a, b, c, d, x, s, ac)
a = AddUnsigned(a, AddUnsigned(AddUnsigned(MD5_G(b, c, d), x), ac))
a = Girar para a esquerda (a, s)
a = AdicionarUnsigned(a, b)
Finalizar sub
Subprivado MD5_HH(a, b, c, d, x, s, ac)
a = AddUnsigned(a, AddUnsigned(AddUnsigned(MD5_H(b, c, d), x), ac))
a = Girar para a esquerda (a, s)
a = AdicionarUnsigned(a, b)
Finalizar sub
Subprivado MD5_II(a, b, c, d, x, s, ac)
a = AddUnsigned(a, AddUnsigned(AddUnsigned(MD5_I(b, c, d), x), ac))
a = Girar para a esquerda (a, s)
a = AdicionarUnsigned(a, b)
Finalizar sub
'MD5_F,MD5_G,MD5_H,MD5_I Função de codificação auxiliar MD5
Função Privada MD5_F(x, y, z)
MD5_F = (x e y) ou ((não x) e z)
Função final
Função privada MD5_G(x, y, z)
MD5_G = (x e z) ou (y e (não z))
Função final
Função privada MD5_H(x, y, z)
MD5_H = (x Xou y Xou z)
Função final
Função Privada MD5_I(x, y, z)
MD5_I = (y Xor (x ou (Não z)))
Função final
'16 conversão de codificação hexadecimal
Função privada WordToHex (byVal lValue)
Diminuir lByte
Dim lCount
Para lCount = 0 a 3
lByte = RShift(lValor, lCount * BITS_TO_A_BYTE) e MD5_m_lOnBits(BITS_TO_A_BYTE - 1)
WordToHex = WordToHex & Right(0 & Hex(lByte), 2)
Próximo
Função final
'Função principal MD5 MD5 (string, bits de codificação)
Função pública MD5 (byVal sMessage, byVal sType)
Escurecer x
Escurecer
Dim AA
Escurecer BB
Escurecer CC
DimDD
Escureça um
Escurecer b
Escurecer c
Escurecer
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) 'Etapa de criptografia 1: conversão de array
uma = &H67452301
b = &HEFCDAB89
c = &H98BADCFE
d = &H10325476
Para k = 0 para UBound(x) Etapa 16
AA = uma
BB = b
CC = c
DD=d
'Etapa de criptografia 2: conversão de codificação
MD5_FF a, b, c, d, x(k + 0), S11, &HD76AA478
MD5_FF d, a, b, c, x(k + 1), S12, &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, &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, &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, &HD62F105D
MD5_GG d, 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_GG d, 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
'Etapa de criptografia 3: anexar conversão não assinada
a = AddUnsigned(a, AA)
b = AdicionarUnsigned(b, BB)
c = AdicionarUnsigned(c, CC)
d = AdicionarNão assinado(d, DD)
Próximo
Se sType = 32 então
'Etapa de criptografia 4: Divida e combine cada conversão hexadecimal de 8 dígitos
MD5 = LCase(WordToHex(a) & WordToHex(b) & WordToHex(c) & WordToHex(d))
Outro
MD5 = LCase(WordToHex(b) e WordToHex(c))
Terminar se
Função final
Função privada SHA256_LShift (byVal lValue, byVal iShiftBits)
Se iShiftBits = 0 Então
SHA256_LShift = lValor
Função de saída
ElseIf iShiftBits = 31 Então
Se lValue e 1 então
SHA256_LShift = &H80000000
Outro
SHA256_LShift = 0
Terminar se
Função de saída
ElseIf iShiftBits < 0 ou iShiftBits > 31 Então
Errar.Aumentar 6
Terminar se
Se (lValue e SHA256_m_l2Power(31 - iShiftBits)) Então
SHA256_LShift = ((lValor e SHA256_m_lOnBits(31 - (iShiftBits + 1))) * SHA256_m_l2Power(iShiftBits)) ou &H80000000
Outro
SHA256_LShift = ((lValor e SHA256_m_lOnBits(31 - iShiftBits)) * SHA256_m_l2Power(iShiftBits))
Terminar se
Função final
Função privada SHA256_RShift (byVal lValue, byVal iShiftBits)
Se iShiftBits = 0 Então
SHA256_RShift = lValor
Função de saída
ElseIf iShiftBits = 31 Então
Se lValue e &H80000000 então
SHA256_RShift = 1
Outro
SHA256_RShift = 0
Terminar se
Função de saída
ElseIf iShiftBits < 0 ou iShiftBits > 31 Então
Errar.Aumentar 6
Terminar se
SHA256_RShift = (lValor e &H7FFFFFFE) / SHA256_m_l2Power(iShiftBits)
Se (lValor e &H80000000) Então
SHA256_RShift = (SHA256_RShift ou (&H40000000 / SHA256_m_l2Power(iShiftBits - 1)))
Terminar se
Função final
Função privada SHA256_AddUnsigned (byVal lX, byVal lY)
x4
y4
x8
y8
Dim lResult
lX8 = lX E &H80000000
ly8 = ly e &h80000000
lX4 = lX E &H40000000
ly4 = ly e &h40000000
lResult = (lX E &H3FFFFFFF) + (lY E &H3FFFFFFF)
Se lX4 e lY4 então
lResultado = lResultado Xou &H80000000 Xou lX8 Xou lY8
ElseIf lX4 ou lY4 Então
Se lResult e &H40000000 então
lResultado = lResultado Xor &HC0000000 Xou lX8 Xou lY8
Outro
lResultado = lResultado Xor &H40000000 Xou lX8 Xou lY8
Terminar se
Outro
lResultado = lResultado Xou lX8 Xou lY8
Terminar se
SHA256_AddUnsigned = lResultado
Função final
Função privada SHA256_CH(x, y, z)
SHA256_Ch = ((x e y) Xor ((não x) e z))
Função final
Função privada SHA256_Maj(x, y, z)
SHA256_Maj = ((x e y) Xor (x e z) Xor (y e z))
Função final
Função privada SHA256_S(x, n)
SHA256_S = (SHA256_RShift(x, (n E SHA256_m_lOnBits(4))) ou SHA256_LShift(x, (32 - (n E SHA256_m_lOnBits(4)))))
Função final
Função privada SHA256_R(x, n)
SHA256_R = SHA256_RShift(x, cLng(n E SHA256_m_lOnBits(4)))
Função final
Função privada SHA256_Sigma0(x)
SHA256_Sigma0 = (SHA256_S(x, 2) Xou SHA256_S(x, 13) Xou SHA256_S(x, 22))
Função final
Função privada SHA256_Sigma1(x)
SHA256_Sigma1 = (SHA256_S(x, 6) Xou SHA256_S(x, 11) Xou SHA256_S(x, 25))
Função final
Função privada SHA256_Gamma0(x)
SHA256_Gamma0 = (SHA256_S(x, 7) Xou SHA256_S(x, 18) Xou SHA256_R(x, 3))
Função final
Função privada SHA256_Gamma1(x)
SHA256_Gamma1 = (SHA256_S(x, 17) Xou SHA256_S(x, 19) Xou SHA256_R(x, 10))
Função final
Função privada SHA256_ConvertToWordArray(byVal sMessage)
Escurecer lMessageLength
Dim lNumberOfWords
Dim lWordArray()
Dim lBytePosition
Dim lByteCount
Dim lWordCount
Diminuir lByte
Const MODULUS_BITS = 512
Const CONGRUENT_BITS = 448
lMessageLength = Len(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)
lBytePosição = 0
lByteCount = 0
Faça até 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
Laço
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
Função final
' ================================================ ========================================
'Algoritmo de criptografia SHA256
' ================================================ =======================================
'Método de chamada:
' SHA256(sMessage, p_Len)
'p_Len controla o comprimento da string gerada, 1 é 8 bits, 2 é 16 bits, o valor máximo é 8, ou seja, o comprimento após a criptografia é 64 bits
'Controle a criptografia de 8 bits/16 bits/24 bits/32 bits/40 bits/48 bits/56 bits/64 bits
Função Pública SHA256(byVal sMessage, byVal p_Len)
Escurecer HASH(7)
DiM
Escurecer W(63)
Escureça um
Escurecer b
Escurecer c
Escurecer
Dim e
f
DiMg
h
Escureça eu
j
Dim T1
Dim T2
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(sMessage)
Para i = 0 para UBound(M) Etapa 16
a = HASH(0)
b = HASH(1)
c = HASH(2)
d = HASH(3)
e = HASH(4)
f = HASH(5)
g = HASH(6)
h = HASH(7)
Para j = 0 a 63
Se j < 16 então
W(j) = M(j + eu)
Outro
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 se
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 = uma
uma = 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 =
Se p_Len >= 8 Então p_Len = 8
Se p_Len <= 0 Então p_Len = 2
Para i = 0 Para p_Len - 1
SHA256 = SHA256 & Direita(00000000 & Hex(HASH(i)), 8)
Próximo
SHA256 = LCase(SHA256)
Função final
Função pública EncryptMode (ByVal p_String, ByVal p_Type)
Dim E1s, E2s
E1s = 16 'O comprimento da primeira criptografia do algoritmo MD5 Comprimento da criptografia MD5 de 16 bits
E2s = 2 ' O comprimento da criptografia do segundo algoritmo ou SHA256 é 2*8=16 bits Comprimento da criptografia SHA256, o comprimento máximo da criptografia é 8*8=64 bits
Se não forNumeric(p_Type) então
p_Tipo = 1
ElseIf p_Type > 7 ou p_Type < 0 Then 'Julgue o número de planos com base no valor máximo de p_Type
p_Tipo = 1
Terminar se
Se não for numérico (E1s), então
E1s = 16
ElseIf E1s <> 16 E E1s <> 32 Então
E1s = 16
Terminar se
Se não for numérico (E2s), então
E2s = 2
ElseIf E2s > 8 ou E2s < 0 Então
E2s = 2
Terminar se
' ==========================================
'É melhor ajustar o esquema de criptografia ao implantá-lo pela primeira vez. Atualmente, existem até 8 esquemas.
'O comprimento da string criptografada é de 16 bits, que pode ser ajustado durante o uso.
' ==========================================
Selecione Caso p_Type
Caso 0 'Algoritmo MD5
EncryptMode = MD5(p_String, E1s)
Caso 1 'Algoritmo SHA256
EncryptMode = SHA256(p_String, E2s)
Caso 2 ' MD5 primeiro, depois SHA256
EncryptMode = SHA256(MD5(p_String, E1s), E2s)
Caso 3 'SHA256 primeiro, depois MD5
EncryptMode = MD5(SHA256(p_String, E2s), E1s)
Caso 4 'MD5 duas vezes
EncryptMode = MD5(MD5(p_String, E1s), E2s)
Caso 5 ' SHA256 duas vezes
EncryptMode = SHA256(SHA256(p_String, E1s), E2s)
Caso 6 'Os primeiros 8 bits do algoritmo MD5 e os últimos 8 bits do algoritmo SHA256
EncryptMode = Esquerda(MD5(p_String, E1s), 8) e Direita(SHA256(p_String, E2s), 8)
Caso 7 'Os primeiros 8 bits do algoritmo SHA256 e os últimos 8 bits do algoritmo MD5
EncryptMode = Esquerda(SHA256(p_String, E2s), 8) e Direita(MD5(p_String, E1s), 8)
Finalizar seleção
Função final
' ===========================================
'Função de criptografia universal para todas as senhas do site
' ===========================================
Função pública PassWordEnt(ByVal p_String)
Se p_String = ou IsNull(p_String) Então p_String = 1
'Toma o restante do valor AscW do último caractere da senha e 8 como o coeficiente do esquema de criptografia
PassWordEnt = EncryptMode(p_String, AscW(LCase(Right(p_String, 1))) Mod 8)
Função final
Fim da aula
%>
Demonstração:
Copie o código do código da seguinte forma:
<!--#include arquivo=cls_Encrypt.asp-->
<%
Escurecer
Definir o = novo Cls_Encrypt
Algoritmo Response.write MD5: & o.EncryptMode(admin,0) & <br />
Algoritmo Response.write SHA256: & o.EncryptMode(admin,1) & <br />
Response.write primeiro MD5 e depois SHA256: & o.EncryptMode(admin,2) & <br />
Response.write primeiro SHA256 e depois MD5: & o.EncryptMode(admin,3) & <br />
Response.write MD5 duas vezes: & o.EncryptMode(admin,4) & <br />
Response.write SHA256 duas vezes: & o.EncryptMode(admin,5) & <br />
Response.write Os primeiros 8 dígitos do algoritmo MD5 e os últimos 8 dígitos do algoritmo SHA256: & o.EncryptMode(admin,6) & <br />
Response.write Os primeiros 8 bits do algoritmo SHA256 e os últimos 8 bits do algoritmo MD5: & o.EncryptMode(admin,7) & <br /><hr />
Response.write usa o valor AscW do último caractere da senha e o restante de 8 como coeficiente do esquema de criptografia: & o.PassWordEnt(admin) & <br /><hr />
Criptografia MD5 de 16 bits Response.write: & o.md5(admin,16) & <br />
Criptografia MD5 de 32 bits Response.write: & o.md5(admin,32) & <br /><hr />
Criptografia SHA256 de 8 bits Response.write: & o.sha256(admin,1) & <br />
Criptografia SHA256 de 16 bits Response.write: & o.sha256(admin,2) & <br />
Criptografia SHA256 de 24 bits Response.write: & o.sha256(admin,3) & <br />
Criptografia SHA256 de 32 bits Response.write: & o.sha256(admin,4) & <br />
Criptografia SHA256 de 40 bits Response.write: & o.sha256(admin,5) & <br />
Criptografia SHA256 de 48 bits Response.write: & o.sha256(admin,6) & <br />
Criptografia SHA256 de 56 bits Response.write: & o.sha256(admin,7) & <br />
Criptografia SHA256 de 64 bits Response.write: & o.sha256(admin,8) & <br />
Definir o = nada
%>