# coding: utf-8
# PyGOST -- Pure Python GOST cryptographic functions library
-# Copyright (C) 2015-2021 Sergey Matveev <stargrave@stargrave.org>
+# Copyright (C) 2015-2024 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
)]
+def _lcache():
+ cache = []
+ for byteN in xrange(8):
+ cache.append([0 for _ in xrange(256)])
+ for byteN in xrange(8):
+ for byteVal in xrange(256):
+ res64 = 0
+ val = byteVal
+ for bitN in xrange(8):
+ if val & 0x80 > 0:
+ res64 ^= A[(7 - byteN) * 8 + bitN]
+ val <<= 1
+ cache[byteN][byteVal] = res64
+ return cache
+
+
+# Trade memory for CPU for part of L() calculations
+LCache = _lcache()
+
+
def add512bit(a, b):
- """Add two 512 integers
- """
- a = bytearray(a)
- b = bytearray(b)
- cb = 0
- res = bytearray(64)
- for i in range(64):
- cb = a[i] + b[i] + (cb >> 8)
- res[i] = cb & 0xff
- return res
+ a = int.from_bytes(a, "little")
+ b = int.from_bytes(b, "little")
+ r = (a + b) % (1 << 512)
+ return r.to_bytes(512 // 8, "little")
def g(n, hsh, msg):
def L(data):
res = []
for i in range(8):
- val = unpack("<Q", data[i * 8:i * 8 + 8])[0]
res64 = 0
- for j in range(BLOCKSIZE):
- if val & 0x8000000000000000:
- res64 ^= A[j]
- val <<= 1
+ for j in range(8):
+ res64 ^= LCache[j][data[8 * i + j]]
res.append(pack("<Q", res64))
return b"".join(res)
:param digest_size: hash digest size to compute
:type digest_size: 32 or 64 bytes
"""
- self.data = data
self._digest_size = digest_size
+ self.hsh = BLOCKSIZE * (b"\x01" if digest_size == 32 else b"\x00")
+ self.chk = bytearray(BLOCKSIZE * b"\x00")
+ self.n = 0
+ self.buf = b""
+ self.update(data)
def copy(self):
- return GOST34112012(copy(self.data), self.digest_size)
+ obj = GOST34112012()
+ obj._digest_size = self._digest_size
+ obj.hsh = self.hsh
+ obj.chk = copy(self.chk)
+ obj.n = self.n
+ obj.buf = self.buf
+ return obj
@property
def digest_size(self):
return self._digest_size
+ def _update_block(self, block):
+ self.hsh = g(self.n, self.hsh, block)
+ self.chk = add512bit(self.chk, block)
+ self.n += 512
+
def update(self, data):
- """Append data that has to be hashed
+ """Update state with the new data
"""
- self.data += data
+ if len(self.buf) > 0:
+ chunk_len = BLOCKSIZE - len(self.buf)
+ self.buf += data[:chunk_len]
+ data = data[chunk_len:]
+ if len(self.buf) == BLOCKSIZE:
+ self._update_block(self.buf)
+ self.buf = b""
+ while len(data) >= BLOCKSIZE:
+ self._update_block(data[:BLOCKSIZE])
+ data = data[BLOCKSIZE:]
+ self.buf += data
def digest(self):
"""Get hash of the provided data
"""
- hsh = BLOCKSIZE * (b"\x01" if self.digest_size == 32 else b"\x00")
- chk = bytearray(BLOCKSIZE * b"\x00")
- n = 0
- data = self.data
- for i in xrange(0, len(data) // BLOCKSIZE * BLOCKSIZE, BLOCKSIZE):
- block = data[i:i + BLOCKSIZE]
- hsh = g(n, hsh, block)
- chk = add512bit(chk, block)
- n += 512
+ data = self.buf
# Padding
- padblock_size = len(data) * 8 - n
+ padblock_size = len(data) * 8
data += b"\x01"
- padlen = BLOCKSIZE - len(data) % BLOCKSIZE
+ padlen = BLOCKSIZE - len(data)
if padlen != BLOCKSIZE:
data += b"\x00" * padlen
- hsh = g(n, hsh, data[-BLOCKSIZE:])
- n += padblock_size
- chk = add512bit(chk, data[-BLOCKSIZE:])
+ hsh = g(self.n, self.hsh, data)
+ n = self.n + padblock_size
+ chk = add512bit(self.chk, data)
hsh = g(0, hsh, pack("<Q", n) + 56 * b"\x00")
hsh = g(0, hsh, chk)
return hsh[-self._digest_size:]