Use more constants

diff --git a/pygost/gost3412.py b/pygost/gost3412.py
index 296e4fbea72a794ca625c71663ce38b223b0d9e6..0c1d2ced896cebe222ddcf033d0928fa0da57efe 100644 (file)
--- a/pygost/gost3412.py
+++ b/pygost/gost3412.py
@@ -26,7 +26,7 @@ from pygost.utils import strxor
 from pygost.utils import xrange
 
 
-KEY_SIZE = 32
+KEYSIZE = 32
 
 LC = bytearray((
     148, 32, 133, 16, 194, 192, 1, 251, 1, 192, 194, 16, 133, 32, 148, 1,

diff --git a/pygost/gost3413.py b/pygost/gost3413.py
index 495a3f9e343826ed430616f88b63c4ead6ca5b60..5aeaec63ef415091ae3de81b64facb57e0af62bd 100644 (file)
--- a/pygost/gost3413.py
+++ b/pygost/gost3413.py
@@ -24,7 +24,7 @@ from pygost.utils import strxor
 from pygost.utils import xrange
 
 
-KEY_SIZE = 32
+KEYSIZE = 32
 
 
 def pad_size(data_size, blocksize):
@@ -112,7 +112,7 @@ def acpkm(encrypter, bs):
     """
     return b"".join([
         encrypter(bytes(bytearray(range(d, d + bs))))
-        for d in range(0x80, 0x80 + bs * (KEY_SIZE // bs), bs)
+        for d in range(0x80, 0x80 + bs * (KEYSIZE // bs), bs)
     ])
 
 
@@ -346,17 +346,17 @@ def mac_acpkm_master(algo_class, encrypter, key_section_size, section_size, bs,
         encrypter,
         key_section_size,
         bs,
-        (KEY_SIZE + bs) * sections,
+        (KEYSIZE + bs) * sections,
     )
     for i in xrange(0, tail_offset, bs):
         if i % section_size == 0:
-            keymat, keymats = keymats[:KEY_SIZE + bs], keymats[KEY_SIZE + bs:]
-            key, k1 = keymat[:KEY_SIZE], keymat[KEY_SIZE:]
+            keymat, keymats = keymats[:KEYSIZE + bs], keymats[KEYSIZE + bs:]
+            key, k1 = keymat[:KEYSIZE], keymat[KEYSIZE:]
             encrypter = algo_class(key).encrypt
         prev = encrypter(strxor(data[i:i + bs], prev))
     tail = data[tail_offset:]
     if len(tail) == bs:
-        key, k1 = keymats[:KEY_SIZE], keymats[KEY_SIZE:]
+        key, k1 = keymats[:KEYSIZE], keymats[KEYSIZE:]
         encrypter = algo_class(key).encrypt
     k2 = long2bytes(bytes2long(k1) << 1, size=bs)
     if bytearray(k1)[0] & 0x80 != 0:

diff --git a/pygost/test_gost28147.py b/pygost/test_gost28147.py
index 5e3191e1a2a960f00a5ab5f8e039c46613a63c51..5ccb6870693ad22ffac0a3c1ebea3831783299ce 100644 (file)
--- a/pygost/test_gost28147.py
+++ b/pygost/test_gost28147.py
@@ -18,6 +18,7 @@ from os import urandom
 from unittest import TestCase
 
 from pygost.gost28147 import block2ns
+from pygost.gost28147 import BLOCKSIZE
 from pygost.gost28147 import cbc_decrypt
 from pygost.gost28147 import cbc_encrypt
 from pygost.gost28147 import cfb_decrypt
@@ -27,6 +28,7 @@ from pygost.gost28147 import DEFAULT_SBOX
 from pygost.gost28147 import ecb_decrypt
 from pygost.gost28147 import ecb_encrypt
 from pygost.gost28147 import encrypt
+from pygost.gost28147 import KEYSIZE
 from pygost.gost28147 import MESH_MAX_DATA
 from pygost.gost28147 import ns2block
 from pygost.utils import hexdec
@@ -171,8 +173,8 @@ class CFBTest(TestCase):
     def test_steps(self):
         """ Check step-by-step operation manually
         """
-        key = urandom(32)
-        iv = urandom(8)
+        key = urandom(KEYSIZE)
+        iv = urandom(BLOCKSIZE)
         plaintext = urandom(20)
         ciphertext = cfb_encrypt(key, plaintext, iv)
 
@@ -194,8 +196,8 @@ class CFBTest(TestCase):
     def test_random(self):
         """ Random data with various sizes
         """
-        key = urandom(32)
-        iv = urandom(8)
+        key = urandom(KEYSIZE)
+        iv = urandom(BLOCKSIZE)
         for size in (5, 8, 16, 120):
             pt = urandom(size)
             self.assertSequenceEqual(
@@ -307,7 +309,7 @@ class CTRTest(TestCase):
             0x13, 0xcc, 0x55, 0x38, 0xb5, 0x63, 0x32, 0xc5,
             0x23, 0xa4, 0xcb, 0x7d, 0x51,
         )))
-        iv = 8 * b"\x00"
+        iv = BLOCKSIZE * b"\x00"
         encrypted = cnt(key, plaintext, iv=iv, sbox=sbox)
         self.assertSequenceEqual(encrypted, ciphertext)
         decrypted = cnt(key, encrypted, iv=iv, sbox=sbox)
@@ -316,7 +318,7 @@ class CTRTest(TestCase):
 
 class CBCTest(TestCase):
     def test_pad_requirement(self):
-        key = 32 * b"x"
+        key = KEYSIZE * b"x"
         for s in (b"", b"foo", b"foobarbaz"):
             with self.assertRaises(ValueError):
                 cbc_encrypt(key, s, pad=False)
@@ -324,23 +326,23 @@ class CBCTest(TestCase):
                 cbc_decrypt(key, s, pad=False)
 
     def test_passes(self):
-        iv = urandom(8)
-        key = 32 * b"x"
+        iv = urandom(BLOCKSIZE)
+        key = KEYSIZE * b"x"
         for pt in (b"foo", b"foobarba", b"foobarbaz", 16 * b"x"):
             ct = cbc_encrypt(key, pt, iv)
             dt = cbc_decrypt(key, ct)
             self.assertSequenceEqual(pt, dt)
 
     def test_iv_existence_check(self):
-        key = 32 * b"x"
+        key = KEYSIZE * b"x"
         with self.assertRaises(ValueError):
-            cbc_decrypt(key, 8 * b"x")
-        iv = urandom(8)
-        cbc_decrypt(key, cbc_encrypt(key, 8 * b"x", iv))
+            cbc_decrypt(key, BLOCKSIZE * b"x")
+        iv = urandom(BLOCKSIZE)
+        cbc_decrypt(key, cbc_encrypt(key, BLOCKSIZE * b"x", iv))
 
     def test_meshing(self):
         pt = urandom(MESH_MAX_DATA * 3)
-        key = urandom(32)
+        key = urandom(KEYSIZE)
         ct = cbc_encrypt(key, pt)
         dt = cbc_decrypt(key, ct)
         self.assertSequenceEqual(pt, dt)
@@ -348,8 +350,8 @@ class CBCTest(TestCase):
 
 class CFBMeshingTest(TestCase):
     def setUp(self):
-        self.key = urandom(32)
-        self.iv = urandom(8)
+        self.key = urandom(KEYSIZE)
+        self.iv = urandom(BLOCKSIZE)
 
     def test_single(self):
         pt = b"\x00"

diff --git a/pygost/test_gost3413.py b/pygost/test_gost3413.py
index 6bf2f885ec74b68d8ccc6bf9c9f1408bd0b83f89..f670d7e85ebac121696c39651b6ca71d4a8bb567 100644 (file)
--- a/pygost/test_gost3413.py
+++ b/pygost/test_gost3413.py
@@ -31,7 +31,7 @@ from pygost.gost3413 import ctr
 from pygost.gost3413 import ctr_acpkm
 from pygost.gost3413 import ecb_decrypt
 from pygost.gost3413 import ecb_encrypt
-from pygost.gost3413 import KEY_SIZE
+from pygost.gost3413 import KEYSIZE
 from pygost.gost3413 import mac
 from pygost.gost3413 import mac_acpkm_master
 from pygost.gost3413 import ofb
@@ -45,7 +45,7 @@ from pygost.utils import strxor
 class Pad2Test(TestCase):
     def test_symmetric(self):
         for _ in range(100):
-            for blocksize in (8, 16):
+            for blocksize in (GOST3412Magma.blocksize, GOST3412Kuznechik.blocksize):
                 data = urandom(randint(0, blocksize * 3))
                 self.assertSequenceEqual(
                     unpad2(pad2(data, blocksize), blocksize),
@@ -70,20 +70,32 @@ class GOST3412KuznechikModesTest(TestCase):
         ciphtext += "f0ca33549d247ceef3f5a5313bd4b157"
         ciphtext += "d0b09ccde830b9eb3a02c4c5aa8ada98"
         self.assertSequenceEqual(
-            hexenc(ecb_encrypt(self.ciph.encrypt, 16, hexdec(self.plaintext))),
+            hexenc(ecb_encrypt(
+                self.ciph.encrypt,
+                GOST3412Kuznechik.blocksize,
+                hexdec(self.plaintext),
+            )),
             ciphtext,
         )
         self.assertSequenceEqual(
-            hexenc(ecb_decrypt(self.ciph.decrypt, 16, hexdec(ciphtext))),
+            hexenc(ecb_decrypt(
+                self.ciph.decrypt,
+                GOST3412Kuznechik.blocksize,
+                hexdec(ciphtext),
+            )),
             self.plaintext,
         )
 
     def test_ecb_symmetric(self):
         for _ in range(100):
-            pt = pad2(urandom(randint(0, 16 * 2)), 16)
-            ciph = GOST3412Kuznechik(urandom(32))
-            ct = ecb_encrypt(ciph.encrypt, 16, pt)
-            self.assertSequenceEqual(ecb_decrypt(ciph.decrypt, 16, ct), pt)
+            pt = pad2(urandom(randint(0, 16 * 2)), GOST3412Kuznechik.blocksize)
+            ciph = GOST3412Kuznechik(urandom(KEYSIZE))
+            ct = ecb_encrypt(ciph.encrypt, GOST3412Kuznechik.blocksize, pt)
+            self.assertSequenceEqual(ecb_decrypt(
+                ciph.decrypt,
+                GOST3412Kuznechik.blocksize,
+                ct,
+            ), pt)
 
     def test_ctr_vectors(self):
         ciphtext = ""
@@ -91,23 +103,38 @@ class GOST3412KuznechikModesTest(TestCase):
         ciphtext += "85eee733f6a13e5df33ce4b33c45dee4"
         ciphtext += "a5eae88be6356ed3d5e877f13564a3a5"
         ciphtext += "cb91fab1f20cbab6d1c6d15820bdba73"
-        iv = self.iv[:8]
-        self.assertSequenceEqual(
-            hexenc(ctr(self.ciph.encrypt, 16, hexdec(self.plaintext), iv)),
+        iv = self.iv[:GOST3412Kuznechik.blocksize // 2]
+        self.assertSequenceEqual(
+            hexenc(ctr(
+                self.ciph.encrypt,
+                GOST3412Kuznechik.blocksize,
+                hexdec(self.plaintext),
+                iv,
+            )),
             ciphtext,
         )
         self.assertSequenceEqual(
-            hexenc(ctr(self.ciph.encrypt, 16, hexdec(ciphtext), iv)),
+            hexenc(ctr(
+                self.ciph.encrypt,
+                GOST3412Kuznechik.blocksize,
+                hexdec(ciphtext),
+                iv,
+            )),
             self.plaintext,
         )
 
     def test_ctr_symmetric(self):
         for _ in range(100):
             pt = urandom(randint(0, 16 * 2))
-            iv = urandom(8)
-            ciph = GOST3412Kuznechik(urandom(32))
-            ct = ctr(ciph.encrypt, 16, pt, iv)
-            self.assertSequenceEqual(ctr(ciph.encrypt, 16, ct, iv), pt)
+            iv = urandom(GOST3412Kuznechik.blocksize // 2)
+            ciph = GOST3412Kuznechik(urandom(KEYSIZE))
+            ct = ctr(ciph.encrypt, GOST3412Kuznechik.blocksize, pt, iv)
+            self.assertSequenceEqual(ctr(
+                ciph.encrypt,
+                GOST3412Kuznechik.blocksize,
+                ct,
+                iv,
+            ), pt)
 
     def test_ofb_vectors(self):
         ciphtext = ""
@@ -116,32 +143,50 @@ class GOST3412KuznechikModesTest(TestCase):
         ciphtext += "66a257ac3ca0b8b1c80fe7fc10288a13"
         ciphtext += "203ebbc066138660a0292243f6903150"
         self.assertSequenceEqual(
-            hexenc(ofb(self.ciph.encrypt, 16, hexdec(self.plaintext), self.iv)),
+            hexenc(ofb(
+                self.ciph.encrypt,
+                GOST3412Kuznechik.blocksize,
+                hexdec(self.plaintext),
+                self.iv,
+            )),
             ciphtext,
         )
         self.assertSequenceEqual(
-            hexenc(ofb(self.ciph.encrypt, 16, hexdec(ciphtext), self.iv)),
+            hexenc(ofb(
+                self.ciph.encrypt,
+                GOST3412Kuznechik.blocksize,
+                hexdec(ciphtext),
+                self.iv,
+            )),
             self.plaintext,
         )
 
     def test_ofb_symmetric(self):
         for _ in range(100):
             pt = urandom(randint(0, 16 * 2))
-            iv = urandom(16 * 2)
-            ciph = GOST3412Kuznechik(urandom(32))
-            ct = ofb(ciph.encrypt, 16, pt, iv)
-            self.assertSequenceEqual(ofb(ciph.encrypt, 16, ct, iv), pt)
+            iv = urandom(GOST3412Kuznechik.blocksize * 2)
+            ciph = GOST3412Kuznechik(urandom(KEYSIZE))
+            ct = ofb(ciph.encrypt, GOST3412Kuznechik.blocksize, pt, iv)
+            self.assertSequenceEqual(ofb(
+                ciph.encrypt,
+                GOST3412Kuznechik.blocksize,
+                ct,
+                iv,
+            ), pt)
 
     def test_ofb_manual(self):
-        iv = [urandom(16) for _ in range(randint(2, 10))]
-        pt = [urandom(16) for _ in range(len(iv), len(iv) + randint(1, 10))]
-        ciph = GOST3412Kuznechik(urandom(32))
+        iv = [urandom(GOST3412Kuznechik.blocksize) for _ in range(randint(2, 10))]
+        pt = [
+            urandom(GOST3412Kuznechik.blocksize)
+            for _ in range(len(iv), len(iv) + randint(1, 10))
+        ]
+        ciph = GOST3412Kuznechik(urandom(KEYSIZE))
         r = [ciph.encrypt(i) for i in iv]
         for i in range(len(pt) - len(iv)):
             r.append(ciph.encrypt(r[i]))
         ct = [strxor(g, r) for g, r in zip(pt, r)]
         self.assertSequenceEqual(
-            ofb(ciph.encrypt, 16, b"".join(pt), b"".join(iv)),
+            ofb(ciph.encrypt, GOST3412Kuznechik.blocksize, b"".join(pt), b"".join(iv)),
             b"".join(ct),
         )
 
@@ -152,21 +197,36 @@ class GOST3412KuznechikModesTest(TestCase):
         ciphtext += "fe7babf1e91999e85640e8b0f49d90d0"
         ciphtext += "167688065a895c631a2d9a1560b63970"
         self.assertSequenceEqual(
-            hexenc(cbc_encrypt(self.ciph.encrypt, 16, hexdec(self.plaintext), self.iv)),
+            hexenc(cbc_encrypt(
+                self.ciph.encrypt,
+                GOST3412Kuznechik.blocksize,
+                hexdec(self.plaintext),
+                self.iv,
+            )),
             ciphtext,
         )
         self.assertSequenceEqual(
-            hexenc(cbc_decrypt(self.ciph.decrypt, 16, hexdec(ciphtext), self.iv)),
+            hexenc(cbc_decrypt(
+                self.ciph.decrypt,
+                GOST3412Kuznechik.blocksize,
+                hexdec(ciphtext),
+                self.iv,
+            )),
             self.plaintext,
         )
 
     def test_cbc_symmetric(self):
         for _ in range(100):
-            pt = pad2(urandom(randint(0, 16 * 2)), 16)
-            iv = urandom(16 * 2)
-            ciph = GOST3412Kuznechik(urandom(32))
-            ct = cbc_encrypt(ciph.encrypt, 16, pt, iv)
-            self.assertSequenceEqual(cbc_decrypt(ciph.decrypt, 16, ct, iv), pt)
+            pt = pad2(urandom(randint(0, 16 * 2)), GOST3412Kuznechik.blocksize)
+            iv = urandom(GOST3412Kuznechik.blocksize * 2)
+            ciph = GOST3412Kuznechik(urandom(KEYSIZE))
+            ct = cbc_encrypt(ciph.encrypt, GOST3412Kuznechik.blocksize, pt, iv)
+            self.assertSequenceEqual(cbc_decrypt(
+                ciph.decrypt,
+                GOST3412Kuznechik.blocksize,
+                ct,
+                iv,
+            ), pt)
 
     def test_cfb_vectors(self):
         ciphtext = ""
@@ -175,36 +235,55 @@ class GOST3412KuznechikModesTest(TestCase):
         ciphtext += "79f2a8eb5cc68d38842d264e97a238b5"
         ciphtext += "4ffebecd4e922de6c75bd9dd44fbf4d1"
         self.assertSequenceEqual(
-            hexenc(cfb_encrypt(self.ciph.encrypt, 16, hexdec(self.plaintext), self.iv)),
+            hexenc(cfb_encrypt(
+                self.ciph.encrypt,
+                GOST3412Kuznechik.blocksize,
+                hexdec(self.plaintext),
+                self.iv,
+            )),
             ciphtext,
         )
         self.assertSequenceEqual(
-            hexenc(cfb_decrypt(self.ciph.encrypt, 16, hexdec(ciphtext), self.iv)),
+            hexenc(cfb_decrypt(
+                self.ciph.encrypt,
+                GOST3412Kuznechik.blocksize,
+                hexdec(ciphtext),
+                self.iv,
+            )),
             self.plaintext,
         )
 
     def test_cfb_symmetric(self):
         for _ in range(100):
             pt = urandom(randint(0, 16 * 2))
-            iv = urandom(16 * 2)
-            ciph = GOST3412Kuznechik(urandom(32))
-            ct = cfb_encrypt(ciph.encrypt, 16, pt, iv)
-            self.assertSequenceEqual(cfb_decrypt(ciph.encrypt, 16, ct, iv), pt)
+            iv = urandom(GOST3412Kuznechik.blocksize * 2)
+            ciph = GOST3412Kuznechik(urandom(KEYSIZE))
+            ct = cfb_encrypt(ciph.encrypt, GOST3412Kuznechik.blocksize, pt, iv)
+            self.assertSequenceEqual(cfb_decrypt(
+                ciph.encrypt,
+                GOST3412Kuznechik.blocksize,
+                ct,
+                iv,
+            ), pt)
 
     def test_mac_vectors(self):
-        k1, k2 = _mac_ks(self.ciph.encrypt, 16)
+        k1, k2 = _mac_ks(self.ciph.encrypt, GOST3412Kuznechik.blocksize)
         self.assertSequenceEqual(hexenc(k1), "297d82bc4d39e3ca0de0573298151dc7")
         self.assertSequenceEqual(hexenc(k2), "52fb05789a73c7941bc0ae65302a3b8e")
         self.assertSequenceEqual(
-            hexenc(mac(self.ciph.encrypt, 16, hexdec(self.plaintext))[:8]),
+            hexenc(mac(
+                self.ciph.encrypt,
+                GOST3412Kuznechik.blocksize,
+                hexdec(self.plaintext),
+            )[:8]),
             "336f4d296059fbe3",
         )
 
     def test_mac_applies(self):
         for _ in range(100):
             data = urandom(randint(0, 16 * 2))
-            ciph = GOST3412Kuznechik(urandom(32))
-            mac(ciph.encrypt, 16, data)
+            ciph = GOST3412Kuznechik(urandom(KEYSIZE))
+            mac(ciph.encrypt, GOST3412Kuznechik.blocksize, data)
 
 
 class GOST3412MagmaModesTest(TestCase):
@@ -224,20 +303,32 @@ class GOST3412MagmaModesTest(TestCase):
         ciphtext += "11d8d9e9eacfbc1e"
         ciphtext += "7c68260996c67efb"
         self.assertSequenceEqual(
-            hexenc(ecb_encrypt(self.ciph.encrypt, 8, hexdec(self.plaintext))),
+            hexenc(ecb_encrypt(
+                self.ciph.encrypt,
+                GOST3412Magma.blocksize,
+                hexdec(self.plaintext),
+            )),
             ciphtext,
         )
         self.assertSequenceEqual(
-            hexenc(ecb_decrypt(self.ciph.decrypt, 8, hexdec(ciphtext))),
+            hexenc(ecb_decrypt(
+                self.ciph.decrypt,
+                GOST3412Magma.blocksize,
+                hexdec(ciphtext),
+            )),
             self.plaintext,
         )
 
     def test_ecb_symmetric(self):
         for _ in range(100):
             pt = pad2(urandom(randint(0, 16 * 2)), 16)
-            ciph = GOST3412Magma(urandom(32))
-            ct = ecb_encrypt(ciph.encrypt, 8, pt)
-            self.assertSequenceEqual(ecb_decrypt(ciph.decrypt, 8, ct), pt)
+            ciph = GOST3412Magma(urandom(KEYSIZE))
+            ct = ecb_encrypt(ciph.encrypt, GOST3412Magma.blocksize, pt)
+            self.assertSequenceEqual(ecb_decrypt(
+                ciph.decrypt,
+                GOST3412Magma.blocksize,
+                ct,
+            ), pt)
 
     def test_ctr_vectors(self):
         ciphtext = ""
@@ -247,21 +338,36 @@ class GOST3412MagmaModesTest(TestCase):
         ciphtext += "568eb680ab52a12d"
         iv = self.iv[:4]
         self.assertSequenceEqual(
-            hexenc(ctr(self.ciph.encrypt, 8, hexdec(self.plaintext), iv)),
+            hexenc(ctr(
+                self.ciph.encrypt,
+                GOST3412Magma.blocksize,
+                hexdec(self.plaintext),
+                iv,
+            )),
             ciphtext,
         )
         self.assertSequenceEqual(
-            hexenc(ctr(self.ciph.encrypt, 8, hexdec(ciphtext), iv)),
+            hexenc(ctr(
+                self.ciph.encrypt,
+                GOST3412Magma.blocksize,
+                hexdec(ciphtext),
+                iv,
+            )),
             self.plaintext,
         )
 
     def test_ctr_symmetric(self):
         for _ in range(100):
             pt = urandom(randint(0, 16 * 2))
-            iv = urandom(4)
-            ciph = GOST3412Magma(urandom(32))
-            ct = ctr(ciph.encrypt, 8, pt, iv)
-            self.assertSequenceEqual(ctr(ciph.encrypt, 8, ct, iv), pt)
+            iv = urandom(GOST3412Magma.blocksize // 2)
+            ciph = GOST3412Magma(urandom(KEYSIZE))
+            ct = ctr(ciph.encrypt, GOST3412Magma.blocksize, pt, iv)
+            self.assertSequenceEqual(ctr(
+                ciph.encrypt,
+                GOST3412Magma.blocksize,
+                ct,
+                iv,
+            ), pt)
 
     def test_ofb_vectors(self):
         iv = self.iv[:16]
@@ -271,21 +377,36 @@ class GOST3412MagmaModesTest(TestCase):
         ciphtext += "a0f83062430e327e"
         ciphtext += "c824efb8bd4fdb05"
         self.assertSequenceEqual(
-            hexenc(ofb(self.ciph.encrypt, 8, hexdec(self.plaintext), iv)),
+            hexenc(ofb(
+                self.ciph.encrypt,
+                GOST3412Magma.blocksize,
+                hexdec(self.plaintext),
+                iv,
+            )),
             ciphtext,
         )
         self.assertSequenceEqual(
-            hexenc(ofb(self.ciph.encrypt, 8, hexdec(ciphtext), iv)),
+            hexenc(ofb(
+                self.ciph.encrypt,
+                GOST3412Magma.blocksize,
+                hexdec(ciphtext),
+                iv,
+            )),
             self.plaintext,
         )
 
     def test_ofb_symmetric(self):
         for _ in range(100):
             pt = urandom(randint(0, 16 * 2))
-            iv = urandom(8 * 2)
-            ciph = GOST3412Magma(urandom(32))
-            ct = ofb(ciph.encrypt, 8, pt, iv)
-            self.assertSequenceEqual(ofb(ciph.encrypt, 8, ct, iv), pt)
+            iv = urandom(GOST3412Magma.blocksize * 2)
+            ciph = GOST3412Magma(urandom(KEYSIZE))
+            ct = ofb(ciph.encrypt, GOST3412Magma.blocksize, pt, iv)
+            self.assertSequenceEqual(ofb(
+                ciph.encrypt,
+                GOST3412Magma.blocksize,
+                ct,
+                iv,
+            ), pt)
 
     def test_cbc_vectors(self):
         ciphtext = ""
@@ -294,21 +415,36 @@ class GOST3412MagmaModesTest(TestCase):
         ciphtext += "5058b4a1c4bc0019"
         ciphtext += "20b78b1a7cd7e667"
         self.assertSequenceEqual(
-            hexenc(cbc_encrypt(self.ciph.encrypt, 8, hexdec(self.plaintext), self.iv)),
+            hexenc(cbc_encrypt(
+                self.ciph.encrypt,
+                GOST3412Magma.blocksize,
+                hexdec(self.plaintext),
+                self.iv,
+            )),
             ciphtext,
         )
         self.assertSequenceEqual(
-            hexenc(cbc_decrypt(self.ciph.decrypt, 8, hexdec(ciphtext), self.iv)),
+            hexenc(cbc_decrypt(
+                self.ciph.decrypt,
+                GOST3412Magma.blocksize,
+                hexdec(ciphtext),
+                self.iv,
+            )),
             self.plaintext,
         )
 
     def test_cbc_symmetric(self):
         for _ in range(100):
             pt = pad2(urandom(randint(0, 16 * 2)), 16)
-            iv = urandom(8 * 2)
-            ciph = GOST3412Magma(urandom(32))
-            ct = cbc_encrypt(ciph.encrypt, 8, pt, iv)
-            self.assertSequenceEqual(cbc_decrypt(ciph.decrypt, 8, ct, iv), pt)
+            iv = urandom(GOST3412Magma.blocksize * 2)
+            ciph = GOST3412Magma(urandom(KEYSIZE))
+            ct = cbc_encrypt(ciph.encrypt, GOST3412Magma.blocksize, pt, iv)
+            self.assertSequenceEqual(cbc_decrypt(
+                ciph.decrypt,
+                GOST3412Magma.blocksize,
+                ct,
+                iv,
+            ), pt)
 
     def test_cfb_vectors(self):
         iv = self.iv[:16]
@@ -318,36 +454,55 @@ class GOST3412MagmaModesTest(TestCase):
         ciphtext += "24bdd2035315d38b"
         ciphtext += "bcc0321421075505"
         self.assertSequenceEqual(
-            hexenc(cfb_encrypt(self.ciph.encrypt, 8, hexdec(self.plaintext), iv)),
+            hexenc(cfb_encrypt(
+                self.ciph.encrypt,
+                GOST3412Magma.blocksize,
+                hexdec(self.plaintext),
+                iv,
+            )),
             ciphtext,
         )
         self.assertSequenceEqual(
-            hexenc(cfb_decrypt(self.ciph.encrypt, 8, hexdec(ciphtext), iv)),
+            hexenc(cfb_decrypt(
+                self.ciph.encrypt,
+                GOST3412Magma.blocksize,
+                hexdec(ciphtext),
+                iv,
+            )),
             self.plaintext,
         )
 
     def test_cfb_symmetric(self):
         for _ in range(100):
             pt = urandom(randint(0, 16 * 2))
-            iv = urandom(8 * 2)
-            ciph = GOST3412Magma(urandom(32))
-            ct = cfb_encrypt(ciph.encrypt, 8, pt, iv)
-            self.assertSequenceEqual(cfb_decrypt(ciph.encrypt, 8, ct, iv), pt)
+            iv = urandom(GOST3412Magma.blocksize * 2)
+            ciph = GOST3412Magma(urandom(KEYSIZE))
+            ct = cfb_encrypt(ciph.encrypt, GOST3412Magma.blocksize, pt, iv)
+            self.assertSequenceEqual(cfb_decrypt(
+                ciph.encrypt,
+                GOST3412Magma.blocksize,
+                ct,
+                iv,
+            ), pt)
 
     def test_mac_vectors(self):
-        k1, k2 = _mac_ks(self.ciph.encrypt, 8)
+        k1, k2 = _mac_ks(self.ciph.encrypt, GOST3412Magma.blocksize)
         self.assertSequenceEqual(hexenc(k1), "5f459b3342521424")
         self.assertSequenceEqual(hexenc(k2), "be8b366684a42848")
         self.assertSequenceEqual(
-            hexenc(mac(self.ciph.encrypt, 8, hexdec(self.plaintext))[:4]),
+            hexenc(mac(
+                self.ciph.encrypt,
+                GOST3412Magma.blocksize,
+                hexdec(self.plaintext),
+            )[:4]),
             "154e7210",
         )
 
     def test_mac_applies(self):
         for _ in range(100):
             data = urandom(randint(0, 16 * 2))
-            ciph = GOST3412Magma(urandom(32))
-            mac(ciph.encrypt, 8, data)
+            ciph = GOST3412Magma(urandom(KEYSIZE))
+            mac(ciph.encrypt, GOST3412Magma.blocksize, data)
 
 
 class TestVectorACPKM(TestCase):
@@ -356,11 +511,11 @@ class TestVectorACPKM(TestCase):
     key = hexdec("8899AABBCCDDEEFF0011223344556677FEDCBA98765432100123456789ABCDEF")
 
     def test_magma_ctr_acpkm(self):
-        key = acpkm(GOST3412Magma(self.key).encrypt, 8)
+        key = acpkm(GOST3412Magma(self.key).encrypt, GOST3412Magma.blocksize)
         self.assertSequenceEqual(key, hexdec("863EA017842C3D372B18A85A28E2317D74BEFC107720DE0C9E8AB974ABD00CA0"))
-        key = acpkm(GOST3412Magma(key).encrypt, 8)
+        key = acpkm(GOST3412Magma(key).encrypt, GOST3412Magma.blocksize)
         self.assertSequenceEqual(key, hexdec("49A5E2677DE555982B8AD5E826652D17EEC847BF5B3997A81CF7FE7F1187BD27"))
-        key = acpkm(GOST3412Magma(key).encrypt, 8)
+        key = acpkm(GOST3412Magma(key).encrypt, GOST3412Magma.blocksize)
         self.assertSequenceEqual(key, hexdec("3256BF3F97B5667426A9FB1C5EAABE41893CCDD5A868F9B63B0AA90720FA43C4"))
 
     def test_magma_ctr(self):
@@ -379,20 +534,34 @@ A1 AE 71 14 9E ED 13 82 AB D4 67 18 06 72 EC 6F
 84 A2 F1 5B 3F CA 72 C1
         """.replace("\n", "").replace(" ", ""))
         self.assertSequenceEqual(
-            ctr_acpkm(GOST3412Magma, encrypter, bs=8, section_size=16, data=plaintext, iv=iv),
+            ctr_acpkm(
+                GOST3412Magma,
+                encrypter,
+                bs=GOST3412Magma.blocksize,
+                section_size=GOST3412Magma.blocksize * 2,
+                data=plaintext,
+                iv=iv
+            ),
             ciphertext,
         )
         self.assertSequenceEqual(
-            ctr_acpkm(GOST3412Magma, encrypter, bs=8, section_size=16, data=ciphertext, iv=iv),
+            ctr_acpkm(
+                GOST3412Magma,
+                encrypter,
+                bs=GOST3412Magma.blocksize,
+                section_size=GOST3412Magma.blocksize * 2,
+                data=ciphertext,
+                iv=iv
+            ),
             plaintext,
         )
 
     def test_kuznechik_ctr_acpkm(self):
-        key = acpkm(GOST3412Kuznechik(self.key).encrypt, 16)
+        key = acpkm(GOST3412Kuznechik(self.key).encrypt, GOST3412Kuznechik.blocksize)
         self.assertSequenceEqual(key, hexdec("2666ED40AE687811745CA0B448F57A7B390ADB5780307E8E9659AC403AE60C60"))
-        key = acpkm(GOST3412Kuznechik(key).encrypt, 16)
+        key = acpkm(GOST3412Kuznechik(key).encrypt, GOST3412Kuznechik.blocksize)
         self.assertSequenceEqual(key, hexdec("BB3DD5402E999B7A3DEBB0DB45448EC530F07365DFEE3ABA8415F77AC8F34CE8"))
-        key = acpkm(GOST3412Kuznechik(key).encrypt, 16)
+        key = acpkm(GOST3412Kuznechik(key).encrypt, GOST3412Kuznechik.blocksize)
         self.assertSequenceEqual(key, hexdec("23362FD553CAD2178299A5B5A2D4722E3BB83C730A8BF57CE2DD004017F8C565"))
 
     def test_kuznechik_ctr(self):
@@ -420,8 +589,8 @@ DF FD 07 EC 81 36 36 46 0C 4F 3B 74 34 23 16 3E
             ctr_acpkm(
                 GOST3412Kuznechik,
                 encrypter,
-                bs=16,
-                section_size=32,
+                bs=GOST3412Kuznechik.blocksize,
+                section_size=GOST3412Kuznechik.blocksize * 2,
                 data=plaintext,
                 iv=iv,
             ),
@@ -431,8 +600,8 @@ DF FD 07 EC 81 36 36 46 0C 4F 3B 74 34 23 16 3E
             ctr_acpkm(
                 GOST3412Kuznechik,
                 encrypter,
-                bs=16,
-                section_size=32,
+                bs=GOST3412Kuznechik.blocksize,
+                section_size=GOST3412Kuznechik.blocksize * 2,
                 data=ciphertext,
                 iv=iv,
             ),
@@ -447,8 +616,8 @@ DF FD 07 EC 81 36 36 46 0C 4F 3B 74 34 23 16 3E
                 GOST3412Magma,
                 encrypter,
                 key_section_size=key_section_size,
-                bs=8,
-                keymat_len=KEY_SIZE + 8,
+                bs=GOST3412Magma.blocksize,
+                keymat_len=KEYSIZE + GOST3412Magma.blocksize,
             ),
             hexdec("0DF2F5273DA328932AC49D81D36B2558A50DBF9BBCAC74A614B2CCB2F1CBCD8A70638E3DE8B3571E"),
         )
