cosmetic: s/enc_cipher/cipher/, remove comment

src/borg/crypto/key.py

@@ -359,14 +359,14 @@ class AESKeyBase(KeyBase):
     def encrypt(self, chunk):
         data = self.compressor.compress(chunk)
         self.nonce_manager.ensure_reservation(num_aes_blocks(len(data)))
-        return self.enc_cipher.encrypt(data, header=self.TYPE_STR, aad_offset=1)
+        return self.cipher.encrypt(data, header=self.TYPE_STR, aad_offset=1)
 
     def decrypt(self, id, data, decompress=True):
         if not (data[0] == self.TYPE or
             data[0] == PassphraseKey.TYPE and isinstance(self, RepoKey)):
             id_str = bin_to_hex(id) if id is not None else '(unknown)'
             raise IntegrityError('Chunk %s: Invalid encryption envelope' % id_str)
-        payload = self.enc_cipher.decrypt(data, header_len=1, aad_offset=1)
+        payload = self.cipher.decrypt(data, header_len=1, aad_offset=1)
         if not decompress:
             return payload
         data = self.decompress(payload)
@@ -392,9 +392,9 @@ class AESKeyBase(KeyBase):
             self.chunk_seed = self.chunk_seed - 0xffffffff - 1
 
     def init_ciphers(self, manifest_nonce=0):
-        self.enc_cipher = CIPHERSUITE(mac_key=self.enc_hmac_key, enc_key=self.enc_key,
-                                      iv=manifest_nonce.to_bytes(16, byteorder='big'))
-        self.nonce_manager = NonceManager(self.repository, self.enc_cipher, manifest_nonce)
+        self.cipher = CIPHERSUITE(mac_key=self.enc_hmac_key, enc_key=self.enc_key,
+                                  iv=manifest_nonce.to_bytes(16, byteorder='big'))
+        self.nonce_manager = NonceManager(self.repository, self.cipher, manifest_nonce)
 
 
 class Passphrase(str):

src/borg/testsuite/key.py

@@ -117,7 +117,7 @@ class TestKey:
     def test_keyfile(self, monkeypatch, keys_dir):
         monkeypatch.setenv('BORG_PASSPHRASE', 'test')
         key = KeyfileKey.create(self.MockRepository(), self.MockArgs())
-        assert bytes_to_long(key.enc_cipher.next_iv(), 8) == 0
+        assert bytes_to_long(key.cipher.next_iv(), 8) == 0
         manifest = key.encrypt(b'ABC')
         assert key.extract_nonce(manifest) == 0
         manifest2 = key.encrypt(b'ABC')
@@ -126,7 +126,7 @@ class TestKey:
         assert key.extract_nonce(manifest2) == 1
         iv = key.extract_nonce(manifest)
         key2 = KeyfileKey.detect(self.MockRepository(), manifest)
-        assert bytes_to_long(key2.enc_cipher.next_iv(), 8) >= iv + num_aes_blocks(len(manifest) - KeyfileKey.PAYLOAD_OVERHEAD)
+        assert bytes_to_long(key2.cipher.next_iv(), 8) >= iv + num_aes_blocks(len(manifest) - KeyfileKey.PAYLOAD_OVERHEAD)
         # Key data sanity check
         assert len({key2.id_key, key2.enc_key, key2.enc_hmac_key}) == 3
         assert key2.chunk_seed != 0
@@ -186,7 +186,7 @@ class TestKey:
     def test_passphrase(self, keys_dir, monkeypatch):
         monkeypatch.setenv('BORG_PASSPHRASE', 'test')
         key = PassphraseKey.create(self.MockRepository(), None)
