ASP Classico

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

Título

Criptografia AES-CSC com HMCA SHA-256

Parâmetros de entrada

PlaintextStringO texto que será criptogrado

AESKeyStringPalavra "Chave" convertida para Base64 - Pode ser recebido como um Token, por exemplo. Chave de criptografia AES codificada como uma string Base64.

MACKeyStringHash SHA-256 gerado com TextPlain="MinhaEmpresa", SecretKey="@MinhaEmpresa. Chave secreta HMAC codificada como uma string Base64.

Parâmetros de saída

String: MAC, IV e texto cifrado unidos por dois pontos.

Este Script UTILIZA bibliotecas do Asp.Net presentes em todo servidor Windows:

-System.Text.UTF8Encoding

-System.Security.Cryptography.ToBase64Transform

-System.Security.Cryptography.FromBase64Transform

-System.Security.Cryptography.HMACSHA256

-System.Security.Cryptography.RijndaelManaged

-System.IO.MemoryStream

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, (quando salvo em VBS) 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.