Rijndael in Ruby entschlüsseln (in VB.net verschlüsselt)
Ich benutze Rinjael, um in VB.NET zu kodieren und muss in Ruby dekodieren. Meine VB.NET-Verschlüsselungsklasse sieht folgendermaßen aus:
Private Class Encryptor
Private symmetricKey As System.Security.Cryptography.RijndaelManaged
Private iVector As Byte()
Private Key As Byte()
Public Function encrypt(ByVal data As String) As String
Try
Dim plainTextBytes As Byte() = System.Text.Encoding.ASCII.GetBytes(data)
Dim encryptor As System.Security.Cryptography.ICryptoTransform = symmetricKey.CreateEncryptor(Key, iVector)
Dim memoryStream As New System.IO.MemoryStream
Dim cryptoStream As System.Security.Cryptography.CryptoStream = New System.Security.Cryptography.CryptoStream(memoryStream, encryptor, System.Security.Cryptography.CryptoStreamMode.Write)
cryptoStream.Write(plainTextBytes, 0, plainTextBytes.Length)
cryptoStream.FlushFinalBlock()
Dim cipherTextBytes As Byte() = memoryStream.ToArray()
memoryStream.Close()
cryptoStream.Close()
Return Convert.ToBase64String(cipherTextBytes)
Catch
Return ""
End Try
End Function
Public Function decrypt(ByVal data As String) As String
Try
Dim crypted As Byte() = Convert.FromBase64String(data)
Dim decryptor As System.Security.Cryptography.ICryptoTransform = symmetricKey.CreateDecryptor(Key, iVector)
Dim memoryStream As New System.IO.MemoryStream(crypted)
Dim cryptoStream As System.Security.Cryptography.CryptoStream = New System.Security.Cryptography.CryptoStream(memoryStream, decryptor, System.Security.Cryptography.CryptoStreamMode.Read)
Dim plain(crypted.Length) As Byte
Dim count As Integer = cryptoStream.Read(plain, 0, plain.Length)
memoryStream.Close()
cryptoStream.Close()
Return System.Text.Encoding.UTF8.GetString(plain, 0, count)
Catch
Return ""
End Try
End Function
Public Sub New(ByVal clientkey As String)
iVector = System.Text.Encoding.ASCII.GetBytes("1234567890123456")
Key = System.Text.Encoding.ASCII.GetBytes(clientkey)
symmetricKey = New System.Security.Cryptography.RijndaelManaged
symmetricKey.Mode = System.Security.Cryptography.CipherMode.CBC
End Sub
End Class
Das funktioniert in Ordnung und ich kann in Java mit dem AES / CBC / PKCS5Padding entschlüsseln. Jetzt sind mein Passwort und iv 16 Zeichen lang (16 * 16bit = 256). Wenn ich versuche, in Ruby zu entschlüsseln, beschwert es sich, dass mein Passwort zu kurz ist ... Ich gehe davon aus, dass es 8-Bit-Zeichen verwendet. Ich benutze diese Klasse zur Entschlüsselung in Ruby:
require 'openssl'
module Crypt
# Decrypts a block of data (encrypted_data) given an encryption key
# and an initialization vector (iv). Keys, iv's, and the data
# returned are all binary strings. Cipher_type should be
# "AES-256-CBC", "AES-256-ECB", or any of the cipher types
# supported by OpenSSL. Pass nil for the iv if the encryption type
# doesn't use iv's (like ECB).
#:return: => String
#:arg: encrypted_data => String
#:arg: key => String
#:arg: iv => String
#:arg: cipher_type => String
def Crypt.decrypt(encrypted_data, key, iv, cipher_type)
aes = OpenSSL::Cipher::Cipher.new(cipher_type)
aes.decrypt
aes.key = key
aes.iv = iv if iv != nil
aes.update(encrypted_data) + aes.final
end
# Encrypts a block of data given an encryption key and an
# initialization vector (iv). Keys, iv's, and the data returned
# are all binary strings. Cipher_type should be "AES-256-CBC",
# "AES-256-ECB", or any of the cipher types supported by OpenSSL.
# Pass nil for the iv if the encryption type doesn't use iv's (like
# ECB).
#:return: => String
#:arg: data => String
#:arg: key => String
#:arg: iv => String
#:arg: cipher_type => String
def Crypt.encrypt(data, key, iv, cipher_type)
aes = OpenSSL::Cipher::Cipher.new(cipher_type)
aes.encrypt
aes.key = key
aes.iv = iv if iv != nil
aes.update(data) + aes.final
end
end
Jetzt. Durch den Versuch, mit Crypt.decrypt (data, key, iv, "AES-CBC-256") zu entschlüsseln, bin ich sicher, dass vorläufige String / Byte-Transformationen an meinen Daten, key, iv durchgeführt werden müssen, um korrekt zu funktionieren.
Wie soll ich Crypt.decrypt mit key = "passwordpassword" und iv = "1234567890123456" anrufen? Muss ich meine Daten mit base64 dekodieren?
Hier ist mein Entschlüsselungsaufruf, der anscheinend nicht funktioniert (Auffüllen mit Nullen):
text = Base64.decode64(text)
pass = Digest::SHA1.hexdigest("#{@pass}0000000000000000").unpack('a2'*32).map{|x| x.hex}.pack('c'*32)
iv = Digest::SHA1.hexdigest("12345678901234560000000000000000").unpack('a2'*32).map{|x| x.hex}.pack('c'*32)
return Crypt.decrypt(text,pass,iv,"AES-256-CBC")