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") } }