func TestCBCEncryptCBCDecrypt(t *testing.T) {
// Encrypt with CBCEncrypt and Decrypt with CBCDecrypt
key := make([]byte, 32)
rand.Reader.Read(key)
var msg = []byte("a 16 byte messag")
encrypted, encErr := primitives.CBCEncrypt(key, msg)
if encErr != nil {
t.Fatalf("Error encrypting message %v", encErr)
}
decrypted, dErr := primitives.CBCDecrypt(key, encrypted)
if dErr != nil {
t.Fatalf("Error encrypting message %v", dErr)
}
if string(msg[:]) != string(decrypted[:]) {
t.Fatal("Encryption->Decryption with same key should result in original message")
}
}
// TestCBCEncryptCBCDecrypt_KeyMismatch attempts to decrypt with a different key than the one used for encryption.
func TestCBCEncryptCBCDecrypt_KeyMismatch(t *testing.T) {
// Generate a random key
key := make([]byte, aes.BlockSize)
rand.Reader.Read(key)
// Clone & tamper with the key
wrongKey := make([]byte, aes.BlockSize)
copy(wrongKey, key[:])
wrongKey[0] = key[0] + 1
var ptext = []byte("1234567890ABCDEF")
encrypted, encErr := primitives.CBCEncrypt(key, ptext)
if encErr != nil {
t.Fatalf("Error encrypting '%s': %v", ptext, encErr)
}
decrypted, decErr := primitives.CBCDecrypt(wrongKey, encrypted)
if decErr != nil {
t.Fatalf("Error decrypting '%s': %v", ptext, decErr)
}
if string(ptext[:]) == string(decrypted[:]) {
t.Fatal("Decrypting a ciphertext with a different key than the one used for encrypting it - should not result in the original plaintext.")
}
}
func TestCBCEncrypt_EmptyText(t *testing.T) {
// Encrypt an empty message. Mainly to document
// a borderline case. Checking as well that the
// cipher length is as expected.
key := make([]byte, 32)
rand.Reader.Read(key)
t.Log("Generated key: ", key)
var msg = []byte("")
t.Log("Message length: ", len(msg))
cipher, encErr := primitives.CBCEncrypt(key, msg)
if encErr != nil {
t.Fatalf("Error encrypting message %v", encErr)
}
t.Log("Cipher length: ", len(cipher))
// expected cipher length: aes.BlockSize
// the first and only block is the IV
var expectedLength = aes.BlockSize
if len(cipher) != expectedLength {
t.Fatalf("Cipher length is wrong. Expected %d, got %d",
expectedLength, len(cipher))
}
t.Log("Cipher: ", cipher)
}
func TestCBCEncryptCBCPKCS7Decrypt_ExpectingFailure(t *testing.T) {
// When encrypting a message that does not need padding, i.e. a message
// whose length is a multiple of the block size, with CBCEncrypt, it
// cannot be decrypted with CBCPKCS7DEcrypt.
//
// The intend of this test is to document this behaviour for clarity.
//
// The reason is that the section 10.3 Note 2 in #PKCS7 states that
// an extra block is appended to the message for padding. Since this
// extra block is missing when using CBCEncrypt for encryption,
// CBCPKCS7Decrypt fails.
key := make([]byte, 32)
rand.Reader.Read(key)
var msg = []byte("a 16 byte messag")
encrypted, encErr := primitives.CBCEncrypt(key, msg)
if encErr != nil {
t.Fatalf("Error encrypting message %v", encErr)
}
decrypted, dErr := primitives.CBCPKCS7Decrypt(key, encrypted)
if dErr != nil {
// expected behaviour, decryption fails.
t.Logf("Expected error decrypting message %v, decrypted message = %v", dErr, decrypted)
}
}
// TestCBCEncryptCBCPKCS7Decrypt_BlockSizeLengthPlaintext verifies that CBCPKCS7Decrypt returns an error
// when attempting to decrypt ciphertext of an irreproducible length.
func TestCBCEncryptCBCPKCS7Decrypt_BlockSizeLengthPlaintext(t *testing.T) {
// One of the purposes of this test is to also document and clarify the expected behavior, i.e., that an extra
// block is appended to the message at the padding stage, as per the spec of PKCS#7 v1.5 [see RFC-2315 p.21]
key := make([]byte, primitives.AESKeyLength)
rand.Reader.Read(key)
// 1234567890123456
var ptext = []byte("a 16 byte messag")
encrypted, encErr := primitives.CBCEncrypt(key, ptext)
if encErr != nil {
t.Fatalf("Error encrypting '%s': %v", ptext, encErr)
}
decrypted, dErr := primitives.CBCPKCS7Decrypt(key, encrypted)
if dErr == nil {
t.Fatalf("Expected an error decrypting ptext '%s'. Decrypted to '%v'", dErr, decrypted)
}
}
// TestCBCEncryptCBCDecrypt encrypts with CBCEncrypt and decrypt with CBCDecrypt.
func TestCBCEncryptCBCDecrypt(t *testing.T) {
key := make([]byte, primitives.AESKeyLength)
rand.Reader.Read(key)
// 1234567890123456
var ptext = []byte("a 16 byte messag")
encrypted, encErr := primitives.CBCEncrypt(key, ptext)
if encErr != nil {
t.Fatalf("Error encrypting '%s': %v", ptext, encErr)
}
decrypted, decErr := primitives.CBCDecrypt(key, encrypted)
if decErr != nil {
t.Fatalf("Error decrypting '%s': %v", ptext, decErr)
}
if string(ptext[:]) != string(decrypted[:]) {
t.Fatal("Encryption->Decryption with same key should result in the original plaintext.")
}
}
// TestCBCEncrypt_EmptyPlaintext encrypts an empty message. Verifying as well that the ciphertext length is as expected.
func TestCBCEncrypt_EmptyPlaintext(t *testing.T) {
key := make([]byte, primitives.AESKeyLength)
rand.Reader.Read(key)
t.Log("Generated key: ", key)
var emptyPlaintext = []byte("")
t.Log("Message length: ", len(emptyPlaintext))
ciphertext, encErr := primitives.CBCEncrypt(key, emptyPlaintext)
if encErr != nil {
}
t.Log("Ciphertext length: ", len(ciphertext))
// Expected cipher length: aes.BlockSize, the first and only block is the IV
var expectedLength = aes.BlockSize
if len(ciphertext) != expectedLength {
t.Fatalf("Wrong ciphertext length. Expected: '%d', received: '%d'", expectedLength, len(ciphertext))
}
t.Log("Ciphertext: ", ciphertext)
}
func TestCBCEncryptCBCDecrypt_KeyMismatch(t *testing.T) {
defer func() {
recover()
}()
key := make([]byte, 32)
rand.Reader.Read(key)
decryptionKey := make([]byte, 32)
copy(decryptionKey, key[:])
decryptionKey[0] = key[0] + 1
var msg = []byte("a message to be encrypted")
encrypted, _ := primitives.CBCEncrypt(key, msg)
decrypted, _ := primitives.CBCDecrypt(decryptionKey, encrypted)
if string(msg[:]) == string(decrypted[:]) {
t.Fatal("Encryption->Decryption with different keys shouldn't return original message")
}
}