-        assert bytes_to_long(key.enc_cipher.next_iv(), 8) == 0
+        assert bytes_to_long(key.cipher.next_iv(), 8) == 0
         assert hexlify(key.id_key) == b'793b0717f9d8fb01c751a487e9b827897ceea62409870600013fbc6b4d8d7ca6'
         assert hexlify(key.enc_hmac_key) == b'b885a05d329a086627412a6142aaeb9f6c54ab7950f996dd65587251f6bc0901'
         assert hexlify(key.enc_key) == b'2ff3654c6daf7381dbbe718d2b20b4f1ea1e34caa6cc65f6bb3ac376b93fed2a'
@@ -199,7 +199,7 @@ class TestKey:
         assert key.extract_nonce(manifest2) == 1
         iv = key.extract_nonce(manifest)
         key2 = PassphraseKey.detect(self.MockRepository(), manifest)
-        assert bytes_to_long(key2.enc_cipher.next_iv(), 8) == iv + num_aes_blocks(len(manifest) - PassphraseKey.PAYLOAD_OVERHEAD)
+        assert bytes_to_long(key2.cipher.next_iv(), 8) == iv + num_aes_blocks(len(manifest) - PassphraseKey.PAYLOAD_OVERHEAD)
         assert key.id_key == key2.id_key
         assert key.enc_hmac_key == key2.enc_hmac_key
         assert key.enc_key == key2.enc_key

src/borg/testsuite/nonces.py

@@ -33,7 +33,7 @@ class TestNonceManager:
         def commit_nonce_reservation(self, next_unreserved, start_nonce):
             pytest.fail("commit_nonce_reservation should never be called on an old repository")
 
-    class MockEncCipher:
+    class MockCipher:
         def __init__(self, iv):
             self.iv_set = False  # placeholder, this is never a valid iv
             self.iv = iv
@@ -67,74 +67,74 @@ class TestNonceManager:
     def test_empty_cache_and_old_server(self, monkeypatch):
         monkeypatch.setattr(nonces, 'NONCE_SPACE_RESERVATION', 0x20)
 
-        enc_cipher = self.MockEncCipher(0x2000)
+        cipher = self.MockCipher(0x2000)
         self.repository = self.MockOldRepository()
-        manager = NonceManager(self.repository, enc_cipher, 0x2000)
+        manager = NonceManager(self.repository, cipher, 0x2000)
         manager.ensure_reservation(19)
-        enc_cipher.expect_iv_and_advance(0x2000, 0x2013)
+        cipher.expect_iv_and_advance(0x2000, 0x2013)
 
         assert self.cache_nonce() == "0000000000002033"
 
     def test_empty_cache(self, monkeypatch):
         monkeypatch.setattr(nonces, 'NONCE_SPACE_RESERVATION', 0x20)
 
-        enc_cipher = self.MockEncCipher(0x2000)
+        cipher = self.MockCipher(0x2000)
         self.repository = self.MockRepository()
         self.repository.next_free = 0x2000
-        manager = NonceManager(self.repository, enc_cipher, 0x2000)
+        manager = NonceManager(self.repository, cipher, 0x2000)
         manager.ensure_reservation(19)
-        enc_cipher.expect_iv_and_advance(0x2000, 0x2013)
+        cipher.expect_iv_and_advance(0x2000, 0x2013)
 
         assert self.cache_nonce() == "0000000000002033"
 
     def test_empty_nonce(self, monkeypatch):
         monkeypatch.setattr(nonces, 'NONCE_SPACE_RESERVATION', 0x20)
 
-        enc_cipher = self.MockEncCipher(0x2000)
+        cipher = self.MockCipher(0x2000)
         self.repository = self.MockRepository()
         self.repository.next_free = None
-        manager = NonceManager(self.repository, enc_cipher, 0x2000)
+        manager = NonceManager(self.repository, cipher, 0x2000)
         manager.ensure_reservation(19)
-        enc_cipher.expect_iv_and_advance(0x2000, 0x2000 + 19)
+        cipher.expect_iv_and_advance(0x2000, 0x2000 + 19)
 
         assert self.cache_nonce() == "0000000000002033"
         assert self.repository.next_free == 0x2033
 
         # enough space in reservation
         manager.ensure_reservation(13)