@@ -458,8 +627,8 @@ DF FD 07 EC 81 36 36 46 0C 4F 3B 74 34 23 16 3E
                 GOST3412Magma,
                 encrypter,
                 key_section_size,
-                section_size=16,
-                bs=8,
+                section_size=GOST3412Magma.blocksize * 2,
+                bs=GOST3412Magma.blocksize,
                 data=text,
             ),
             hexdec("A0540E3730ACBCF3"),
@@ -473,8 +642,8 @@ DF FD 07 EC 81 36 36 46 0C 4F 3B 74 34 23 16 3E
                 GOST3412Magma,
                 encrypter,
                 key_section_size=key_section_size,
-                bs=8,
-                keymat_len=3 * (KEY_SIZE + 8),
+                bs=GOST3412Magma.blocksize,
+                keymat_len=3 * (KEYSIZE + GOST3412Magma.blocksize),
             ),
             hexdec("""
 0D F2 F5 27 3D A3 28 93 2A C4 9D 81 D3 6B 25 58
@@ -497,8 +666,8 @@ E2 40 66 40 54 7B 9F 1F 5F 2B 43 61 2A AE AF DA
                 GOST3412Magma,
                 encrypter,
                 key_section_size,
-                section_size=16,
-                bs=8,
+                section_size=GOST3412Magma.blocksize * 2,
+                bs=GOST3412Magma.blocksize,
                 data=text,
             ),
             hexdec("34008DAD5496BB8E"),
@@ -512,8 +681,8 @@ E2 40 66 40 54 7B 9F 1F 5F 2B 43 61 2A AE AF DA
                 GOST3412Kuznechik,
                 encrypter,
                 key_section_size=key_section_size,
-                bs=16,
-                keymat_len=KEY_SIZE + 16,
+                bs=GOST3412Kuznechik.blocksize,
+                keymat_len=KEYSIZE + GOST3412Kuznechik.blocksize,
             ),
             hexdec("""
 0C AB F1 F2 EF BC 4A C1 60 48 DF 1A 24 C6 05 B2
@@ -530,8 +699,8 @@ C0 D1 67 3D 75 86 A8 EC 0D D4 2C 45 A4 F9 5B AE
                 GOST3412Kuznechik,
                 encrypter,
                 key_section_size,
-                section_size=32,
-                bs=16,
+                section_size=GOST3412Kuznechik.blocksize * 2,
+                bs=GOST3412Kuznechik.blocksize,
                 data=text,
             ),
             hexdec("B5367F47B62B995EEB2A648C5843145E"),
