Merge pull request #112 from reaperhulk/block-cipher-decrypt

Block Cipher Decryption

2 files changed, 40 insertions, 25 deletions

diff --git a/tests/primitives/test_block.py b/tests/primitives/test_block.py
index 9f5905bf..5e147a79 100644
--- a/tests/primitives/test_block.py
+++ b/tests/primitives/test_block.py
@@ -15,11 +15,10 @@ from __future__ import absolute_import, division, print_function
 
 import binascii
 
-import pretend
 import pytest
 
+from cryptography.primitives import interfaces
 from cryptography.primitives.block import BlockCipher, ciphers, modes
-from cryptography.primitives.block.base import _Operation
 
 
 class TestBlockCipher(object):
@@ -29,40 +28,42 @@ class TestBlockCipher(object):
             modes.CBC(binascii.unhexlify(b"0" * 32))
         )
 
-    def test_use_after_finalize(self, api):
+    def test_creates_encryptor(self):
         cipher = BlockCipher(
             ciphers.AES(binascii.unhexlify(b"0" * 32)),
-            modes.CBC(binascii.unhexlify(b"0" * 32)),
-            api
+            modes.CBC(binascii.unhexlify(b"0" * 32))
         )
-        cipher.encrypt(b"a" * 16)
-        cipher.finalize()
-        with pytest.raises(ValueError):
-            cipher.encrypt(b"b" * 16)
-        with pytest.raises(ValueError):
-            cipher.finalize()
+        assert isinstance(cipher.encryptor(), interfaces.CipherContext)
 
-    def test_encrypt_with_invalid_operation(self, api):
+    def test_creates_decryptor(self):
         cipher = BlockCipher(
             ciphers.AES(binascii.unhexlify(b"0" * 32)),
-            modes.CBC(binascii.unhexlify(b"0" * 32)),
-            api
+            modes.CBC(binascii.unhexlify(b"0" * 32))
         )
-        cipher._operation = _Operation.decrypt
+        assert isinstance(cipher.decryptor(), interfaces.CipherContext)
 
-        with pytest.raises(ValueError):
-            cipher.encrypt(b"b" * 16)
 
-    def test_finalize_with_invalid_operation(self, api):
+class TestBlockCipherContext(object):
+    def test_use_after_finalize(self, api):
         cipher = BlockCipher(
             ciphers.AES(binascii.unhexlify(b"0" * 32)),
             modes.CBC(binascii.unhexlify(b"0" * 32)),
             api
         )
-        cipher._operation = pretend.stub(name="wat")
-
+        encryptor = cipher.encryptor()
+        encryptor.update(b"a" * 16)
+        encryptor.finalize()
+        with pytest.raises(ValueError):
+            encryptor.update(b"b" * 16)
+        with pytest.raises(ValueError):
+            encryptor.finalize()
+        decryptor = cipher.decryptor()
+        decryptor.update(b"a" * 16)
+        decryptor.finalize()
+        with pytest.raises(ValueError):
+            decryptor.update(b"b" * 16)
         with pytest.raises(ValueError):
-            cipher.finalize()
+            decryptor.finalize()
 
     def test_unaligned_block_encryption(self, api):
         cipher = BlockCipher(
@@ -70,7 +71,16 @@ class TestBlockCipher(object):
             modes.ECB(),
             api
         )
-        ct = cipher.encrypt(b"a" * 15)
+        encryptor = cipher.encryptor()
+        ct = encryptor.update(b"a" * 15)
         assert ct == b""
-        ct += cipher.encrypt(b"a" * 65)
+        ct += encryptor.update(b"a" * 65)
         assert len(ct) == 80
+        ct += encryptor.finalize()
+        decryptor = cipher.decryptor()
+        pt = decryptor.update(ct[:3])
+        assert pt == b""
+        pt += decryptor.update(ct[3:])
+        assert len(pt) == 80
+        assert pt == b"a" * 80
+        decryptor.finalize()
diff --git a/tests/primitives/utils.py b/tests/primitives/utils.py
index a15e773c..91ca36d8 100644
--- a/tests/primitives/utils.py
+++ b/tests/primitives/utils.py
@@ -37,9 +37,14 @@ def encrypt_test(api, cipher_factory, mode_factory, params, only_if,
         mode_factory(**params),
         api
     )
-    actual_ciphertext = cipher.encrypt(binascii.unhexlify(plaintext))
-    actual_ciphertext += cipher.finalize()
+    encryptor = cipher.encryptor()
+    actual_ciphertext = encryptor.update(binascii.unhexlify(plaintext))
+    actual_ciphertext += encryptor.finalize()
     assert actual_ciphertext == binascii.unhexlify(ciphertext)
+    decryptor = cipher.decryptor()
+    actual_plaintext = decryptor.update(binascii.unhexlify(ciphertext))
+    actual_plaintext += decryptor.finalize()
+    assert actual_plaintext == binascii.unhexlify(plaintext)
 
 
 def generate_hash_test(param_loader, path, file_names, hash_cls,