-        enc_cipher.expect_iv_and_advance(0x2013, 0x2000 + 19 + 13)
+        cipher.expect_iv_and_advance(0x2013, 0x2000 + 19 + 13)
         assert self.cache_nonce() == "0000000000002033"
         assert self.repository.next_free == 0x2033
 
         # just barely enough space in reservation
         manager.ensure_reservation(19)
-        enc_cipher.expect_iv_and_advance(0x2020, 0x2000 + 19 + 13 + 19)
+        cipher.expect_iv_and_advance(0x2020, 0x2000 + 19 + 13 + 19)
         assert self.cache_nonce() == "0000000000002033"
         assert self.repository.next_free == 0x2033
 
         # no space in reservation
         manager.ensure_reservation(16)
-        enc_cipher.expect_iv_and_advance(0x2033, 0x2000 + 19 + 13 + 19 + 16)
+        cipher.expect_iv_and_advance(0x2033, 0x2000 + 19 + 13 + 19 + 16)
         assert self.cache_nonce() == "0000000000002063"
         assert self.repository.next_free == 0x2063
 
         # spans reservation boundary
         manager.ensure_reservation(64)
-        enc_cipher.expect_iv_and_advance(0x2063, 0x2000 + 19 + 13 + 19 + 16 + 64) # XXX FIX
+        cipher.expect_iv_and_advance(0x2063, 0x2000 + 19 + 13 + 19 + 16 + 64)
         assert self.cache_nonce() == "00000000000020c3"
         assert self.repository.next_free == 0x20c3
 
     def test_sync_nonce(self, monkeypatch):
         monkeypatch.setattr(nonces, 'NONCE_SPACE_RESERVATION', 0x20)
 
-        enc_cipher = self.MockEncCipher(0x2000)
+        cipher = self.MockCipher(0x2000)
         self.repository = self.MockRepository()
         self.repository.next_free = 0x2000
         self.set_cache_nonce("0000000000002000")
 
-        manager = NonceManager(self.repository, enc_cipher, 0x2000)
+        manager = NonceManager(self.repository, cipher, 0x2000)
         manager.ensure_reservation(19)
-        enc_cipher.expect_iv_and_advance(0x2000, 0x2000 + 19)
+        cipher.expect_iv_and_advance(0x2000, 0x2000 + 19)
 
         assert self.cache_nonce() == "0000000000002033"
         assert self.repository.next_free == 0x2033
@@ -142,14 +142,14 @@ class TestNonceManager:
     def test_server_just_upgraded(self, monkeypatch):
         monkeypatch.setattr(nonces, 'NONCE_SPACE_RESERVATION', 0x20)
 
-        enc_cipher = self.MockEncCipher(0x2000)
+        cipher = self.MockCipher(0x2000)
         self.repository = self.MockRepository()
         self.repository.next_free = None
         self.set_cache_nonce("0000000000002000")
 
-        manager = NonceManager(self.repository, enc_cipher, 0x2000)
+        manager = NonceManager(self.repository, cipher, 0x2000)
         manager.ensure_reservation(19)
-        enc_cipher.expect_iv_and_advance(0x2000, 0x2000 + 19)
+        cipher.expect_iv_and_advance(0x2000, 0x2000 + 19)
 
         assert self.cache_nonce() == "0000000000002033"
         assert self.repository.next_free == 0x2033
@@ -157,13 +157,13 @@ class TestNonceManager:
     def test_transaction_abort_no_cache(self, monkeypatch):
         monkeypatch.setattr(nonces, 'NONCE_SPACE_RESERVATION', 0x20)
 
-        enc_cipher = self.MockEncCipher(0x1000)
+        cipher = self.MockCipher(0x1000)
         self.repository = self.MockRepository()
         self.repository.next_free = 0x2000
 
