AspClassico - Criptografia AES CBC HMac
AES_SHA256.asp
<%
' AES-256-CBC with HMAC-SHA-256 in VBScript
Set utf8 = CreateObject("System.Text.UTF8Encoding")
Set b64Enc = CreateObject("System.Security.Cryptography.ToBase64Transform")
Set b64Dec = CreateObject("System.Security.Cryptography.FromBase64Transform")
Set mac = CreateObject("System.Security.Cryptography.HMACSHA256")
Set aes = CreateObject("System.Security.Cryptography.RijndaelManaged")
Set mem = CreateObject("System.IO.MemoryStream")
Function Min(a, b)
Min = a
If b < a Then Min = b
End Function
Function B64Encode(bytes)
blockSize = b64Enc.InputBlockSize
For offset = 0 To LenB(bytes) - 1 Step blockSize
length = Min(blockSize, LenB(bytes) - offset)
b64Block = b64Enc.TransformFinalBlock((bytes), offset, length)
result = result & utf8.GetString((b64Block))
Next
B64Encode = result
End Function
Function B64Decode(b64Str)
bytes = utf8.GetBytes_4(b64Str)
B64Decode = b64Dec.TransformFinalBlock((bytes), 0, LenB(bytes))
End Function
Function ConcatBytes(a, b)
mem.SetLength(0)
mem.Write (a), 0, LenB(a)
mem.Write (b), 0, LenB(b)
ConcatBytes = mem.ToArray()
End Function
Function EqualBytes(a, b)
EqualBytes = False
If LenB(a) <> LenB(b) Then Exit Function
diff = 0
For i = 1 to LenB(a)
diff = diff Or (AscB(MidB(a, i, 1)) Xor AscB(MidB(b, i, 1)))
Next
EqualBytes = Not diff
End Function
Function ComputeMAC(msgBytes, keyBytes)
mac.Key = keyBytes
ComputeMAC = mac.ComputeHash_2((msgBytes))
End Function
'Criptografe o texto simples e calcule o MAC para o resultado.
'
'O comprimento da chave de criptografia AES (aesKey) deve ser de 256 bits (32 bytes).
'Deve ser fornecido como uma string codificada em Base64. No macOS ou Linux,
'digite este comando para gerar uma chave de 256 bits codificada em Base64:
'
'head -c32 / dev / urandom | base64
'
'A chave secreta HMAC (macKey) pode ter qualquer comprimento, mas um mínimo de
'256 bits (32 bytes) é recomendado como o comprimento desta chave. Isso deve
'ser fornecido como uma string codificada em Base64.
'
'O valor de retorno desta função é composto pelos três seguintes
'Strings codificados em Base64 unidos por dois pontos:
'
'- Código de autenticação da mensagem.
'- Vetor de inicialização de 128 bits gerado aleatoriamente (IV).
'- Texto cifrado.
'
' Nota:
'
'- Uma chave de 256 bits após a codificação Base64 contém 44 caracteres
'incluindo um' = 'caractere como preenchimento no final.
'- Um IV de 128 bits após a codificação Base64 contém 24 caracteres
'incluindo dois' = 'caracteres como preenchimento no final.
'
'Argumentos:
'plaintext (String): Texto a ser criptografado.
'aesKey (String): chave de criptografia AES codificada como uma string Base64.
'macKey (String): chave secreta HMAC codificada como uma string Base64.
'
'Retorna:
'String: MAC, IV e texto cifrado unidos por dois pontos.
Function Encrypt(plaintext, aesKey, macKey)
aes.GenerateIV()
aesKeyBytes = B64Decode(aesKey)
macKeyBytes = B64Decode(macKey)
Set aesEnc = aes.CreateEncryptor_2((aesKeyBytes), aes.IV)
plainBytes = utf8.GetBytes_4(plaintext)
cipherBytes = aesEnc.TransformFinalBlock((plainBytes), 0, LenB(plainBytes))
macBytes = ComputeMAC(ConcatBytes(aes.IV, cipherBytes), macKeyBytes)
Encrypt = B64Encode(macBytes) & ":" & B64Encode(aes.IV) & ":" & _
B64Encode(cipherBytes)
End Function
'Descriptografe o texto cifrado depois de autenticar o IV e o texto cifrado usando MAC.
'
'MAC, IV e o texto cifrado devem ser codificados em Base64. Eles são fornecidos
'juntos como uma única string com os valores codificados em Base64 separados
'por dois pontos. Veja o comentário da função Encrypt () para ler mais sobre
' O formato.
'
'Argumentos:
'macIVCipherText (String): MAC, IV e texto cifrado separados por dois pontos.
'aesKey (String): chave de criptografia AES codificada como uma string Base64.
'macKey (String): chave secreta HMAC codificada como uma string Base64.
'
'Retorna:
'String: Texto simples para o qual o texto cifrado fornecido é descriptografado.
Function Decrypt(macIVCiphertext, aesKey, macKey)
aesKeyBytes = B64Decode(aesKey)
macKeyBytes = B64Decode(macKey)
tokens = Split(macIVCiphertext, ":")
macBytes = B64Decode(tokens(0))
ivBytes = B64Decode(tokens(1))
cipherBytes = B64Decode(tokens(2))
macActual = ComputeMAC(ConcatBytes(ivBytes, cipherBytes), macKeyBytes)
If Not EqualBytes(macBytes, macActual) Then
Err.Raise vbObjectError + 1000, "Decrypt()", "Bad MAC"
End If
Set aesDec = aes.CreateDecryptor_2((aesKeyBytes), (ivBytes))
plainBytes = aesDec.TransformFinalBlock((cipherBytes), 0, LenB(cipherBytes))
Decrypt = utf8.GetString((plainBytes))
End Function
' Mostra propriedades interessantes de objetos de criptografia usados aqui.
Function CryptoInfo
Set enc = aes.CreateEncryptor_2(aes.Key, aes.IV)
Set dec = aes.CreateDecryptor_2(aes.Key, aes.IV)
CryptoInfo = "aes.BlockSize: " & aes.BlockSize & vbCrLf & _
"aes.FeedbackSize: " & aes.FeedbackSize & vbCrLf & _
"aes.KeySize: " & aes.KeySize & vbCrLf & _
"aes.Mode: " & aes.Mode & vbCrLf & _
"aes.Padding: " & aes.Padding & vbCrLf & _
"mac.HashName: " & mac.HashName & vbCrLf & _
"mac.HashSize: " & mac.HashSize & vbCrLf & _
"aesEnc.InputBlockSize: " & enc.InputBlockSize & vbCrLf & _
"aesEnc.OutputBlockSize: " & enc.OutputBlockSize & vbCrLf & _
"aesDec.InputBlockSize: " & enc.InputBlockSize & vbCrLf & _
"aesDec.OutputBlockSize: " & enc.OutputBlockSize & vbCrLf & _
"b64Enc.InputBlockSize: " & b64Enc.InputBlockSize & vbCrLf & _
"b64Enc.OutputBlockSize: " & b64Enc.OutputBlockSize & vbCrLf & _
"b64Dec.InputBlockSize: " & b64Dec.InputBlockSize & vbCrLf & _
"b64Dec.OutputBlockSize: " & b64Dec.OutputBlockSize & vbCrLf
End Function
%>
-------------------------------------------------------------------------------------------------------
exemplo.asp
<%
Plaintext = "AspClassico"
AESKey = "QGFzcF9jbGFzc2ljb0A=" ' Palavra @asp_classico@ convertido para Base64 - Deve ter 14 caracteres
MACKey = "VTXs5H3SsmamlMowXb/I6ZdIT06qnzliI1UOK4B8uhM=" ' Hash SHA-256 gerado com TextPlain="MinhaEmpresa", SecretKey="@MinhaEmpresa"
' Testei com os sites abaixo e produziu o mesmo resultado, posteriormente convertido para Base64
' https://codebeautify.org/hmac-generator
' https://www.devglan.com/online-tools/hmac-sha256-online
encrypted1 = Encrypt(Plaintext, AESKey, MACKey)
decrypted1 = Decrypt(encrypted1, AESKey, MACKey)
response.write "Texto origem: " & decrypted1
response.write "
Criptogrado : " & encrypted1
%>