@@ -545,8 +714,8 @@ C0 D1 67 3D 75 86 A8 EC 0D D4 2C 45 A4 F9 5B AE
                 GOST3412Kuznechik,
                 encrypter,
                 key_section_size=key_section_size,
-                bs=16,
-                keymat_len=3 * (KEY_SIZE + 16),
+                bs=GOST3412Kuznechik.blocksize,
+                keymat_len=3 * (KEYSIZE + GOST3412Kuznechik.blocksize),
             ),
             hexdec("""
 0C AB F1 F2 EF BC 4A C1 60 48 DF 1A 24 C6 05 B2
@@ -572,8 +741,8 @@ A8 1C 79 A0 4F 29 66 0E A3 FD A8 74 C6 30 79 9E
                 GOST3412Kuznechik,
                 encrypter,
                 key_section_size,
-                section_size=32,
-                bs=16,
+                section_size=GOST3412Kuznechik.blocksize * 2,
+                bs=GOST3412Kuznechik.blocksize,
                 data=text,
             ),
             hexdec("FBB8DCEE45BEA67C35F58C5700898E5D"),

diff --git a/pygost/test_mgm.py b/pygost/test_mgm.py
index 56cfda0a30cf9421b2af0ddc5b7ce32678e13322..903415826c7251cc932b4c1bea42c4eb6fbd0919 100644 (file)
--- a/pygost/test_mgm.py
+++ b/pygost/test_mgm.py
@@ -20,6 +20,7 @@ from unittest import TestCase
 
 from pygost.gost3412 import GOST3412Kuznechik
 from pygost.gost3412 import GOST3412Magma
+from pygost.gost3412 import KEYSIZE
 from pygost.mgm import MGM
 from pygost.mgm import nonce_prepare
 from pygost.utils import hexdec
@@ -30,7 +31,7 @@ class TestVector(TestCase):
         key = hexdec("8899AABBCCDDEEFF0011223344556677FEDCBA98765432100123456789ABCDEF")
         ad = hexdec("0202020202020202010101010101010104040404040404040303030303030303EA0505050505050505")
         plaintext = hexdec("1122334455667700FFEEDDCCBBAA998800112233445566778899AABBCCEEFF0A112233445566778899AABBCCEEFF0A002233445566778899AABBCCEEFF0A0011AABBCC")
-        mgm = MGM(GOST3412Kuznechik(key).encrypt, 16)
+        mgm = MGM(GOST3412Kuznechik(key).encrypt, GOST3412Kuznechik.blocksize)
         ciphertext = mgm.seal(plaintext[:16], plaintext, ad)
         self.assertSequenceEqual(ciphertext[:len(plaintext)], hexdec("A9757B8147956E9055B8A33DE89F42FC8075D2212BF9FD5BD3F7069AADC16B39497AB15915A6BA85936B5D0EA9F6851CC60C14D4D3F883D0AB94420695C76DEB2C7552"))
         self.assertSequenceEqual(ciphertext[len(plaintext):], hexdec("CF5D656F40C34F5C46E8BB0E29FCDB4C"))
@@ -49,9 +50,15 @@ class TestSymmetric(TestCase):
             self.assertSequenceEqual(mgm.open(nonce, ct, ad), pt)
 
     def test_magma(self):
-        mgm = MGM(GOST3412Magma(urandom(32)).encrypt, 8)
-        self._itself(mgm, 8)
+        mgm = MGM(
+            GOST3412Magma(urandom(KEYSIZE)).encrypt,
+            GOST3412Magma.blocksize,
+        )
+        self._itself(mgm, GOST3412Magma.blocksize)
 
     def test_kuznechik(self):
-        mgm = MGM(GOST3412Kuznechik(urandom(32)).encrypt, 16)
-        self._itself(mgm, 16)
+        mgm = MGM(
+            GOST3412Kuznechik(urandom(KEYSIZE)).encrypt,
+            GOST3412Kuznechik.blocksize,
+        )
+        self._itself(mgm, GOST3412Kuznechik.blocksize)