-        manager = NonceManager(self.repository, enc_cipher, 0x2000)
+        manager = NonceManager(self.repository, cipher, 0x2000)
         manager.ensure_reservation(19)
-        enc_cipher.expect_iv_and_advance(0x2000, 0x2000 + 19)
+        cipher.expect_iv_and_advance(0x2000, 0x2000 + 19)
 
         assert self.cache_nonce() == "0000000000002033"
         assert self.repository.next_free == 0x2033
@@ -171,27 +171,27 @@ class TestNonceManager:
     def test_transaction_abort_old_server(self, monkeypatch):
         monkeypatch.setattr(nonces, 'NONCE_SPACE_RESERVATION', 0x20)
 
-        enc_cipher = self.MockEncCipher(0x1000)
+        cipher = self.MockCipher(0x1000)
         self.repository = self.MockOldRepository()
         self.set_cache_nonce("0000000000002000")
 
-        manager = NonceManager(self.repository, enc_cipher, 0x2000)
+        manager = NonceManager(self.repository, cipher, 0x2000)
         manager.ensure_reservation(19)
-        enc_cipher.expect_iv_and_advance(0x2000, 0x2000 + 19)
+        cipher.expect_iv_and_advance(0x2000, 0x2000 + 19)
 
         assert self.cache_nonce() == "0000000000002033"
 
     def test_transaction_abort_on_other_client(self, monkeypatch):
         monkeypatch.setattr(nonces, 'NONCE_SPACE_RESERVATION', 0x20)
 
-        enc_cipher = self.MockEncCipher(0x1000)
+        cipher = self.MockCipher(0x1000)
         self.repository = self.MockRepository()
         self.repository.next_free = 0x2000
         self.set_cache_nonce("0000000000001000")
 
-        manager = NonceManager(self.repository, enc_cipher, 0x2000)
+        manager = NonceManager(self.repository, cipher, 0x2000)
         manager.ensure_reservation(19)
-        enc_cipher.expect_iv_and_advance(0x2000, 0x2000 + 19)
+        cipher.expect_iv_and_advance(0x2000, 0x2000 + 19)
 
         assert self.cache_nonce() == "0000000000002033"
         assert self.repository.next_free == 0x2033
@@ -199,14 +199,14 @@ class TestNonceManager:
     def test_interleaved(self, monkeypatch):
         monkeypatch.setattr(nonces, 'NONCE_SPACE_RESERVATION', 0x20)
 
-        enc_cipher = self.MockEncCipher(0x2000)
+        cipher = self.MockCipher(0x2000)
         self.repository = self.MockRepository()
         self.repository.next_free = 0x2000
         self.set_cache_nonce("0000000000002000")
 
-        manager = NonceManager(self.repository, enc_cipher, 0x2000)
+        manager = NonceManager(self.repository, cipher, 0x2000)
         manager.ensure_reservation(19)
-        enc_cipher.expect_iv_and_advance(0x2000, 0x2000 + 19)
+        cipher.expect_iv_and_advance(0x2000, 0x2000 + 19)
 
         assert self.cache_nonce() == "0000000000002033"
         assert self.repository.next_free == 0x2033
@@ -216,12 +216,12 @@ class TestNonceManager:
 
         # enough space in reservation
         manager.ensure_reservation(12)
-        enc_cipher.expect_iv_and_advance(0x2013, 0x2000 + 19 + 12)
+        cipher.expect_iv_and_advance(0x2013, 0x2000 + 19 + 12)
         assert self.cache_nonce() == "0000000000002033"
         assert self.repository.next_free == 0x4000
 
         # spans reservation boundary
         manager.ensure_reservation(21)
-        enc_cipher.expect_iv_and_advance(0x4000, 0x4000 + 21)
+        cipher.expect_iv_and_advance(0x4000, 0x4000 + 21)
         assert self.cache_nonce() == "0000000000004035"
         assert self.repository.next_free == 0x4035