def helper_test_inverse_linear_transformation_over_finite_field(
         self, _in: bytes, expected_out: bytes):
     algorithm = kalyna._KalynaEncryptor(128, _default_key_128())
     state = algorithm._in_to_state(_in)
     algorithm._inv_linear_transformation_over_finite_field(state)
     out = algorithm._state_to_out(state)
     self.assertEqual(expected_out, out)
 def test_inv_non_linear_bijective_mapping(self):
     algorithm = kalyna._KalynaEncryptor(128, _default_key_128())
     _in = b'\x9A\x2B\x1E\xAC\x76\xEE\x89\x1B\x91\x4A\xCF\x17\x7C\x98\xDD\x3D'
     _expected_out = b'\x26\x61\x70\x7E\xAF\x4F\xC7\xFD\x9E\x74\x91\xF7\xFC\x9F\xBE\x13'
     state = algorithm._in_to_state(_in)
     algorithm._inv_non_linear_bijective_mapping(state)
     self.assertEqual(_expected_out, algorithm._state_to_out(state))
    def test_round_key_expand_128(self):
        algorithm = kalyna._KalynaEncryptor(128, _default_key_128())

        expected_kt = b'\x86\x2F\x1F\x65\x3B\x77\x5B\xA1\xD0\x5C\xBC\x2F\x38\xE2\xD8\x7D'
        actual_kt = algorithm._key_expand_kt(_default_key_128())

        self.assertEqual(expected_kt, algorithm._state_to_out(actual_kt))
 def test_left_circular_shift(self):
     algorithm = kalyna._KalynaEncryptor(128, _default_key_128())
     _in = b'\x9A\x2B\x1E\xAC\x7C\x98\xDD\x3D\x91\x4A\xCF\x17\x76\xEE\x89\x1B'
     _expected_out = b'\x9A\x2B\x1E\xAC\x76\xEE\x89\x1B\x91\x4A\xCF\x17\x7C\x98\xDD\x3D'
     state = algorithm._in_to_state(_in)
     algorithm._left_circular_shift(state)
     self.assertEqual(_expected_out, algorithm._state_to_out(state))
    def test_round_key_expand_256(self):
        algorithm = kalyna._KalynaEncryptor(128, _default_key_256())

        expected_kt = b'\x1F\x44\x77\x80\x2D\x36\x68\x59\x9A\x40\x15\x36\x52\x48\x2C\xBF'
        actual_kt = algorithm._key_expand_kt(_default_key_256())

        self.assertEqual(expected_kt, algorithm._state_to_out(actual_kt))
    def test_key_expansion_128_256(self):
        algorithm = kalyna._KalynaEncryptor(128, _default_key_256())

        expected_keys = [
            b'\x57\xC8\x16\xEB\x3F\x7E\x12\xDE\xED\x2C\x6B\x56\xE6\xB5\xBE\x1A',
            b'\xDE\xED\x2C\x6B\x56\xE6\xB5\xBE\x1A\x57\xC8\x16\xEB\x3F\x7E\x12',
            b'\xD8\x06\x9A\x7D\x88\x9A\xCD\x80\xCD\x31\x84\x45\x6C\xCC\xAE\x6F',
            b'\x80\xCD\x31\x84\x45\x6C\xCC\xAE\x6F\xD8\x06\x9A\x7D\x88\x9A\xCD',
            b'\xC3\x61\xCC\x97\x35\x13\x41\x1A\x82\x32\x4D\x2B\x67\x42\xF3\xFE',
            b'\x1A\x82\x32\x4D\x2B\x67\x42\xF3\xFE\xC3\x61\xCC\x97\x35\x13\x41',
            b'\x83\x10\x69\x8C\x65\xCF\x80\xA4\x09\xEF\x6F\xAA\xBE\xB8\x0F\x56',
            b'\xA4\x09\xEF\x6F\xAA\xBE\xB8\x0F\x56\x83\x10\x69\x8C\x65\xCF\x80',
            b'\xC6\xD5\xC4\xC3\x81\x46\x1A\x7B\x03\x4D\x69\x18\x42\x90\x15\x10',
            b'\x7B\x03\x4D\x69\x18\x42\x90\x15\x10\xC6\xD5\xC4\xC3\x81\x46\x1A',
            b'\x84\xD0\xF8\x21\x46\xC8\xBD\xF9\xB2\xB3\x70\x7B\x4D\x49\x38\x7E',
            b'\xF9\xB2\xB3\x70\x7B\x4D\x49\x38\x7E\x84\xD0\xF8\x21\x46\xC8\xBD',
            b'\x43\xFA\xDB\x28\xA0\xD1\xD4\x2B\xBF\xF9\x2F\xF9\x79\x45\x46\xB3',
            b'\x2B\xBF\xF9\x2F\xF9\x79\x45\x46\xB3\x43\xFA\xDB\x28\xA0\xD1\xD4',
            b'\xC3\x1E\xE8\xA8\x7E\x2C\xED\x24\x5A\x21\xA4\x35\xFD\xB2\x5B\x92'
        ]
        self.assertEqual(len(expected_keys), len(algorithm._round_keys))

        for key_index in range(len(expected_keys)):
            print(f'key_index: {key_index}')
            expected_key = kalyna._KalynaEncryptor._in_to_state(
                expected_keys[key_index])
            actual_key = algorithm._round_keys[key_index]
            if len(expected_key[0]) > 0:
                self.assertEqual(expected_key, actual_key)
 def helper_test_add_round_key_modulo_2(self, state_bytes: bytes,
                                        key_bytes: bytes,
                                        expected_out: bytes):
     algorithm = kalyna._KalynaEncryptor(128, _default_key_128())
     state = algorithm._in_to_state(state_bytes)
     key = algorithm._in_to_state(key_bytes)
     algorithm._add_round_key_modulo_2(state, key)
     self.assertEqual(expected_out, algorithm._state_to_out(state))
 def test_in_to_state(self):
     algorithm = kalyna._KalynaEncryptor(128, _default_key_128())
     _in = b'\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F'
     expected_state = [[0x10, 0x18], [0x11, 0x19], [0x12,
                                                    0x1A], [0x13, 0x1B],
                       [0x14, 0x1C], [0x15, 0x1D], [0x16, 0x1E],
                       [0x17, 0x1F]]
     self.assertEqual(expected_state, algorithm._in_to_state(_in))
    def test_rotate_left(self):
        algorithm = kalyna._KalynaEncryptor(128, _default_key_128())

        _in = b'\x16\x50\x5e\x6b\x9b\x3a\xb1\xe6\x86\x5b\x77\xdc\xe0\x82\xa0\xf4'
        expected_out = b'\xe6\x86\x5b\x77\xdc\xe0\x82\xa0\xf4\x16\x50\x5e\x6b\x9b\x3a\xb1'
        state = algorithm._in_to_state(_in)
        out_state = algorithm._in_to_state(expected_out)
        algorithm._rotate_left(2, state)
        self.assertEqual(out_state, state)
    def helper_test_subtract_round_key_modulo_2_64(self, state_bytes: bytes,
                                                   round_key_bytes: bytes,
                                                   expected_out_bytes: bytes):
        algorithm = kalyna._KalynaEncryptor(128, _default_key_128())

        state = algorithm._in_to_state(state_bytes)
        round_key = algorithm._in_to_state(round_key_bytes)

        algorithm._subtract_round_key_modulo_2_64(state, round_key)

        self.assertEqual(expected_out_bytes, algorithm._state_to_out(state))
    def test_key_expansion_128_128(self):
        algorithm = kalyna._KalynaEncryptor(128, _default_key_128())

        expected_keys = [
            b'\x16\x50\x5e\x6b\x9b\x3a\xb1\xe6\x86\x5b\x77\xdc\xe0\x82\xa0\xf4',
            b'\xE6\x86\x5B\x77\xDC\xE0\x82\xA0\xF4\x16\x50\x5E\x6B\x9B\x3A\xB1',
            b'\x7E\x70\x87\x6E\xAE\x49\x84\x76\x8A\xAA\xA0\x0A\x7C\x93\xEC\x42',
            b'\x76\x8A\xAA\xA0\x0A\x7C\x93\xEC\x42\x7E\x70\x87\x6E\xAE\x49\x84',
            b'\x45\xCE\xD4\xC5\x1E\x91\x40\xF5\x3E\x72\x76\x82\x0F\x0B\xD9\xFE',
            b'\xF5\x3E\x72\x76\x82\x0F\x0B\xD9\xFE\x45\xCE\xD4\xC5\x1E\x91\x40',
            b'\x8C\x77\xEE\x22\x79\x00\xC4\x62\x51\x5F\x66\x32\x05\x60\xC4\xB1',
            b'\x62\x51\x5F\x66\x32\x05\x60\xC4\xB1\x8C\x77\xEE\x22\x79\x00\xC4',
            b'\x0A\x98\x72\xE2\x5C\xD2\xB0\xB8\xAA\x87\x9A\x20\x86\xA6\x6D\xD8',
            b'\xB8\xAA\x87\x9A\x20\x86\xA6\x6D\xD8\x0A\x98\x72\xE2\x5C\xD2\xB0',
            b'\x57\x26\xB1\xA8\x94\xDB\xC4\x18\xF6\x0B\xF3\xD5\xE8\xD7\x48\x61'
        ]
        self.assertEqual(len(expected_keys), len(algorithm._round_keys))

        for key_index in range(len(expected_keys)):
            expected_key = kalyna._KalynaEncryptor._in_to_state(
                expected_keys[key_index])
            actual_key = algorithm._round_keys[key_index]
            if len(expected_key[0]) > 0:
                self.assertEqual(expected_key, actual_key)
 def test_cipher_inv_cipher(self):
     algorithm = kalyna._KalynaEncryptor(128, _default_key_128())
     _in = b'S***n krasavchik'
     self.assertEqual(_in, algorithm.inv_cipher(algorithm.cipher(_in)))
 def helper_test_kalyna_inv_cipher(self, key: bytes, _in: bytes,
                                   expected_out: bytes):
     algorithm = kalyna._KalynaEncryptor(128, key)
     self.assertEqual(expected_out, algorithm.inv_cipher(_in))
 def helper_test_kalyna_cipher(self, _in, expected_out):
     algorithm = kalyna._KalynaEncryptor(128, _default_key_128())
     self.assertEqual(expected_out, algorithm.cipher(_in))