# coding: utf-8
# PyGOST -- Pure Python GOST cryptographic functions library
-# Copyright (C) 2015-2019 Sergey Matveev <stargrave@stargrave.org>
+# Copyright (C) 2015-2020 Sergey Matveev <stargrave@stargrave.org>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
+# the Free Software Foundation, version 3 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
-""" GOST 28147-89 block cipher
+"""GOST 28147-89 block cipher
This is implementation of :rfc:`5830` ECB, CNT, CFB and :rfc:`4357`
CBC modes of operation. N1, N2, K names are taken according to
from pygost.gost3413 import unpad2
from pygost.utils import hexdec
from pygost.utils import strxor
-from pygost.utils import xrange # pylint: disable=redefined-builtin
+from pygost.utils import xrange
KEYSIZE = 32
def _K(s, _in):
- """ S-box substitution
+ """S-box substitution
:param s: S-box
:param _in: 32-bit word
def block2ns(data):
- """ Convert block to N1 and N2 integers
+ """Convert block to N1 and N2 integers
"""
data = bytearray(data)
return (
def ns2block(ns):
- """ Convert N1 and N2 integers to 8-byte block
+ """Convert N1 and N2 integers to 8-byte block
"""
n1, n2 = ns
return bytes(bytearray((
- (n2 >> 0) & 255, (n2 >> 8) & 255, (n2 >> 16) & 255, (n2 >> 24) & 255,
- (n1 >> 0) & 255, (n1 >> 8) & 255, (n1 >> 16) & 255, (n1 >> 24) & 255,
+ (n2 >> 0) & 0xFF, (n2 >> 8) & 0xFF, (n2 >> 16) & 0xFF, (n2 >> 24) & 0xFF,
+ (n1 >> 0) & 0xFF, (n1 >> 8) & 0xFF, (n1 >> 16) & 0xFF, (n1 >> 24) & 0xFF,
)))
-def addmod(x, y, mod=2 ** 32):
- """ Modulo adding of two integers
- """
- r = x + y
- return r if r < mod else r - mod
-
-
def _shift11(x):
- """ 11-bit cyclic shift
+ """11-bit cyclic shift
"""
return ((x << 11) & (2 ** 32 - 1)) | ((x >> (32 - 11)) & (2 ** 32 - 1))
def xcrypt(seq, sbox, key, ns):
- """ Perform full-round single-block operation
+ """Perform full-round single-block operation
:param seq: sequence of K_i S-box applying (either encrypt or decrypt)
:param sbox: S-box parameters to use
]
n1, n2 = ns
for i in seq:
- n1, n2 = _shift11(_K(s, addmod(n1, x[i]))) ^ n2, n1
+ n1, n2 = _shift11(_K(s, (n1 + x[i]) % (2 ** 32))) ^ n2, n1
return n1, n2
def encrypt(sbox, key, ns):
- """ Encrypt single block
+ """Encrypt single block
"""
return xcrypt(SEQ_ENCRYPT, sbox, key, ns)
def decrypt(sbox, key, ns):
- """ Decrypt single block
+ """Decrypt single block
"""
return xcrypt(SEQ_DECRYPT, sbox, key, ns)
def ecb(key, data, action, sbox=DEFAULT_SBOX):
- """ ECB mode of operation
+ """ECB mode of operation
:param bytes key: encryption key
:param data: plaintext
def cbc_encrypt(key, data, iv=8 * b"\x00", pad=True, sbox=DEFAULT_SBOX, mesh=False):
- """ CBC encryption mode of operation
+ """CBC encryption mode of operation
:param bytes key: encryption key
:param bytes data: plaintext
def cbc_decrypt(key, data, pad=True, sbox=DEFAULT_SBOX, mesh=False):
- """ CBC decryption mode of operation
+ """CBC decryption mode of operation
:param bytes key: encryption key
:param bytes data: ciphertext
def cnt(key, data, iv=8 * b"\x00", sbox=DEFAULT_SBOX):
- """ Counter mode of operation
+ """Counter mode of operation
:param bytes key: encryption key
:param bytes data: plaintext
n2, n1 = encrypt(sbox, key, block2ns(iv))
gamma = []
for _ in xrange(0, len(data) + pad_size(len(data), BLOCKSIZE), BLOCKSIZE):
- n1 = addmod(n1, C2, 2 ** 32)
- n2 = addmod(n2, C1, 2 ** 32 - 1)
+ n1 = (n1 + C2) % (2 ** 32)
+ n2 = (n2 + C1) % (2 ** 32 - 1)
gamma.append(ns2block(encrypt(sbox, key, (n1, n2))))
return strxor(b"".join(gamma), data)
def cfb_encrypt(key, data, iv=8 * b"\x00", sbox=DEFAULT_SBOX, mesh=False):
- """ CFB encryption mode of operation
+ """CFB encryption mode of operation
:param bytes key: encryption key
:param bytes data: plaintext
def cfb_decrypt(key, data, iv=8 * b"\x00", sbox=DEFAULT_SBOX, mesh=False):
- """ CFB decryption mode of operation
+ """CFB decryption mode of operation
:param bytes key: encryption key
:param bytes data: plaintext