kopia lustrzana https://github.com/micropython/micropython-lib
hashlib: Refactor, split, and optimise.
This splits out each algorithm into its own extension package, so that only the necessary algorithms can be installed. This allows for a significant reduction in RAM and flash. i.e. previously installing hashlib meant that all algorithms were imported. Additionally ensures that any built-in hash algorithms (from uhashlib) are still exposed (e.g. `md5`), and retains the existing behavior to use the built-in preferentially. Also includes a refactoring of the algorithms to reduce code size and reduce the number of allocations they do as well as using bytearrays in place of list-of-int where possible. Add more comprehensive tests (using unittest). This work was funded through GitHub Sponsors. Signed-off-by: Jim Mussared <jim.mussared@gmail.com>pull/675/head
Jim Mussared
Damien George
rodzic
2fba6b8644
commit
da5ddfc6e2
|
|
@ -0,0 +1,29 @@
|
|||
# Use built-in algorithms preferentially (on many ports this is just sha256).
|
||||
try:
|
||||
from uhashlib import *
|
||||
except ImportError:
|
||||
pass
|
||||
|
||||
|
||||
# Add missing algorithms based on installed extensions.
|
||||
def _init():
|
||||
for algo in ("sha224", "sha256", "sha384", "sha512"):
|
||||
if algo not in globals():
|
||||
try:
|
||||
# from ._{algo} import {algo}
|
||||
c = __import__("_" + algo, None, None, (), 1)
|
||||
globals()[algo] = getattr(c, algo)
|
||||
except ImportError:
|
||||
pass
|
||||
|
||||
|
||||
_init()
|
||||
del _init
|
||||
|
||||
|
||||
def new(algo, data=b""):
|
||||
try:
|
||||
c = globals()[algo]
|
||||
return c(data)
|
||||
except KeyError:
|
||||
raise ValueError(algo)
|
||||
|
|
@ -0,0 +1,42 @@
|
|||
# MIT license; Copyright (c) 2023 Jim Mussared
|
||||
# Originally ported from CPython by Paul Sokolovsky
|
||||
|
||||
|
||||
# Base class for SHA implementations, which must provide:
|
||||
# .digestsize & .digest_size
|
||||
# .block_size
|
||||
# ._iv
|
||||
# ._update
|
||||
# ._final
|
||||
class sha:
|
||||
def __init__(self, s=None):
|
||||
self._digest = self._iv[:]
|
||||
self._count_lo = 0
|
||||
self._count_hi = 0
|
||||
self._data = bytearray(self.block_size)
|
||||
self._local = 0
|
||||
self._digestsize = self.digest_size
|
||||
if s:
|
||||
self.update(s)
|
||||
|
||||
def update(self, s):
|
||||
if isinstance(s, str):
|
||||
s = s.encode("ascii")
|
||||
else:
|
||||
s = bytes(s)
|
||||
self._update(s)
|
||||
|
||||
def digest(self):
|
||||
return self.copy()._final()[: self._digestsize]
|
||||
|
||||
def hexdigest(self):
|
||||
return "".join(["%.2x" % i for i in self.digest()])
|
||||
|
||||
def copy(self):
|
||||
new = type(self)()
|
||||
new._digest = self._digest[:]
|
||||
new._count_lo = self._count_lo
|
||||
new._count_hi = self._count_hi
|
||||
new._data = self._data[:]
|
||||
new._local = self._local
|
||||
return new
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
metadata(version="1.0")
|
||||
|
||||
package("hashlib")
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
# MIT license; Copyright (c) 2023 Jim Mussared
|
||||
# Originally ported from CPython by Paul Sokolovsky
|
||||
|
||||
from ._sha256 import sha256
|
||||
|
||||
|
||||
class sha224(sha256):
|
||||
digest_size = digestsize = 28
|
||||
_iv = [
|
||||
0xC1059ED8,
|
||||
0x367CD507,
|
||||
0x3070DD17,
|
||||
0xF70E5939,
|
||||
0xFFC00B31,
|
||||
0x68581511,
|
||||
0x64F98FA7,
|
||||
0xBEFA4FA4,
|
||||
]
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
metadata(version="1.0", description="Adds the SHA224 hash algorithm to hashlib.")
|
||||
|
||||
require("hashlib-sha256")
|
||||
package("hashlib")
|
||||
|
|
@ -0,0 +1,194 @@
|
|||
# MIT license; Copyright (c) 2023 Jim Mussared
|
||||
# Originally ported from CPython by Paul Sokolovsky
|
||||
|
||||
from ._sha import sha
|
||||
|
||||
_SHA_BLOCKSIZE = const(64)
|
||||
|
||||
|
||||
ROR = lambda x, y: (((x & 0xFFFFFFFF) >> (y & 31)) | (x << (32 - (y & 31)))) & 0xFFFFFFFF
|
||||
Ch = lambda x, y, z: (z ^ (x & (y ^ z)))
|
||||
Maj = lambda x, y, z: (((x | y) & z) | (x & y))
|
||||
S = lambda x, n: ROR(x, n)
|
||||
R = lambda x, n: (x & 0xFFFFFFFF) >> n
|
||||
Sigma0 = lambda x: (S(x, 2) ^ S(x, 13) ^ S(x, 22))
|
||||
Sigma1 = lambda x: (S(x, 6) ^ S(x, 11) ^ S(x, 25))
|
||||
Gamma0 = lambda x: (S(x, 7) ^ S(x, 18) ^ R(x, 3))
|
||||
Gamma1 = lambda x: (S(x, 17) ^ S(x, 19) ^ R(x, 10))
|
||||
|
||||
|
||||
class sha256(sha):
|
||||
digest_size = digestsize = 32
|
||||
block_size = _SHA_BLOCKSIZE
|
||||
_iv = [
|
||||
0x6A09E667,
|
||||
0xBB67AE85,
|
||||
0x3C6EF372,
|
||||
0xA54FF53A,
|
||||
0x510E527F,
|
||||
0x9B05688C,
|
||||
0x1F83D9AB,
|
||||
0x5BE0CD19,
|
||||
]
|
||||
|
||||
def _transform(self):
|
||||
W = []
|
||||
|
||||
d = self._data
|
||||
for i in range(0, 16):
|
||||
W.append((d[4 * i] << 24) + (d[4 * i + 1] << 16) + (d[4 * i + 2] << 8) + d[4 * i + 3])
|
||||
|
||||
for i in range(16, 64):
|
||||
W.append((Gamma1(W[i - 2]) + W[i - 7] + Gamma0(W[i - 15]) + W[i - 16]) & 0xFFFFFFFF)
|
||||
|
||||
ss = self._digest[:]
|
||||
|
||||
def RND(a, b, c, d, e, f, g, h, i, ki):
|
||||
t0 = h + Sigma1(e) + Ch(e, f, g) + ki + W[i]
|
||||
t1 = Sigma0(a) + Maj(a, b, c)
|
||||
d += t0
|
||||
h = t0 + t1
|
||||
return d & 0xFFFFFFFF, h & 0xFFFFFFFF
|
||||
|
||||
ss[3], ss[7] = RND(ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 0, 0x428A2F98)
|
||||
ss[2], ss[6] = RND(ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 1, 0x71374491)
|
||||
ss[1], ss[5] = RND(ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 2, 0xB5C0FBCF)
|
||||
ss[0], ss[4] = RND(ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 3, 0xE9B5DBA5)
|
||||
ss[7], ss[3] = RND(ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 4, 0x3956C25B)
|
||||
ss[6], ss[2] = RND(ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 5, 0x59F111F1)
|
||||
ss[5], ss[1] = RND(ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 6, 0x923F82A4)
|
||||
ss[4], ss[0] = RND(ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 7, 0xAB1C5ED5)
|
||||
ss[3], ss[7] = RND(ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 8, 0xD807AA98)
|
||||
ss[2], ss[6] = RND(ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 9, 0x12835B01)
|
||||
ss[1], ss[5] = RND(ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 10, 0x243185BE)
|
||||
ss[0], ss[4] = RND(ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 11, 0x550C7DC3)
|
||||
ss[7], ss[3] = RND(ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 12, 0x72BE5D74)
|
||||
ss[6], ss[2] = RND(ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 13, 0x80DEB1FE)
|
||||
ss[5], ss[1] = RND(ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 14, 0x9BDC06A7)
|
||||
ss[4], ss[0] = RND(ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 15, 0xC19BF174)
|
||||
ss[3], ss[7] = RND(ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 16, 0xE49B69C1)
|
||||
ss[2], ss[6] = RND(ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 17, 0xEFBE4786)
|
||||
ss[1], ss[5] = RND(ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 18, 0x0FC19DC6)
|
||||
ss[0], ss[4] = RND(ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 19, 0x240CA1CC)
|
||||
ss[7], ss[3] = RND(ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 20, 0x2DE92C6F)
|
||||
ss[6], ss[2] = RND(ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 21, 0x4A7484AA)
|
||||
ss[5], ss[1] = RND(ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 22, 0x5CB0A9DC)
|
||||
ss[4], ss[0] = RND(ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 23, 0x76F988DA)
|
||||
ss[3], ss[7] = RND(ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 24, 0x983E5152)
|
||||
ss[2], ss[6] = RND(ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 25, 0xA831C66D)
|
||||
ss[1], ss[5] = RND(ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 26, 0xB00327C8)
|
||||
ss[0], ss[4] = RND(ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 27, 0xBF597FC7)
|
||||
ss[7], ss[3] = RND(ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 28, 0xC6E00BF3)
|
||||
ss[6], ss[2] = RND(ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 29, 0xD5A79147)
|
||||
ss[5], ss[1] = RND(ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 30, 0x06CA6351)
|
||||
ss[4], ss[0] = RND(ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 31, 0x14292967)
|
||||
ss[3], ss[7] = RND(ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 32, 0x27B70A85)
|
||||
ss[2], ss[6] = RND(ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 33, 0x2E1B2138)
|
||||
ss[1], ss[5] = RND(ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 34, 0x4D2C6DFC)
|
||||
ss[0], ss[4] = RND(ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 35, 0x53380D13)
|
||||
ss[7], ss[3] = RND(ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 36, 0x650A7354)
|
||||
ss[6], ss[2] = RND(ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 37, 0x766A0ABB)
|
||||
ss[5], ss[1] = RND(ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 38, 0x81C2C92E)
|
||||
ss[4], ss[0] = RND(ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 39, 0x92722C85)
|
||||
ss[3], ss[7] = RND(ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 40, 0xA2BFE8A1)
|
||||
ss[2], ss[6] = RND(ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 41, 0xA81A664B)
|
||||
ss[1], ss[5] = RND(ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 42, 0xC24B8B70)
|
||||
ss[0], ss[4] = RND(ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 43, 0xC76C51A3)
|
||||
ss[7], ss[3] = RND(ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 44, 0xD192E819)
|
||||
ss[6], ss[2] = RND(ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 45, 0xD6990624)
|
||||
ss[5], ss[1] = RND(ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 46, 0xF40E3585)
|
||||
ss[4], ss[0] = RND(ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 47, 0x106AA070)
|
||||
ss[3], ss[7] = RND(ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 48, 0x19A4C116)
|
||||
ss[2], ss[6] = RND(ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 49, 0x1E376C08)
|
||||
ss[1], ss[5] = RND(ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 50, 0x2748774C)
|
||||
ss[0], ss[4] = RND(ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 51, 0x34B0BCB5)
|
||||
ss[7], ss[3] = RND(ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 52, 0x391C0CB3)
|
||||
ss[6], ss[2] = RND(ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 53, 0x4ED8AA4A)
|
||||
ss[5], ss[1] = RND(ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 54, 0x5B9CCA4F)
|
||||
ss[4], ss[0] = RND(ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 55, 0x682E6FF3)
|
||||
ss[3], ss[7] = RND(ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 56, 0x748F82EE)
|
||||
ss[2], ss[6] = RND(ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 57, 0x78A5636F)
|
||||
ss[1], ss[5] = RND(ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 58, 0x84C87814)
|
||||
ss[0], ss[4] = RND(ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 59, 0x8CC70208)
|
||||
ss[7], ss[3] = RND(ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 60, 0x90BEFFFA)
|
||||
ss[6], ss[2] = RND(ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 61, 0xA4506CEB)
|
||||
ss[5], ss[1] = RND(ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 62, 0xBEF9A3F7)
|
||||
ss[4], ss[0] = RND(ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 63, 0xC67178F2)
|
||||
|
||||
for i in range(len(self._digest)):
|
||||
self._digest[i] = (self._digest[i] + ss[i]) & 0xFFFFFFFF
|
||||
|
||||
def _update(self, buffer):
|
||||
if isinstance(buffer, str):
|
||||
raise TypeError("Unicode strings must be encoded before hashing")
|
||||
count = len(buffer)
|
||||
buffer_idx = 0
|
||||
clo = (self._count_lo + (count << 3)) & 0xFFFFFFFF
|
||||
if clo < self._count_lo:
|
||||
self._count_hi += 1
|
||||
self._count_lo = clo
|
||||
|
||||
self._count_hi += count >> 29
|
||||
|
||||
if self._local:
|
||||
i = _SHA_BLOCKSIZE - self._local
|
||||
if i > count:
|
||||
i = count
|
||||
|
||||
# copy buffer
|
||||
for x in enumerate(buffer[buffer_idx : buffer_idx + i]):
|
||||
self._data[self._local + x[0]] = x[1]
|
||||
|
||||
count -= i
|
||||
buffer_idx += i
|
||||
|
||||
self._local += i
|
||||
if self._local == _SHA_BLOCKSIZE:
|
||||
self._transform()
|
||||
self._local = 0
|
||||
else:
|
||||
return
|
||||
|
||||
while count >= _SHA_BLOCKSIZE:
|
||||
# copy buffer
|
||||
self._data = bytearray(buffer[buffer_idx : buffer_idx + _SHA_BLOCKSIZE])
|
||||
count -= _SHA_BLOCKSIZE
|
||||
buffer_idx += _SHA_BLOCKSIZE
|
||||
self._transform()
|
||||
|
||||
# copy buffer
|
||||
pos = self._local
|
||||
self._data[pos : pos + count] = buffer[buffer_idx : buffer_idx + count]
|
||||
self._local = count
|
||||
|
||||
def _final(self):
|
||||
lo_bit_count = self._count_lo
|
||||
hi_bit_count = self._count_hi
|
||||
count = (lo_bit_count >> 3) & 0x3F
|
||||
self._data[count] = 0x80
|
||||
count += 1
|
||||
if count > _SHA_BLOCKSIZE - 8:
|
||||
# zero the bytes in data after the count
|
||||
self._data = self._data[:count] + bytes(_SHA_BLOCKSIZE - count)
|
||||
self._transform()
|
||||
# zero bytes in data
|
||||
self._data = bytearray(_SHA_BLOCKSIZE)
|
||||
else:
|
||||
self._data = self._data[:count] + bytes(_SHA_BLOCKSIZE - count)
|
||||
|
||||
self._data[56] = (hi_bit_count >> 24) & 0xFF
|
||||
self._data[57] = (hi_bit_count >> 16) & 0xFF
|
||||
self._data[58] = (hi_bit_count >> 8) & 0xFF
|
||||
self._data[59] = (hi_bit_count >> 0) & 0xFF
|
||||
self._data[60] = (lo_bit_count >> 24) & 0xFF
|
||||
self._data[61] = (lo_bit_count >> 16) & 0xFF
|
||||
self._data[62] = (lo_bit_count >> 8) & 0xFF
|
||||
self._data[63] = (lo_bit_count >> 0) & 0xFF
|
||||
|
||||
self._transform()
|
||||
|
||||
dig = bytearray()
|
||||
for i in self._digest:
|
||||
for j in range(4):
|
||||
dig.append((i >> ((3 - j) * 8)) & 0xFF)
|
||||
return dig
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
metadata(version="1.0", description="Adds the SHA256 hash algorithm to hashlib.")
|
||||
|
||||
require("hashlib-core")
|
||||
package("hashlib")
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
# MIT license; Copyright (c) 2023 Jim Mussared
|
||||
# Originally ported from CPython by Paul Sokolovsky
|
||||
|
||||
from ._sha512 import sha512
|
||||
|
||||
|
||||
class sha384(sha512):
|
||||
digest_size = digestsize = 48
|
||||
_iv = [
|
||||
0xCBBB9D5DC1059ED8,
|
||||
0x629A292A367CD507,
|
||||
0x9159015A3070DD17,
|
||||
0x152FECD8F70E5939,
|
||||
0x67332667FFC00B31,
|
||||
0x8EB44A8768581511,
|
||||
0xDB0C2E0D64F98FA7,
|
||||
0x47B5481DBEFA4FA4,
|
||||
]
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
metadata(version="1.0", description="Adds the SHA384 hash algorithm to hashlib.")
|
||||
|
||||
require("hashlib-sha512")
|
||||
package("hashlib")
|
||||
|
|
@ -0,0 +1,393 @@
|
|||
# MIT license; Copyright (c) 2023 Jim Mussared
|
||||
# Originally ported from CPython by Paul Sokolovsky
|
||||
|
||||
from ._sha import sha
|
||||
|
||||
_SHA_BLOCKSIZE = const(128)
|
||||
|
||||
|
||||
ROR64 = (
|
||||
lambda x, y: (((x & 0xFFFFFFFFFFFFFFFF) >> (y & 63)) | (x << (64 - (y & 63))))
|
||||
& 0xFFFFFFFFFFFFFFFF
|
||||
)
|
||||
Ch = lambda x, y, z: (z ^ (x & (y ^ z)))
|
||||
Maj = lambda x, y, z: (((x | y) & z) | (x & y))
|
||||
S = lambda x, n: ROR64(x, n)
|
||||
R = lambda x, n: (x & 0xFFFFFFFFFFFFFFFF) >> n
|
||||
Sigma0 = lambda x: (S(x, 28) ^ S(x, 34) ^ S(x, 39))
|
||||
Sigma1 = lambda x: (S(x, 14) ^ S(x, 18) ^ S(x, 41))
|
||||
Gamma0 = lambda x: (S(x, 1) ^ S(x, 8) ^ R(x, 7))
|
||||
Gamma1 = lambda x: (S(x, 19) ^ S(x, 61) ^ R(x, 6))
|
||||
|
||||
|
||||
class sha512(sha):
|
||||
digest_size = digestsize = 64
|
||||
block_size = _SHA_BLOCKSIZE
|
||||
_iv = [
|
||||
0x6A09E667F3BCC908,
|
||||
0xBB67AE8584CAA73B,
|
||||
0x3C6EF372FE94F82B,
|
||||
0xA54FF53A5F1D36F1,
|
||||
0x510E527FADE682D1,
|
||||
0x9B05688C2B3E6C1F,
|
||||
0x1F83D9ABFB41BD6B,
|
||||
0x5BE0CD19137E2179,
|
||||
]
|
||||
|
||||
def _transform(self):
|
||||
W = []
|
||||
|
||||
d = self._data
|
||||
for i in range(0, 16):
|
||||
W.append(
|
||||
(d[8 * i] << 56)
|
||||
+ (d[8 * i + 1] << 48)
|
||||
+ (d[8 * i + 2] << 40)
|
||||
+ (d[8 * i + 3] << 32)
|
||||
+ (d[8 * i + 4] << 24)
|
||||
+ (d[8 * i + 5] << 16)
|
||||
+ (d[8 * i + 6] << 8)
|
||||
+ d[8 * i + 7]
|
||||
)
|
||||
|
||||
for i in range(16, 80):
|
||||
W.append(
|
||||
(Gamma1(W[i - 2]) + W[i - 7] + Gamma0(W[i - 15]) + W[i - 16]) & 0xFFFFFFFFFFFFFFFF
|
||||
)
|
||||
|
||||
ss = self._digest[:]
|
||||
|
||||
def RND(a, b, c, d, e, f, g, h, i, ki):
|
||||
t0 = (h + Sigma1(e) + Ch(e, f, g) + ki + W[i]) & 0xFFFFFFFFFFFFFFFF
|
||||
t1 = (Sigma0(a) + Maj(a, b, c)) & 0xFFFFFFFFFFFFFFFF
|
||||
d = (d + t0) & 0xFFFFFFFFFFFFFFFF
|
||||
h = (t0 + t1) & 0xFFFFFFFFFFFFFFFF
|
||||
return d & 0xFFFFFFFFFFFFFFFF, h & 0xFFFFFFFFFFFFFFFF
|
||||
|
||||
ss[3], ss[7] = RND(
|
||||
ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 0, 0x428A2F98D728AE22
|
||||
)
|
||||
ss[2], ss[6] = RND(
|
||||
ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 1, 0x7137449123EF65CD
|
||||
)
|
||||
ss[1], ss[5] = RND(
|
||||
ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 2, 0xB5C0FBCFEC4D3B2F
|
||||
)
|
||||
ss[0], ss[4] = RND(
|
||||
ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 3, 0xE9B5DBA58189DBBC
|
||||
)
|
||||
ss[7], ss[3] = RND(
|
||||
ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 4, 0x3956C25BF348B538
|
||||
)
|
||||
ss[6], ss[2] = RND(
|
||||
ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 5, 0x59F111F1B605D019
|
||||
)
|
||||
ss[5], ss[1] = RND(
|
||||
ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 6, 0x923F82A4AF194F9B
|
||||
)
|
||||
ss[4], ss[0] = RND(
|
||||
ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 7, 0xAB1C5ED5DA6D8118
|
||||
)
|
||||
ss[3], ss[7] = RND(
|
||||
ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 8, 0xD807AA98A3030242
|
||||
)
|
||||
ss[2], ss[6] = RND(
|
||||
ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 9, 0x12835B0145706FBE
|
||||
)
|
||||
ss[1], ss[5] = RND(
|
||||
ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 10, 0x243185BE4EE4B28C
|
||||
)
|
||||
ss[0], ss[4] = RND(
|
||||
ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 11, 0x550C7DC3D5FFB4E2
|
||||
)
|
||||
ss[7], ss[3] = RND(
|
||||
ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 12, 0x72BE5D74F27B896F
|
||||
)
|
||||
ss[6], ss[2] = RND(
|
||||
ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 13, 0x80DEB1FE3B1696B1
|
||||
)
|
||||
ss[5], ss[1] = RND(
|
||||
ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 14, 0x9BDC06A725C71235
|
||||
)
|
||||
ss[4], ss[0] = RND(
|
||||
ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 15, 0xC19BF174CF692694
|
||||
)
|
||||
ss[3], ss[7] = RND(
|
||||
ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 16, 0xE49B69C19EF14AD2
|
||||
)
|
||||
ss[2], ss[6] = RND(
|
||||
ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 17, 0xEFBE4786384F25E3
|
||||
)
|
||||
ss[1], ss[5] = RND(
|
||||
ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 18, 0x0FC19DC68B8CD5B5
|
||||
)
|
||||
ss[0], ss[4] = RND(
|
||||
ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 19, 0x240CA1CC77AC9C65
|
||||
)
|
||||
ss[7], ss[3] = RND(
|
||||
ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 20, 0x2DE92C6F592B0275
|
||||
)
|
||||
ss[6], ss[2] = RND(
|
||||
ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 21, 0x4A7484AA6EA6E483
|
||||
)
|
||||
ss[5], ss[1] = RND(
|
||||
ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 22, 0x5CB0A9DCBD41FBD4
|
||||
)
|
||||
ss[4], ss[0] = RND(
|
||||
ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 23, 0x76F988DA831153B5
|
||||
)
|
||||
ss[3], ss[7] = RND(
|
||||
ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 24, 0x983E5152EE66DFAB
|
||||
)
|
||||
ss[2], ss[6] = RND(
|
||||
ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 25, 0xA831C66D2DB43210
|
||||
)
|
||||
ss[1], ss[5] = RND(
|
||||
ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 26, 0xB00327C898FB213F
|
||||
)
|
||||
ss[0], ss[4] = RND(
|
||||
ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 27, 0xBF597FC7BEEF0EE4
|
||||
)
|
||||
ss[7], ss[3] = RND(
|
||||
ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 28, 0xC6E00BF33DA88FC2
|
||||
)
|
||||
ss[6], ss[2] = RND(
|
||||
ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 29, 0xD5A79147930AA725
|
||||
)
|
||||
ss[5], ss[1] = RND(
|
||||
ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 30, 0x06CA6351E003826F
|
||||
)
|
||||
ss[4], ss[0] = RND(
|
||||
ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 31, 0x142929670A0E6E70
|
||||
)
|
||||
ss[3], ss[7] = RND(
|
||||
ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 32, 0x27B70A8546D22FFC
|
||||
)
|
||||
ss[2], ss[6] = RND(
|
||||
ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 33, 0x2E1B21385C26C926
|
||||
)
|
||||
ss[1], ss[5] = RND(
|
||||
ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 34, 0x4D2C6DFC5AC42AED
|
||||
)
|
||||
ss[0], ss[4] = RND(
|
||||
ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 35, 0x53380D139D95B3DF
|
||||
)
|
||||
ss[7], ss[3] = RND(
|
||||
ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 36, 0x650A73548BAF63DE
|
||||
)
|
||||
ss[6], ss[2] = RND(
|
||||
ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 37, 0x766A0ABB3C77B2A8
|
||||
)
|
||||
ss[5], ss[1] = RND(
|
||||
ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 38, 0x81C2C92E47EDAEE6
|
||||
)
|
||||
ss[4], ss[0] = RND(
|
||||
ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 39, 0x92722C851482353B
|
||||
)
|
||||
ss[3], ss[7] = RND(
|
||||
ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 40, 0xA2BFE8A14CF10364
|
||||
)
|
||||
ss[2], ss[6] = RND(
|
||||
ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 41, 0xA81A664BBC423001
|
||||
)
|
||||
ss[1], ss[5] = RND(
|
||||
ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 42, 0xC24B8B70D0F89791
|
||||
)
|
||||
ss[0], ss[4] = RND(
|
||||
ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 43, 0xC76C51A30654BE30
|
||||
)
|
||||
ss[7], ss[3] = RND(
|
||||
ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 44, 0xD192E819D6EF5218
|
||||
)
|
||||
ss[6], ss[2] = RND(
|
||||
ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 45, 0xD69906245565A910
|
||||
)
|
||||
ss[5], ss[1] = RND(
|
||||
ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 46, 0xF40E35855771202A
|
||||
)
|
||||
ss[4], ss[0] = RND(
|
||||
ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 47, 0x106AA07032BBD1B8
|
||||
)
|
||||
ss[3], ss[7] = RND(
|
||||
ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 48, 0x19A4C116B8D2D0C8
|
||||
)
|
||||
ss[2], ss[6] = RND(
|
||||
ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 49, 0x1E376C085141AB53
|
||||
)
|
||||
ss[1], ss[5] = RND(
|
||||
ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 50, 0x2748774CDF8EEB99
|
||||
)
|
||||
ss[0], ss[4] = RND(
|
||||
ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 51, 0x34B0BCB5E19B48A8
|
||||
)
|
||||
ss[7], ss[3] = RND(
|
||||
ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 52, 0x391C0CB3C5C95A63
|
||||
)
|
||||
ss[6], ss[2] = RND(
|
||||
ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 53, 0x4ED8AA4AE3418ACB
|
||||
)
|
||||
ss[5], ss[1] = RND(
|
||||
ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 54, 0x5B9CCA4F7763E373
|
||||
)
|
||||
ss[4], ss[0] = RND(
|
||||
ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 55, 0x682E6FF3D6B2B8A3
|
||||
)
|
||||
ss[3], ss[7] = RND(
|
||||
ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 56, 0x748F82EE5DEFB2FC
|
||||
)
|
||||
ss[2], ss[6] = RND(
|
||||
ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 57, 0x78A5636F43172F60
|
||||
)
|
||||
ss[1], ss[5] = RND(
|
||||
ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 58, 0x84C87814A1F0AB72
|
||||
)
|
||||
ss[0], ss[4] = RND(
|
||||
ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 59, 0x8CC702081A6439EC
|
||||
)
|
||||
ss[7], ss[3] = RND(
|
||||
ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 60, 0x90BEFFFA23631E28
|
||||
)
|
||||
ss[6], ss[2] = RND(
|
||||
ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 61, 0xA4506CEBDE82BDE9
|
||||
)
|
||||
ss[5], ss[1] = RND(
|
||||
ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 62, 0xBEF9A3F7B2C67915
|
||||
)
|
||||
ss[4], ss[0] = RND(
|
||||
ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 63, 0xC67178F2E372532B
|
||||
)
|
||||
ss[3], ss[7] = RND(
|
||||
ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 64, 0xCA273ECEEA26619C
|
||||
)
|
||||
ss[2], ss[6] = RND(
|
||||
ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 65, 0xD186B8C721C0C207
|
||||
)
|
||||
ss[1], ss[5] = RND(
|
||||
ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 66, 0xEADA7DD6CDE0EB1E
|
||||
)
|
||||
ss[0], ss[4] = RND(
|
||||
ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 67, 0xF57D4F7FEE6ED178
|
||||
)
|
||||
ss[7], ss[3] = RND(
|
||||
ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 68, 0x06F067AA72176FBA
|
||||
)
|
||||
ss[6], ss[2] = RND(
|
||||
ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 69, 0x0A637DC5A2C898A6
|
||||
)
|
||||
ss[5], ss[1] = RND(
|
||||
ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 70, 0x113F9804BEF90DAE
|
||||
)
|
||||
ss[4], ss[0] = RND(
|
||||
ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 71, 0x1B710B35131C471B
|
||||
)
|
||||
ss[3], ss[7] = RND(
|
||||
ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 72, 0x28DB77F523047D84
|
||||
)
|
||||
ss[2], ss[6] = RND(
|
||||
ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 73, 0x32CAAB7B40C72493
|
||||
)
|
||||
ss[1], ss[5] = RND(
|
||||
ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 74, 0x3C9EBE0A15C9BEBC
|
||||
)
|
||||
ss[0], ss[4] = RND(
|
||||
ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 75, 0x431D67C49C100D4C
|
||||
)
|
||||
ss[7], ss[3] = RND(
|
||||
ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 76, 0x4CC5D4BECB3E42B6
|
||||
)
|
||||
ss[6], ss[2] = RND(
|
||||
ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 77, 0x597F299CFC657E2A
|
||||
)
|
||||
ss[5], ss[1] = RND(
|
||||
ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 78, 0x5FCB6FAB3AD6FAEC
|
||||
)
|
||||
ss[4], ss[0] = RND(
|
||||
ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 79, 0x6C44198C4A475817
|
||||
)
|
||||
|
||||
for i in range(len(self._digest)):
|
||||
self._digest[i] = (self._digest[i] + ss[i]) & 0xFFFFFFFFFFFFFFFF
|
||||
|
||||
def _update(self, buffer):
|
||||
if isinstance(buffer, str):
|
||||
raise TypeError("Unicode strings must be encoded before hashing")
|
||||
count = len(buffer)
|
||||
buffer_idx = 0
|
||||
clo = (self._count_lo + (count << 3)) & 0xFFFFFFFF
|
||||
if clo < self._count_lo:
|
||||
self._count_hi += 1
|
||||
self._count_lo = clo
|
||||
|
||||
self._count_hi += count >> 29
|
||||
|
||||
if self._local:
|
||||
i = _SHA_BLOCKSIZE - self._local
|
||||
if i > count:
|
||||
i = count
|
||||
|
||||
# copy buffer
|
||||
for x in enumerate(buffer[buffer_idx : buffer_idx + i]):
|
||||
self._data[self._local + x[0]] = x[1]
|
||||
|
||||
count -= i
|
||||
buffer_idx += i
|
||||
|
||||
self._local += i
|
||||
if self._local == _SHA_BLOCKSIZE:
|
||||
self._transform()
|
||||
self._local = 0
|
||||
else:
|
||||
return
|
||||
|
||||
while count >= _SHA_BLOCKSIZE:
|
||||
# copy buffer
|
||||
self._data = bytearray(buffer[buffer_idx : buffer_idx + _SHA_BLOCKSIZE])
|
||||
count -= _SHA_BLOCKSIZE
|
||||
buffer_idx += _SHA_BLOCKSIZE
|
||||
self._transform()
|
||||
|
||||
# copy buffer
|
||||
pos = self._local
|
||||
self._data[pos : pos + count] = buffer[buffer_idx : buffer_idx + count]
|
||||
self._local = count
|
||||
|
||||
def _final(self):
|
||||
lo_bit_count = self._count_lo
|
||||
hi_bit_count = self._count_hi
|
||||
count = (lo_bit_count >> 3) & 0x7F
|
||||
self._data[count] = 0x80
|
||||
count += 1
|
||||
if count > _SHA_BLOCKSIZE - 16:
|
||||
# zero the bytes in data after the count
|
||||
self._data = self._data[:count] + bytes(_SHA_BLOCKSIZE - count)
|
||||
self._transform()
|
||||
# zero bytes in data
|
||||
self._data = bytearray(_SHA_BLOCKSIZE)
|
||||
else:
|
||||
self._data = self._data[:count] + bytes(_SHA_BLOCKSIZE - count)
|
||||
|
||||
self._data[112] = 0
|
||||
self._data[113] = 0
|
||||
self._data[114] = 0
|
||||
self._data[115] = 0
|
||||
self._data[116] = 0
|
||||
self._data[117] = 0
|
||||
self._data[118] = 0
|
||||
self._data[119] = 0
|
||||
|
||||
self._data[120] = (hi_bit_count >> 24) & 0xFF
|
||||
self._data[121] = (hi_bit_count >> 16) & 0xFF
|
||||
self._data[122] = (hi_bit_count >> 8) & 0xFF
|
||||
self._data[123] = (hi_bit_count >> 0) & 0xFF
|
||||
self._data[124] = (lo_bit_count >> 24) & 0xFF
|
||||
self._data[125] = (lo_bit_count >> 16) & 0xFF
|
||||
self._data[126] = (lo_bit_count >> 8) & 0xFF
|
||||
self._data[127] = (lo_bit_count >> 0) & 0xFF
|
||||
|
||||
self._transform()
|
||||
|
||||
dig = bytearray()
|
||||
for i in self._digest:
|
||||
for j in range(8):
|
||||
dig.append((i >> ((7 - j) * 8)) & 0xFF)
|
||||
return dig
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
metadata(version="1.0", description="Adds the SHA512 hash algorithm to hashlib.")
|
||||
|
||||
require("hashlib-core")
|
||||
package("hashlib")
|
||||
|
|
@ -1,24 +0,0 @@
|
|||
try:
|
||||
import uhashlib
|
||||
except ImportError:
|
||||
uhashlib = None
|
||||
|
||||
|
||||
def init():
|
||||
for i in ("sha1", "sha224", "sha256", "sha384", "sha512"):
|
||||
c = getattr(uhashlib, i, None)
|
||||
if not c:
|
||||
c = __import__("_" + i, None, None, (), 1)
|
||||
c = getattr(c, i)
|
||||
globals()[i] = c
|
||||
|
||||
|
||||
init()
|
||||
|
||||
|
||||
def new(algo, data=b""):
|
||||
try:
|
||||
c = globals()[algo]
|
||||
return c(data)
|
||||
except KeyError:
|
||||
raise ValueError(algo)
|
||||
|
|
@ -1 +0,0 @@
|
|||
from ._sha256 import sha224
|
||||
|
|
@ -1,301 +0,0 @@
|
|||
SHA_BLOCKSIZE = 64
|
||||
SHA_DIGESTSIZE = 32
|
||||
|
||||
|
||||
def new_shaobject():
|
||||
return {
|
||||
"digest": [0] * 8,
|
||||
"count_lo": 0,
|
||||
"count_hi": 0,
|
||||
"data": [0] * SHA_BLOCKSIZE,
|
||||
"local": 0,
|
||||
"digestsize": 0,
|
||||
}
|
||||
|
||||
|
||||
ROR = lambda x, y: (((x & 0xFFFFFFFF) >> (y & 31)) | (x << (32 - (y & 31)))) & 0xFFFFFFFF
|
||||
Ch = lambda x, y, z: (z ^ (x & (y ^ z)))
|
||||
Maj = lambda x, y, z: (((x | y) & z) | (x & y))
|
||||
S = lambda x, n: ROR(x, n)
|
||||
R = lambda x, n: (x & 0xFFFFFFFF) >> n
|
||||
Sigma0 = lambda x: (S(x, 2) ^ S(x, 13) ^ S(x, 22))
|
||||
Sigma1 = lambda x: (S(x, 6) ^ S(x, 11) ^ S(x, 25))
|
||||
Gamma0 = lambda x: (S(x, 7) ^ S(x, 18) ^ R(x, 3))
|
||||
Gamma1 = lambda x: (S(x, 17) ^ S(x, 19) ^ R(x, 10))
|
||||
|
||||
|
||||
def sha_transform(sha_info):
|
||||
W = []
|
||||
|
||||
d = sha_info["data"]
|
||||
for i in range(0, 16):
|
||||
W.append((d[4 * i] << 24) + (d[4 * i + 1] << 16) + (d[4 * i + 2] << 8) + d[4 * i + 3])
|
||||
|
||||
for i in range(16, 64):
|
||||
W.append((Gamma1(W[i - 2]) + W[i - 7] + Gamma0(W[i - 15]) + W[i - 16]) & 0xFFFFFFFF)
|
||||
|
||||
ss = sha_info["digest"][:]
|
||||
|
||||
def RND(a, b, c, d, e, f, g, h, i, ki):
|
||||
t0 = h + Sigma1(e) + Ch(e, f, g) + ki + W[i]
|
||||
t1 = Sigma0(a) + Maj(a, b, c)
|
||||
d += t0
|
||||
h = t0 + t1
|
||||
return d & 0xFFFFFFFF, h & 0xFFFFFFFF
|
||||
|
||||
ss[3], ss[7] = RND(ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 0, 0x428A2F98)
|
||||
ss[2], ss[6] = RND(ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 1, 0x71374491)
|
||||
ss[1], ss[5] = RND(ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 2, 0xB5C0FBCF)
|
||||
ss[0], ss[4] = RND(ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 3, 0xE9B5DBA5)
|
||||
ss[7], ss[3] = RND(ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 4, 0x3956C25B)
|
||||
ss[6], ss[2] = RND(ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 5, 0x59F111F1)
|
||||
ss[5], ss[1] = RND(ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 6, 0x923F82A4)
|
||||
ss[4], ss[0] = RND(ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 7, 0xAB1C5ED5)
|
||||
ss[3], ss[7] = RND(ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 8, 0xD807AA98)
|
||||
ss[2], ss[6] = RND(ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 9, 0x12835B01)
|
||||
ss[1], ss[5] = RND(ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 10, 0x243185BE)
|
||||
ss[0], ss[4] = RND(ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 11, 0x550C7DC3)
|
||||
ss[7], ss[3] = RND(ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 12, 0x72BE5D74)
|
||||
ss[6], ss[2] = RND(ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 13, 0x80DEB1FE)
|
||||
ss[5], ss[1] = RND(ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 14, 0x9BDC06A7)
|
||||
ss[4], ss[0] = RND(ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 15, 0xC19BF174)
|
||||
ss[3], ss[7] = RND(ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 16, 0xE49B69C1)
|
||||
ss[2], ss[6] = RND(ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 17, 0xEFBE4786)
|
||||
ss[1], ss[5] = RND(ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 18, 0x0FC19DC6)
|
||||
ss[0], ss[4] = RND(ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 19, 0x240CA1CC)
|
||||
ss[7], ss[3] = RND(ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 20, 0x2DE92C6F)
|
||||
ss[6], ss[2] = RND(ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 21, 0x4A7484AA)
|
||||
ss[5], ss[1] = RND(ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 22, 0x5CB0A9DC)
|
||||
ss[4], ss[0] = RND(ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 23, 0x76F988DA)
|
||||
ss[3], ss[7] = RND(ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 24, 0x983E5152)
|
||||
ss[2], ss[6] = RND(ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 25, 0xA831C66D)
|
||||
ss[1], ss[5] = RND(ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 26, 0xB00327C8)
|
||||
ss[0], ss[4] = RND(ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 27, 0xBF597FC7)
|
||||
ss[7], ss[3] = RND(ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 28, 0xC6E00BF3)
|
||||
ss[6], ss[2] = RND(ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 29, 0xD5A79147)
|
||||
ss[5], ss[1] = RND(ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 30, 0x06CA6351)
|
||||
ss[4], ss[0] = RND(ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 31, 0x14292967)
|
||||
ss[3], ss[7] = RND(ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 32, 0x27B70A85)
|
||||
ss[2], ss[6] = RND(ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 33, 0x2E1B2138)
|
||||
ss[1], ss[5] = RND(ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 34, 0x4D2C6DFC)
|
||||
ss[0], ss[4] = RND(ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 35, 0x53380D13)
|
||||
ss[7], ss[3] = RND(ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 36, 0x650A7354)
|
||||
ss[6], ss[2] = RND(ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 37, 0x766A0ABB)
|
||||
ss[5], ss[1] = RND(ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 38, 0x81C2C92E)
|
||||
ss[4], ss[0] = RND(ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 39, 0x92722C85)
|
||||
ss[3], ss[7] = RND(ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 40, 0xA2BFE8A1)
|
||||
ss[2], ss[6] = RND(ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 41, 0xA81A664B)
|
||||
ss[1], ss[5] = RND(ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 42, 0xC24B8B70)
|
||||
ss[0], ss[4] = RND(ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 43, 0xC76C51A3)
|
||||
ss[7], ss[3] = RND(ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 44, 0xD192E819)
|
||||
ss[6], ss[2] = RND(ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 45, 0xD6990624)
|
||||
ss[5], ss[1] = RND(ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 46, 0xF40E3585)
|
||||
ss[4], ss[0] = RND(ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 47, 0x106AA070)
|
||||
ss[3], ss[7] = RND(ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 48, 0x19A4C116)
|
||||
ss[2], ss[6] = RND(ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 49, 0x1E376C08)
|
||||
ss[1], ss[5] = RND(ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 50, 0x2748774C)
|
||||
ss[0], ss[4] = RND(ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 51, 0x34B0BCB5)
|
||||
ss[7], ss[3] = RND(ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 52, 0x391C0CB3)
|
||||
ss[6], ss[2] = RND(ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 53, 0x4ED8AA4A)
|
||||
ss[5], ss[1] = RND(ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 54, 0x5B9CCA4F)
|
||||
ss[4], ss[0] = RND(ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 55, 0x682E6FF3)
|
||||
ss[3], ss[7] = RND(ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 56, 0x748F82EE)
|
||||
ss[2], ss[6] = RND(ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 57, 0x78A5636F)
|
||||
ss[1], ss[5] = RND(ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 58, 0x84C87814)
|
||||
ss[0], ss[4] = RND(ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 59, 0x8CC70208)
|
||||
ss[7], ss[3] = RND(ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 60, 0x90BEFFFA)
|
||||
ss[6], ss[2] = RND(ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 61, 0xA4506CEB)
|
||||
ss[5], ss[1] = RND(ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 62, 0xBEF9A3F7)
|
||||
ss[4], ss[0] = RND(ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 63, 0xC67178F2)
|
||||
|
||||
dig = []
|
||||
for i, x in enumerate(sha_info["digest"]):
|
||||
dig.append((x + ss[i]) & 0xFFFFFFFF)
|
||||
sha_info["digest"] = dig
|
||||
|
||||
|
||||
def sha_init():
|
||||
sha_info = new_shaobject()
|
||||
sha_info["digest"] = [
|
||||
0x6A09E667,
|
||||
0xBB67AE85,
|
||||
0x3C6EF372,
|
||||
0xA54FF53A,
|
||||
0x510E527F,
|
||||
0x9B05688C,
|
||||
0x1F83D9AB,
|
||||
0x5BE0CD19,
|
||||
]
|
||||
sha_info["count_lo"] = 0
|
||||
sha_info["count_hi"] = 0
|
||||
sha_info["local"] = 0
|
||||
sha_info["digestsize"] = 32
|
||||
return sha_info
|
||||
|
||||
|
||||
def sha224_init():
|
||||
sha_info = new_shaobject()
|
||||
sha_info["digest"] = [
|
||||
0xC1059ED8,
|
||||
0x367CD507,
|
||||
0x3070DD17,
|
||||
0xF70E5939,
|
||||
0xFFC00B31,
|
||||
0x68581511,
|
||||
0x64F98FA7,
|
||||
0xBEFA4FA4,
|
||||
]
|
||||
sha_info["count_lo"] = 0
|
||||
sha_info["count_hi"] = 0
|
||||
sha_info["local"] = 0
|
||||
sha_info["digestsize"] = 28
|
||||
return sha_info
|
||||
|
||||
|
||||
def getbuf(s):
|
||||
if isinstance(s, str):
|
||||
return s.encode("ascii")
|
||||
else:
|
||||
return bytes(s)
|
||||
|
||||
|
||||
def sha_update(sha_info, buffer):
|
||||
if isinstance(buffer, str):
|
||||
raise TypeError("Unicode strings must be encoded before hashing")
|
||||
count = len(buffer)
|
||||
buffer_idx = 0
|
||||
clo = (sha_info["count_lo"] + (count << 3)) & 0xFFFFFFFF
|
||||
if clo < sha_info["count_lo"]:
|
||||
sha_info["count_hi"] += 1
|
||||
sha_info["count_lo"] = clo
|
||||
|
||||
sha_info["count_hi"] += count >> 29
|
||||
|
||||
if sha_info["local"]:
|
||||
i = SHA_BLOCKSIZE - sha_info["local"]
|
||||
if i > count:
|
||||
i = count
|
||||
|
||||
# copy buffer
|
||||
for x in enumerate(buffer[buffer_idx : buffer_idx + i]):
|
||||
sha_info["data"][sha_info["local"] + x[0]] = x[1]
|
||||
|
||||
count -= i
|
||||
buffer_idx += i
|
||||
|
||||
sha_info["local"] += i
|
||||
if sha_info["local"] == SHA_BLOCKSIZE:
|
||||
sha_transform(sha_info)
|
||||
sha_info["local"] = 0
|
||||
else:
|
||||
return
|
||||
|
||||
while count >= SHA_BLOCKSIZE:
|
||||
# copy buffer
|
||||
sha_info["data"] = list(buffer[buffer_idx : buffer_idx + SHA_BLOCKSIZE])
|
||||
count -= SHA_BLOCKSIZE
|
||||
buffer_idx += SHA_BLOCKSIZE
|
||||
sha_transform(sha_info)
|
||||
|
||||
# copy buffer
|
||||
pos = sha_info["local"]
|
||||
sha_info["data"][pos : pos + count] = list(buffer[buffer_idx : buffer_idx + count])
|
||||
sha_info["local"] = count
|
||||
|
||||
|
||||
def sha_final(sha_info):
|
||||
lo_bit_count = sha_info["count_lo"]
|
||||
hi_bit_count = sha_info["count_hi"]
|
||||
count = (lo_bit_count >> 3) & 0x3F
|
||||
sha_info["data"][count] = 0x80
|
||||
count += 1
|
||||
if count > SHA_BLOCKSIZE - 8:
|
||||
# zero the bytes in data after the count
|
||||
sha_info["data"] = sha_info["data"][:count] + ([0] * (SHA_BLOCKSIZE - count))
|
||||
sha_transform(sha_info)
|
||||
# zero bytes in data
|
||||
sha_info["data"] = [0] * SHA_BLOCKSIZE
|
||||
else:
|
||||
sha_info["data"] = sha_info["data"][:count] + ([0] * (SHA_BLOCKSIZE - count))
|
||||
|
||||
sha_info["data"][56] = (hi_bit_count >> 24) & 0xFF
|
||||
sha_info["data"][57] = (hi_bit_count >> 16) & 0xFF
|
||||
sha_info["data"][58] = (hi_bit_count >> 8) & 0xFF
|
||||
sha_info["data"][59] = (hi_bit_count >> 0) & 0xFF
|
||||
sha_info["data"][60] = (lo_bit_count >> 24) & 0xFF
|
||||
sha_info["data"][61] = (lo_bit_count >> 16) & 0xFF
|
||||
sha_info["data"][62] = (lo_bit_count >> 8) & 0xFF
|
||||
sha_info["data"][63] = (lo_bit_count >> 0) & 0xFF
|
||||
|
||||
sha_transform(sha_info)
|
||||
|
||||
dig = []
|
||||
for i in sha_info["digest"]:
|
||||
dig.extend([((i >> 24) & 0xFF), ((i >> 16) & 0xFF), ((i >> 8) & 0xFF), (i & 0xFF)])
|
||||
return bytes(dig)
|
||||
|
||||
|
||||
class sha256(object):
|
||||
digest_size = digestsize = SHA_DIGESTSIZE
|
||||
block_size = SHA_BLOCKSIZE
|
||||
|
||||
def __init__(self, s=None):
|
||||
self._sha = sha_init()
|
||||
if s:
|
||||
sha_update(self._sha, getbuf(s))
|
||||
|
||||
def update(self, s):
|
||||
sha_update(self._sha, getbuf(s))
|
||||
|
||||
def digest(self):
|
||||
return sha_final(self._sha.copy())[: self._sha["digestsize"]]
|
||||
|
||||
def hexdigest(self):
|
||||
return "".join(["%.2x" % i for i in self.digest()])
|
||||
|
||||
def copy(self):
|
||||
new = sha256()
|
||||
new._sha = self._sha.copy()
|
||||
return new
|
||||
|
||||
|
||||
class sha224(sha256):
|
||||
digest_size = digestsize = 28
|
||||
|
||||
def __init__(self, s=None):
|
||||
self._sha = sha224_init()
|
||||
if s:
|
||||
sha_update(self._sha, getbuf(s))
|
||||
|
||||
def copy(self):
|
||||
new = sha224()
|
||||
new._sha = self._sha.copy()
|
||||
return new
|
||||
|
||||
|
||||
def test():
|
||||
a_str = "just a test string"
|
||||
|
||||
assert (
|
||||
b"\xe3\xb0\xc4B\x98\xfc\x1c\x14\x9a\xfb\xf4\xc8\x99o\xb9$'\xaeA\xe4d\x9b\x93L\xa4\x95\x99\x1bxR\xb8U"
|
||||
== sha256().digest()
|
||||
)
|
||||
assert (
|
||||
"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" == sha256().hexdigest()
|
||||
)
|
||||
assert (
|
||||
"d7b553c6f09ac85d142415f857c5310f3bbbe7cdd787cce4b985acedd585266f"
|
||||
== sha256(a_str).hexdigest()
|
||||
)
|
||||
assert (
|
||||
"8113ebf33c97daa9998762aacafe750c7cefc2b2f173c90c59663a57fe626f21"
|
||||
== sha256(a_str * 7).hexdigest()
|
||||
)
|
||||
|
||||
s = sha256(a_str)
|
||||
s.update(a_str)
|
||||
assert "03d9963e05a094593190b6fc794cb1a3e1ac7d7883f0b5855268afeccc70d461" == s.hexdigest()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
test()
|
||||
|
|
@ -1 +0,0 @@
|
|||
from ._sha512 import sha384
|
||||
|
|
@ -1,519 +0,0 @@
|
|||
"""
|
||||
This code was Ported from CPython's sha512module.c
|
||||
"""
|
||||
|
||||
SHA_BLOCKSIZE = 128
|
||||
SHA_DIGESTSIZE = 64
|
||||
|
||||
|
||||
def new_shaobject():
|
||||
return {
|
||||
"digest": [0] * 8,
|
||||
"count_lo": 0,
|
||||
"count_hi": 0,
|
||||
"data": [0] * SHA_BLOCKSIZE,
|
||||
"local": 0,
|
||||
"digestsize": 0,
|
||||
}
|
||||
|
||||
|
||||
ROR64 = (
|
||||
lambda x, y: (((x & 0xFFFFFFFFFFFFFFFF) >> (y & 63)) | (x << (64 - (y & 63))))
|
||||
& 0xFFFFFFFFFFFFFFFF
|
||||
)
|
||||
Ch = lambda x, y, z: (z ^ (x & (y ^ z)))
|
||||
Maj = lambda x, y, z: (((x | y) & z) | (x & y))
|
||||
S = lambda x, n: ROR64(x, n)
|
||||
R = lambda x, n: (x & 0xFFFFFFFFFFFFFFFF) >> n
|
||||
Sigma0 = lambda x: (S(x, 28) ^ S(x, 34) ^ S(x, 39))
|
||||
Sigma1 = lambda x: (S(x, 14) ^ S(x, 18) ^ S(x, 41))
|
||||
Gamma0 = lambda x: (S(x, 1) ^ S(x, 8) ^ R(x, 7))
|
||||
Gamma1 = lambda x: (S(x, 19) ^ S(x, 61) ^ R(x, 6))
|
||||
|
||||
|
||||
def sha_transform(sha_info):
|
||||
W = []
|
||||
|
||||
d = sha_info["data"]
|
||||
for i in range(0, 16):
|
||||
W.append(
|
||||
(d[8 * i] << 56)
|
||||
+ (d[8 * i + 1] << 48)
|
||||
+ (d[8 * i + 2] << 40)
|
||||
+ (d[8 * i + 3] << 32)
|
||||
+ (d[8 * i + 4] << 24)
|
||||
+ (d[8 * i + 5] << 16)
|
||||
+ (d[8 * i + 6] << 8)
|
||||
+ d[8 * i + 7]
|
||||
)
|
||||
|
||||
for i in range(16, 80):
|
||||
W.append(
|
||||
(Gamma1(W[i - 2]) + W[i - 7] + Gamma0(W[i - 15]) + W[i - 16]) & 0xFFFFFFFFFFFFFFFF
|
||||
)
|
||||
|
||||
ss = sha_info["digest"][:]
|
||||
|
||||
def RND(a, b, c, d, e, f, g, h, i, ki):
|
||||
t0 = (h + Sigma1(e) + Ch(e, f, g) + ki + W[i]) & 0xFFFFFFFFFFFFFFFF
|
||||
t1 = (Sigma0(a) + Maj(a, b, c)) & 0xFFFFFFFFFFFFFFFF
|
||||
d = (d + t0) & 0xFFFFFFFFFFFFFFFF
|
||||
h = (t0 + t1) & 0xFFFFFFFFFFFFFFFF
|
||||
return d & 0xFFFFFFFFFFFFFFFF, h & 0xFFFFFFFFFFFFFFFF
|
||||
|
||||
ss[3], ss[7] = RND(
|
||||
ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 0, 0x428A2F98D728AE22
|
||||
)
|
||||
ss[2], ss[6] = RND(
|
||||
ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 1, 0x7137449123EF65CD
|
||||
)
|
||||
ss[1], ss[5] = RND(
|
||||
ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 2, 0xB5C0FBCFEC4D3B2F
|
||||
)
|
||||
ss[0], ss[4] = RND(
|
||||
ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 3, 0xE9B5DBA58189DBBC
|
||||
)
|
||||
ss[7], ss[3] = RND(
|
||||
ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 4, 0x3956C25BF348B538
|
||||
)
|
||||
ss[6], ss[2] = RND(
|
||||
ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 5, 0x59F111F1B605D019
|
||||
)
|
||||
ss[5], ss[1] = RND(
|
||||
ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 6, 0x923F82A4AF194F9B
|
||||
)
|
||||
ss[4], ss[0] = RND(
|
||||
ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 7, 0xAB1C5ED5DA6D8118
|
||||
)
|
||||
ss[3], ss[7] = RND(
|
||||
ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 8, 0xD807AA98A3030242
|
||||
)
|
||||
ss[2], ss[6] = RND(
|
||||
ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 9, 0x12835B0145706FBE
|
||||
)
|
||||
ss[1], ss[5] = RND(
|
||||
ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 10, 0x243185BE4EE4B28C
|
||||
)
|
||||
ss[0], ss[4] = RND(
|
||||
ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 11, 0x550C7DC3D5FFB4E2
|
||||
)
|
||||
ss[7], ss[3] = RND(
|
||||
ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 12, 0x72BE5D74F27B896F
|
||||
)
|
||||
ss[6], ss[2] = RND(
|
||||
ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 13, 0x80DEB1FE3B1696B1
|
||||
)
|
||||
ss[5], ss[1] = RND(
|
||||
ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 14, 0x9BDC06A725C71235
|
||||
)
|
||||
ss[4], ss[0] = RND(
|
||||
ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 15, 0xC19BF174CF692694
|
||||
)
|
||||
ss[3], ss[7] = RND(
|
||||
ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 16, 0xE49B69C19EF14AD2
|
||||
)
|
||||
ss[2], ss[6] = RND(
|
||||
ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 17, 0xEFBE4786384F25E3
|
||||
)
|
||||
ss[1], ss[5] = RND(
|
||||
ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 18, 0x0FC19DC68B8CD5B5
|
||||
)
|
||||
ss[0], ss[4] = RND(
|
||||
ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 19, 0x240CA1CC77AC9C65
|
||||
)
|
||||
ss[7], ss[3] = RND(
|
||||
ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 20, 0x2DE92C6F592B0275
|
||||
)
|
||||
ss[6], ss[2] = RND(
|
||||
ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 21, 0x4A7484AA6EA6E483
|
||||
)
|
||||
ss[5], ss[1] = RND(
|
||||
ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 22, 0x5CB0A9DCBD41FBD4
|
||||
)
|
||||
ss[4], ss[0] = RND(
|
||||
ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 23, 0x76F988DA831153B5
|
||||
)
|
||||
ss[3], ss[7] = RND(
|
||||
ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 24, 0x983E5152EE66DFAB
|
||||
)
|
||||
ss[2], ss[6] = RND(
|
||||
ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 25, 0xA831C66D2DB43210
|
||||
)
|
||||
ss[1], ss[5] = RND(
|
||||
ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 26, 0xB00327C898FB213F
|
||||
)
|
||||
ss[0], ss[4] = RND(
|
||||
ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 27, 0xBF597FC7BEEF0EE4
|
||||
)
|
||||
ss[7], ss[3] = RND(
|
||||
ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 28, 0xC6E00BF33DA88FC2
|
||||
)
|
||||
ss[6], ss[2] = RND(
|
||||
ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 29, 0xD5A79147930AA725
|
||||
)
|
||||
ss[5], ss[1] = RND(
|
||||
ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 30, 0x06CA6351E003826F
|
||||
)
|
||||
ss[4], ss[0] = RND(
|
||||
ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 31, 0x142929670A0E6E70
|
||||
)
|
||||
ss[3], ss[7] = RND(
|
||||
ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 32, 0x27B70A8546D22FFC
|
||||
)
|
||||
ss[2], ss[6] = RND(
|
||||
ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 33, 0x2E1B21385C26C926
|
||||
)
|
||||
ss[1], ss[5] = RND(
|
||||
ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 34, 0x4D2C6DFC5AC42AED
|
||||
)
|
||||
ss[0], ss[4] = RND(
|
||||
ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 35, 0x53380D139D95B3DF
|
||||
)
|
||||
ss[7], ss[3] = RND(
|
||||
ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 36, 0x650A73548BAF63DE
|
||||
)
|
||||
ss[6], ss[2] = RND(
|
||||
ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 37, 0x766A0ABB3C77B2A8
|
||||
)
|
||||
ss[5], ss[1] = RND(
|
||||
ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 38, 0x81C2C92E47EDAEE6
|
||||
)
|
||||
ss[4], ss[0] = RND(
|
||||
ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 39, 0x92722C851482353B
|
||||
)
|
||||
ss[3], ss[7] = RND(
|
||||
ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 40, 0xA2BFE8A14CF10364
|
||||
)
|
||||
ss[2], ss[6] = RND(
|
||||
ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 41, 0xA81A664BBC423001
|
||||
)
|
||||
ss[1], ss[5] = RND(
|
||||
ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 42, 0xC24B8B70D0F89791
|
||||
)
|
||||
ss[0], ss[4] = RND(
|
||||
ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 43, 0xC76C51A30654BE30
|
||||
)
|
||||
ss[7], ss[3] = RND(
|
||||
ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 44, 0xD192E819D6EF5218
|
||||
)
|
||||
ss[6], ss[2] = RND(
|
||||
ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 45, 0xD69906245565A910
|
||||
)
|
||||
ss[5], ss[1] = RND(
|
||||
ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 46, 0xF40E35855771202A
|
||||
)
|
||||
ss[4], ss[0] = RND(
|
||||
ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 47, 0x106AA07032BBD1B8
|
||||
)
|
||||
ss[3], ss[7] = RND(
|
||||
ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 48, 0x19A4C116B8D2D0C8
|
||||
)
|
||||
ss[2], ss[6] = RND(
|
||||
ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 49, 0x1E376C085141AB53
|
||||
)
|
||||
ss[1], ss[5] = RND(
|
||||
ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 50, 0x2748774CDF8EEB99
|
||||
)
|
||||
ss[0], ss[4] = RND(
|
||||
ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 51, 0x34B0BCB5E19B48A8
|
||||
)
|
||||
ss[7], ss[3] = RND(
|
||||
ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 52, 0x391C0CB3C5C95A63
|
||||
)
|
||||
ss[6], ss[2] = RND(
|
||||
ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 53, 0x4ED8AA4AE3418ACB
|
||||
)
|
||||
ss[5], ss[1] = RND(
|
||||
ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 54, 0x5B9CCA4F7763E373
|
||||
)
|
||||
ss[4], ss[0] = RND(
|
||||
ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 55, 0x682E6FF3D6B2B8A3
|
||||
)
|
||||
ss[3], ss[7] = RND(
|
||||
ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 56, 0x748F82EE5DEFB2FC
|
||||
)
|
||||
ss[2], ss[6] = RND(
|
||||
ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 57, 0x78A5636F43172F60
|
||||
)
|
||||
ss[1], ss[5] = RND(
|
||||
ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 58, 0x84C87814A1F0AB72
|
||||
)
|
||||
ss[0], ss[4] = RND(
|
||||
ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 59, 0x8CC702081A6439EC
|
||||
)
|
||||
ss[7], ss[3] = RND(
|
||||
ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 60, 0x90BEFFFA23631E28
|
||||
)
|
||||
ss[6], ss[2] = RND(
|
||||
ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 61, 0xA4506CEBDE82BDE9
|
||||
)
|
||||
ss[5], ss[1] = RND(
|
||||
ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 62, 0xBEF9A3F7B2C67915
|
||||
)
|
||||
ss[4], ss[0] = RND(
|
||||
ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 63, 0xC67178F2E372532B
|
||||
)
|
||||
ss[3], ss[7] = RND(
|
||||
ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 64, 0xCA273ECEEA26619C
|
||||
)
|
||||
ss[2], ss[6] = RND(
|
||||
ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 65, 0xD186B8C721C0C207
|
||||
)
|
||||
ss[1], ss[5] = RND(
|
||||
ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 66, 0xEADA7DD6CDE0EB1E
|
||||
)
|
||||
ss[0], ss[4] = RND(
|
||||
ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 67, 0xF57D4F7FEE6ED178
|
||||
)
|
||||
ss[7], ss[3] = RND(
|
||||
ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 68, 0x06F067AA72176FBA
|
||||
)
|
||||
ss[6], ss[2] = RND(
|
||||
ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 69, 0x0A637DC5A2C898A6
|
||||
)
|
||||
ss[5], ss[1] = RND(
|
||||
ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 70, 0x113F9804BEF90DAE
|
||||
)
|
||||
ss[4], ss[0] = RND(
|
||||
ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 71, 0x1B710B35131C471B
|
||||
)
|
||||
ss[3], ss[7] = RND(
|
||||
ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 72, 0x28DB77F523047D84
|
||||
)
|
||||
ss[2], ss[6] = RND(
|
||||
ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 73, 0x32CAAB7B40C72493
|
||||
)
|
||||
ss[1], ss[5] = RND(
|
||||
ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 74, 0x3C9EBE0A15C9BEBC
|
||||
)
|
||||
ss[0], ss[4] = RND(
|
||||
ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 75, 0x431D67C49C100D4C
|
||||
)
|
||||
ss[7], ss[3] = RND(
|
||||
ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 76, 0x4CC5D4BECB3E42B6
|
||||
)
|
||||
ss[6], ss[2] = RND(
|
||||
ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 77, 0x597F299CFC657E2A
|
||||
)
|
||||
ss[5], ss[1] = RND(
|
||||
ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 78, 0x5FCB6FAB3AD6FAEC
|
||||
)
|
||||
ss[4], ss[0] = RND(
|
||||
ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 79, 0x6C44198C4A475817
|
||||
)
|
||||
|
||||
dig = []
|
||||
for i, x in enumerate(sha_info["digest"]):
|
||||
dig.append((x + ss[i]) & 0xFFFFFFFFFFFFFFFF)
|
||||
sha_info["digest"] = dig
|
||||
|
||||
|
||||
def sha_init():
|
||||
sha_info = new_shaobject()
|
||||
sha_info["digest"] = [
|
||||
0x6A09E667F3BCC908,
|
||||
0xBB67AE8584CAA73B,
|
||||
0x3C6EF372FE94F82B,
|
||||
0xA54FF53A5F1D36F1,
|
||||
0x510E527FADE682D1,
|
||||
0x9B05688C2B3E6C1F,
|
||||
0x1F83D9ABFB41BD6B,
|
||||
0x5BE0CD19137E2179,
|
||||
]
|
||||
sha_info["count_lo"] = 0
|
||||
sha_info["count_hi"] = 0
|
||||
sha_info["local"] = 0
|
||||
sha_info["digestsize"] = 64
|
||||
return sha_info
|
||||
|
||||
|
||||
def sha384_init():
|
||||
sha_info = new_shaobject()
|
||||
sha_info["digest"] = [
|
||||
0xCBBB9D5DC1059ED8,
|
||||
0x629A292A367CD507,
|
||||
0x9159015A3070DD17,
|
||||
0x152FECD8F70E5939,
|
||||
0x67332667FFC00B31,
|
||||
0x8EB44A8768581511,
|
||||
0xDB0C2E0D64F98FA7,
|
||||
0x47B5481DBEFA4FA4,
|
||||
]
|
||||
sha_info["count_lo"] = 0
|
||||
sha_info["count_hi"] = 0
|
||||
sha_info["local"] = 0
|
||||
sha_info["digestsize"] = 48
|
||||
return sha_info
|
||||
|
||||
|
||||
def getbuf(s):
|
||||
if isinstance(s, str):
|
||||
return s.encode("ascii")
|
||||
else:
|
||||
return bytes(s)
|
||||
|
||||
|
||||
def sha_update(sha_info, buffer):
|
||||
if isinstance(buffer, str):
|
||||
raise TypeError("Unicode strings must be encoded before hashing")
|
||||
count = len(buffer)
|
||||
buffer_idx = 0
|
||||
clo = (sha_info["count_lo"] + (count << 3)) & 0xFFFFFFFF
|
||||
if clo < sha_info["count_lo"]:
|
||||
sha_info["count_hi"] += 1
|
||||
sha_info["count_lo"] = clo
|
||||
|
||||
sha_info["count_hi"] += count >> 29
|
||||
|
||||
if sha_info["local"]:
|
||||
i = SHA_BLOCKSIZE - sha_info["local"]
|
||||
if i > count:
|
||||
i = count
|
||||
|
||||
# copy buffer
|
||||
for x in enumerate(buffer[buffer_idx : buffer_idx + i]):
|
||||
sha_info["data"][sha_info["local"] + x[0]] = x[1]
|
||||
|
||||
count -= i
|
||||
buffer_idx += i
|
||||
|
||||
sha_info["local"] += i
|
||||
if sha_info["local"] == SHA_BLOCKSIZE:
|
||||
sha_transform(sha_info)
|
||||
sha_info["local"] = 0
|
||||
else:
|
||||
return
|
||||
|
||||
while count >= SHA_BLOCKSIZE:
|
||||
# copy buffer
|
||||
sha_info["data"] = list(buffer[buffer_idx : buffer_idx + SHA_BLOCKSIZE])
|
||||
count -= SHA_BLOCKSIZE
|
||||
buffer_idx += SHA_BLOCKSIZE
|
||||
sha_transform(sha_info)
|
||||
|
||||
# copy buffer
|
||||
pos = sha_info["local"]
|
||||
sha_info["data"][pos : pos + count] = list(buffer[buffer_idx : buffer_idx + count])
|
||||
sha_info["local"] = count
|
||||
|
||||
|
||||
def sha_final(sha_info):
|
||||
lo_bit_count = sha_info["count_lo"]
|
||||
hi_bit_count = sha_info["count_hi"]
|
||||
count = (lo_bit_count >> 3) & 0x7F
|
||||
sha_info["data"][count] = 0x80
|
||||
count += 1
|
||||
if count > SHA_BLOCKSIZE - 16:
|
||||
# zero the bytes in data after the count
|
||||
sha_info["data"] = sha_info["data"][:count] + ([0] * (SHA_BLOCKSIZE - count))
|
||||
sha_transform(sha_info)
|
||||
# zero bytes in data
|
||||
sha_info["data"] = [0] * SHA_BLOCKSIZE
|
||||
else:
|
||||
sha_info["data"] = sha_info["data"][:count] + ([0] * (SHA_BLOCKSIZE - count))
|
||||
|
||||
sha_info["data"][112] = 0
|
||||
sha_info["data"][113] = 0
|
||||
sha_info["data"][114] = 0
|
||||
sha_info["data"][115] = 0
|
||||
sha_info["data"][116] = 0
|
||||
sha_info["data"][117] = 0
|
||||
sha_info["data"][118] = 0
|
||||
sha_info["data"][119] = 0
|
||||
|
||||
sha_info["data"][120] = (hi_bit_count >> 24) & 0xFF
|
||||
sha_info["data"][121] = (hi_bit_count >> 16) & 0xFF
|
||||
sha_info["data"][122] = (hi_bit_count >> 8) & 0xFF
|
||||
sha_info["data"][123] = (hi_bit_count >> 0) & 0xFF
|
||||
sha_info["data"][124] = (lo_bit_count >> 24) & 0xFF
|
||||
sha_info["data"][125] = (lo_bit_count >> 16) & 0xFF
|
||||
sha_info["data"][126] = (lo_bit_count >> 8) & 0xFF
|
||||
sha_info["data"][127] = (lo_bit_count >> 0) & 0xFF
|
||||
|
||||
sha_transform(sha_info)
|
||||
|
||||
dig = []
|
||||
for i in sha_info["digest"]:
|
||||
dig.extend(
|
||||
[
|
||||
((i >> 56) & 0xFF),
|
||||
((i >> 48) & 0xFF),
|
||||
((i >> 40) & 0xFF),
|
||||
((i >> 32) & 0xFF),
|
||||
((i >> 24) & 0xFF),
|
||||
((i >> 16) & 0xFF),
|
||||
((i >> 8) & 0xFF),
|
||||
(i & 0xFF),
|
||||
]
|
||||
)
|
||||
return bytes(dig)
|
||||
|
||||
|
||||
class sha512(object):
|
||||
digest_size = digestsize = SHA_DIGESTSIZE
|
||||
block_size = SHA_BLOCKSIZE
|
||||
|
||||
def __init__(self, s=None):
|
||||
self._sha = sha_init()
|
||||
if s:
|
||||
sha_update(self._sha, getbuf(s))
|
||||
|
||||
def update(self, s):
|
||||
sha_update(self._sha, getbuf(s))
|
||||
|
||||
def digest(self):
|
||||
return sha_final(self._sha.copy())[: self._sha["digestsize"]]
|
||||
|
||||
def hexdigest(self):
|
||||
return "".join(["%.2x" % i for i in self.digest()])
|
||||
|
||||
def copy(self):
|
||||
new = sha512()
|
||||
new._sha = self._sha.copy()
|
||||
return new
|
||||
|
||||
|
||||
class sha384(sha512):
|
||||
digest_size = digestsize = 48
|
||||
|
||||
def __init__(self, s=None):
|
||||
self._sha = sha384_init()
|
||||
if s:
|
||||
sha_update(self._sha, getbuf(s))
|
||||
|
||||
def copy(self):
|
||||
new = sha384()
|
||||
new._sha = self._sha.copy()
|
||||
return new
|
||||
|
||||
|
||||
def test():
|
||||
a_str = "just a test string"
|
||||
|
||||
assert (
|
||||
sha512().digest()
|
||||
== b"\xcf\x83\xe15~\xef\xb8\xbd\xf1T(P\xd6m\x80\x07\xd6 \xe4\x05\x0bW\x15\xdc\x83\xf4\xa9!\xd3l\xe9\xceG\xd0\xd1<]\x85\xf2\xb0\xff\x83\x18\xd2\x87~\xec/c\xb91\xbdGAz\x81\xa582z\xf9'\xda>"
|
||||
)
|
||||
assert (
|
||||
sha512().hexdigest()
|
||||
== "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e"
|
||||
)
|
||||
assert (
|
||||
sha512(a_str).hexdigest()
|
||||
== "68be4c6664af867dd1d01c8d77e963d87d77b702400c8fabae355a41b8927a5a5533a7f1c28509bbd65c5f3ac716f33be271fbda0ca018b71a84708c9fae8a53"
|
||||
)
|
||||
assert (
|
||||
sha512(a_str * 7).hexdigest()
|
||||
== "3233acdbfcfff9bff9fc72401d31dbffa62bd24e9ec846f0578d647da73258d9f0879f7fde01fe2cc6516af3f343807fdef79e23d696c923d79931db46bf1819"
|
||||
)
|
||||
|
||||
s = sha512(a_str)
|
||||
s.update(a_str)
|
||||
assert (
|
||||
s.hexdigest()
|
||||
== "341aeb668730bbb48127d5531115f3c39d12cb9586a6ca770898398aff2411087cfe0b570689adf328cddeb1f00803acce6737a19f310b53bbdb0320828f75bb"
|
||||
)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
test()
|
||||
|
|
@ -1,3 +1,8 @@
|
|||
metadata(version="2.4.0-4")
|
||||
metadata(version="2.5.0")
|
||||
|
||||
package("hashlib")
|
||||
# This is a collection package that gets all hash functions. To save code and
|
||||
# memory size, prefer to install just the algorithm you need.
|
||||
require("hashlib-sha224")
|
||||
require("hashlib-sha256")
|
||||
require("hashlib-sha384")
|
||||
require("hashlib-sha512")
|
||||
|
|
|
|||
|
|
@ -1,35 +0,0 @@
|
|||
from hashlib._sha256 import test as sha256_test
|
||||
from hashlib._sha512 import test as sha512_test
|
||||
|
||||
|
||||
sha256_test()
|
||||
sha512_test()
|
||||
|
||||
|
||||
import hashlib
|
||||
|
||||
patterns = [
|
||||
(
|
||||
"sha224",
|
||||
b"1234",
|
||||
b"\x99\xfb/H\xc6\xafGa\xf9\x04\xfc\x85\xf9^\xb5a\x90\xe5\xd4\x0b\x1fD\xec:\x9c\x1f\xa3\x19",
|
||||
),
|
||||
(
|
||||
"sha256",
|
||||
b"1234",
|
||||
b"\x03\xacgB\x16\xf3\xe1\\v\x1e\xe1\xa5\xe2U\xf0g\x956#\xc8\xb3\x88\xb4E\x9e\x13\xf9x\xd7\xc8F\xf4",
|
||||
),
|
||||
(
|
||||
"sha384",
|
||||
b"1234",
|
||||
b"PO\x00\x8c\x8f\xcf\x8b.\xd5\xdf\xcd\xe7R\xfcTd\xab\x8b\xa0d!]\x9c[_\xc4\x86\xaf=\x9a\xb8\xc8\x1b\x14xQ\x80\xd2\xad|\xee\x1a\xb7\x92\xadDy\x8c",
|
||||
),
|
||||
(
|
||||
"sha512",
|
||||
b"1234",
|
||||
b"\xd4\x04U\x9f`.\xabo\xd6\x02\xacv\x80\xda\xcb\xfa\xad\xd1603^\x95\x1f\tz\xf3\x90\x0e\x9d\xe1v\xb6\xdb(Q/.\x00\x0b\x9d\x04\xfb\xa5\x13>\x8b\x1cn\x8d\xf5\x9d\xb3\xa8\xab\x9d`\xbeK\x97\xcc\x9e\x81\xdb",
|
||||
),
|
||||
]
|
||||
|
||||
for algo, input, output in patterns:
|
||||
assert hashlib.new(algo, input).digest() == output
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
import unittest
|
||||
import hashlib
|
||||
|
||||
|
||||
class TestNew(unittest.TestCase):
|
||||
def test_sha224(self):
|
||||
self.assertEqual(
|
||||
hashlib.new("sha224", b"1234").digest(),
|
||||
b"\x99\xfb/H\xc6\xafGa\xf9\x04\xfc\x85\xf9^\xb5a\x90\xe5\xd4\x0b\x1fD\xec:\x9c\x1f\xa3\x19",
|
||||
)
|
||||
|
||||
def test_sha256(self):
|
||||
self.assertEqual(
|
||||
hashlib.new("sha256", b"1234").digest(),
|
||||
b"\x03\xacgB\x16\xf3\xe1\\v\x1e\xe1\xa5\xe2U\xf0g\x956#\xc8\xb3\x88\xb4E\x9e\x13\xf9x\xd7\xc8F\xf4",
|
||||
)
|
||||
|
||||
def test_sha384(self):
|
||||
self.assertEqual(
|
||||
hashlib.new("sha384", b"1234").digest(),
|
||||
b"PO\x00\x8c\x8f\xcf\x8b.\xd5\xdf\xcd\xe7R\xfcTd\xab\x8b\xa0d!]\x9c[_\xc4\x86\xaf=\x9a\xb8\xc8\x1b\x14xQ\x80\xd2\xad|\xee\x1a\xb7\x92\xadDy\x8c",
|
||||
)
|
||||
|
||||
def test_sha512(self):
|
||||
self.assertEqual(
|
||||
hashlib.new("sha512", b"1234").digest(),
|
||||
b"\xd4\x04U\x9f`.\xabo\xd6\x02\xacv\x80\xda\xcb\xfa\xad\xd1603^\x95\x1f\tz\xf3\x90\x0e\x9d\xe1v\xb6\xdb(Q/.\x00\x0b\x9d\x04\xfb\xa5\x13>\x8b\x1cn\x8d\xf5\x9d\xb3\xa8\xab\x9d`\xbeK\x97\xcc\x9e\x81\xdb",
|
||||
)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
|
|
@ -0,0 +1,83 @@
|
|||
import unittest
|
||||
from hashlib import sha256
|
||||
|
||||
|
||||
class TestSha256(unittest.TestCase):
|
||||
a_str = b"just a test string"
|
||||
b_str = b"some other string for testing"
|
||||
c_str = b"nothing to see here"
|
||||
|
||||
def test_empty(self):
|
||||
self.assertEqual(
|
||||
b"\xe3\xb0\xc4B\x98\xfc\x1c\x14\x9a\xfb\xf4\xc8\x99o\xb9$'\xaeA\xe4d\x9b\x93L\xa4\x95\x99\x1bxR\xb8U",
|
||||
sha256().digest(),
|
||||
)
|
||||
|
||||
def test_empty_hex(self):
|
||||
self.assertEqual(
|
||||
"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
|
||||
sha256().hexdigest(),
|
||||
)
|
||||
|
||||
def test_str(self):
|
||||
self.assertEqual(
|
||||
b"\xd7\xb5S\xc6\xf0\x9a\xc8]\x14$\x15\xf8W\xc51\x0f;\xbb\xe7\xcd\xd7\x87\xcc\xe4\xb9\x85\xac\xed\xd5\x85&o",
|
||||
sha256(self.a_str).digest(),
|
||||
)
|
||||
self.assertEqual(
|
||||
b'|\x80Q\xb2\xa0u\xf0g\xe3\xc45\xce1p\xc6I\xb6r\x19J&\x8b\xdc\xa5"\x00?A\x90\xba\xbd,',
|
||||
sha256(self.b_str).digest(),
|
||||
)
|
||||
|
||||
def test_str_hex(self):
|
||||
self.assertEqual(
|
||||
"d7b553c6f09ac85d142415f857c5310f3bbbe7cdd787cce4b985acedd585266f",
|
||||
sha256(self.a_str).hexdigest(),
|
||||
)
|
||||
self.assertEqual(
|
||||
"7c8051b2a075f067e3c435ce3170c649b672194a268bdca522003f4190babd2c",
|
||||
sha256(self.b_str).hexdigest(),
|
||||
)
|
||||
|
||||
def test_long_str(self):
|
||||
self.assertEqual(
|
||||
"f1f1af5d66ba1789f8214354c0ed04856bbe43c01aa392c584ef1ec3dbf45482",
|
||||
sha256(self.a_str * 123).hexdigest(),
|
||||
)
|
||||
|
||||
def test_update(self):
|
||||
s = sha256(self.a_str)
|
||||
s.update(self.b_str)
|
||||
self.assertEqual(
|
||||
"fc7f204eb969ca3f10488731fa63910486adda7c2ae2ee2142e85414454c6d42", s.hexdigest()
|
||||
)
|
||||
|
||||
def test_repeat_final(self):
|
||||
s = sha256(self.a_str)
|
||||
s.update(self.b_str)
|
||||
self.assertEqual(
|
||||
"fc7f204eb969ca3f10488731fa63910486adda7c2ae2ee2142e85414454c6d42", s.hexdigest()
|
||||
)
|
||||
self.assertEqual(
|
||||
"fc7f204eb969ca3f10488731fa63910486adda7c2ae2ee2142e85414454c6d42", s.hexdigest()
|
||||
)
|
||||
s.update(self.c_str)
|
||||
self.assertEqual(
|
||||
"b707db9ae915b0f6f9a67ded8c9932999ee7e9dfb33513b084ea9384f5ffb082", s.hexdigest()
|
||||
)
|
||||
|
||||
def test_copy(self):
|
||||
s = sha256(self.a_str)
|
||||
s2 = s.copy()
|
||||
s.update(self.b_str)
|
||||
s2.update(self.c_str)
|
||||
self.assertEqual(
|
||||
"fc7f204eb969ca3f10488731fa63910486adda7c2ae2ee2142e85414454c6d42", s.hexdigest()
|
||||
)
|
||||
self.assertEqual(
|
||||
"6a340b2bd2b63f4a0f9bb7566c26831354ee6ed17d1187d3a53627181fcb2907", s2.hexdigest()
|
||||
)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
|
|
@ -0,0 +1,89 @@
|
|||
import unittest
|
||||
from hashlib import sha512
|
||||
|
||||
|
||||
class Testsha512(unittest.TestCase):
|
||||
a_str = b"just a test string"
|
||||
b_str = b"some other string for testing"
|
||||
c_str = b"nothing to see here"
|
||||
|
||||
def test_empty(self):
|
||||
self.assertEqual(
|
||||
b"\xcf\x83\xe15~\xef\xb8\xbd\xf1T(P\xd6m\x80\x07\xd6 \xe4\x05\x0bW\x15\xdc\x83\xf4\xa9!\xd3l\xe9\xceG\xd0\xd1<]\x85\xf2\xb0\xff\x83\x18\xd2\x87~\xec/c\xb91\xbdGAz\x81\xa582z\xf9'\xda>",
|
||||
sha512().digest(),
|
||||
)
|
||||
|
||||
def test_empty_hex(self):
|
||||
self.assertEqual(
|
||||
"cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e",
|
||||
sha512().hexdigest(),
|
||||
)
|
||||
|
||||
def test_str(self):
|
||||
self.assertEqual(
|
||||
b"h\xbeLfd\xaf\x86}\xd1\xd0\x1c\x8dw\xe9c\xd8}w\xb7\x02@\x0c\x8f\xab\xae5ZA\xb8\x92zZU3\xa7\xf1\xc2\x85\t\xbb\xd6\\_:\xc7\x16\xf3;\xe2q\xfb\xda\x0c\xa0\x18\xb7\x1a\x84p\x8c\x9f\xae\x8aS",
|
||||
sha512(self.a_str).digest(),
|
||||
)
|
||||
self.assertEqual(
|
||||
b"Tt\xd1\xf8\x1fh\x14\xba\x85\x1a\x84\x15\x9b(\x812\x8er\x8d\xdeN\xc0\xe2\xff\xbb\xcc$i\x18gh\x18\xc4\xcb?\xc0\xa0\nTl\x0f\x01J\x07eP\x19\x98\xd9\xebZ\xd2?\x1cj\xa8Q)!\x18\xab!!~",
|
||||
sha512(self.b_str).digest(),
|
||||
)
|
||||
|
||||
def test_str_hex(self):
|
||||
self.assertEqual(
|
||||
"68be4c6664af867dd1d01c8d77e963d87d77b702400c8fabae355a41b8927a5a5533a7f1c28509bbd65c5f3ac716f33be271fbda0ca018b71a84708c9fae8a53",
|
||||
sha512(self.a_str).hexdigest(),
|
||||
)
|
||||
self.assertEqual(
|
||||
"5474d1f81f6814ba851a84159b2881328e728dde4ec0e2ffbbcc246918676818c4cb3fc0a00a546c0f014a0765501998d9eb5ad23f1c6aa851292118ab21217e",
|
||||
sha512(self.b_str).hexdigest(),
|
||||
)
|
||||
|
||||
def test_long_str(self):
|
||||
self.assertEqual(
|
||||
"8ee045cd8faf900bb23d13754d65723404a224030af827897cde92a40f7a1202405bc3efe5466c7e4833e7a9a5b9f9278ebe4c968e7fa662d8addc17ba95cc73",
|
||||
sha512(self.a_str * 123).hexdigest(),
|
||||
)
|
||||
|
||||
def test_update(self):
|
||||
s = sha512(self.a_str)
|
||||
s.update(self.b_str)
|
||||
self.assertEqual(
|
||||
"3fa253e7b093d5bc7b31f613f03833a4d39341cf73642349a46f26b39b5d95c97bb4e16fc588bda81d5c7a2db62cfca5c4c71a142cf02fd78409bffe5e4f408c",
|
||||
s.hexdigest(),
|
||||
)
|
||||
|
||||
def test_repeat_final(self):
|
||||
s = sha512(self.a_str)
|
||||
s.update(self.b_str)
|
||||
self.assertEqual(
|
||||
"3fa253e7b093d5bc7b31f613f03833a4d39341cf73642349a46f26b39b5d95c97bb4e16fc588bda81d5c7a2db62cfca5c4c71a142cf02fd78409bffe5e4f408c",
|
||||
s.hexdigest(),
|
||||
)
|
||||
self.assertEqual(
|
||||
"3fa253e7b093d5bc7b31f613f03833a4d39341cf73642349a46f26b39b5d95c97bb4e16fc588bda81d5c7a2db62cfca5c4c71a142cf02fd78409bffe5e4f408c",
|
||||
s.hexdigest(),
|
||||
)
|
||||
s.update(self.c_str)
|
||||
self.assertEqual(
|
||||
"4b0827d5a28eeb2ebbeec270d7c775e78d5a76251753b8242327ffa2b1e5662a655be44bc09e41fcc0805bccd79cee13f4c41c40acff6fc1cf69b311d9b08f55",
|
||||
s.hexdigest(),
|
||||
)
|
||||
|
||||
def test_copy(self):
|
||||
s = sha512(self.a_str)
|
||||
s2 = s.copy()
|
||||
s.update(self.b_str)
|
||||
s2.update(self.c_str)
|
||||
self.assertEqual(
|
||||
"3fa253e7b093d5bc7b31f613f03833a4d39341cf73642349a46f26b39b5d95c97bb4e16fc588bda81d5c7a2db62cfca5c4c71a142cf02fd78409bffe5e4f408c",
|
||||
s.hexdigest(),
|
||||
)
|
||||
self.assertEqual(
|
||||
"2e4d68ec2d2836f24718b24442db027141fd2f7e06fb11c1460b013017feb0e74dea9d9415abe51b729ad86792bd5cd2cec9567d58a47a03785028376e7a5cc1",
|
||||
s2.hexdigest(),
|
||||
)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Ładowanie…
Reference in New Issue