Update micropython libraries
This commit is contained in:
Miguel Grinberg
@@ -152,10 +152,8 @@ Maintaing Secure User Sessions
|
||||
|
||||
* - Required external dependencies
|
||||
- | CPython: `PyJWT <https://pyjwt.readthedocs.io/>`_
|
||||
| MicroPython: `jwt.py <https://github.com/miguelgrinberg/microdot/blob/main/libs/micropython/jwt.py>`_,
|
||||
`hmac <https://github.com/micropython/micropython-lib/blob/master/python-stdlib/hmac/hmac.py>`_,
|
||||
`hashlib <https://github.com/miguelgrinberg/microdot/tree/main/libs/micropython/hashlib>`_,
|
||||
`warnings <https://github.com/micropython/micropython-lib/blob/master/python-stdlib/warnings/warnings.py>`_
|
||||
| MicroPython: `jwt.py <https://github.com/micropython/micropython-lib/blob/master/python-ecosys/pyjwt/jwt.py>`_,
|
||||
`hmac <https://github.com/micropython/micropython-lib/blob/master/python-stdlib/hmac/hmac.py>`_
|
||||
|
||||
* - Examples
|
||||
- | `login.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/login.py>`_
|
||||
|
||||
@@ -1,25 +0,0 @@
|
||||
try:
|
||||
import uhashlib
|
||||
except ImportError:
|
||||
uhashlib = None
|
||||
|
||||
|
||||
def init():
|
||||
for i in ("sha1", "sha224", "sha256", "sha384", "sha512"):
|
||||
try:
|
||||
c = __import__("_" + i, None, None, (), 1)
|
||||
except ImportError:
|
||||
c = uhashlib
|
||||
c = getattr(c, i, None)
|
||||
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,152 +1,87 @@
|
||||
"""HMAC (Keyed-Hashing for Message Authentication) Python module.
|
||||
Implements the HMAC algorithm as described by RFC 2104.
|
||||
"""
|
||||
|
||||
import warnings as _warnings
|
||||
|
||||
# from _operator import _compare_digest as compare_digest
|
||||
import hashlib as _hashlib
|
||||
|
||||
PendingDeprecationWarning = None
|
||||
RuntimeWarning = None
|
||||
|
||||
trans_5C = bytes((x ^ 0x5C) for x in range(256))
|
||||
trans_36 = bytes((x ^ 0x36) for x in range(256))
|
||||
|
||||
|
||||
def translate(d, t):
|
||||
return bytes(t[x] for x in d)
|
||||
|
||||
|
||||
# The size of the digests returned by HMAC depends on the underlying
|
||||
# hashing module used. Use digest_size from the instance of HMAC instead.
|
||||
digest_size = None
|
||||
# Implements the hmac module from the Python standard library.
|
||||
|
||||
|
||||
class HMAC:
|
||||
"""RFC 2104 HMAC class. Also complies with RFC 4231.
|
||||
This supports the API for Cryptographic Hash Functions (PEP 247).
|
||||
"""
|
||||
|
||||
blocksize = 64 # 512-bit HMAC; can be changed in subclasses.
|
||||
|
||||
def __init__(self, key, msg=None, digestmod=None):
|
||||
"""Create a new HMAC object.
|
||||
key: key for the keyed hash object.
|
||||
msg: Initial input for the hash, if provided.
|
||||
digestmod: A module supporting PEP 247. *OR*
|
||||
A hashlib constructor returning a new hash object. *OR*
|
||||
A hash name suitable for hashlib.new().
|
||||
Defaults to hashlib.md5.
|
||||
Implicit default to hashlib.md5 is deprecated and will be
|
||||
removed in Python 3.6.
|
||||
Note: key and msg must be a bytes or bytearray objects.
|
||||
"""
|
||||
|
||||
if not isinstance(key, (bytes, bytearray)):
|
||||
raise TypeError("key: expected bytes or bytearray, but got %r" % type(key).__name__)
|
||||
raise TypeError("key: expected bytes/bytearray")
|
||||
|
||||
import hashlib
|
||||
|
||||
if digestmod is None:
|
||||
_warnings.warn(
|
||||
"HMAC() without an explicit digestmod argument " "is deprecated.",
|
||||
PendingDeprecationWarning,
|
||||
2,
|
||||
)
|
||||
digestmod = _hashlib.md5
|
||||
# TODO: Default hash algorithm is now deprecated.
|
||||
digestmod = hashlib.md5
|
||||
|
||||
if callable(digestmod):
|
||||
self.digest_cons = digestmod
|
||||
# A hashlib constructor returning a new hash object.
|
||||
make_hash = digestmod # A
|
||||
elif isinstance(digestmod, str):
|
||||
self.digest_cons = lambda d=b"": _hashlib.new(digestmod, d)
|
||||
# A hash name suitable for hashlib.new().
|
||||
make_hash = lambda d=b"": hashlib.new(digestmod, d) # B
|
||||
else:
|
||||
self.digest_cons = lambda d=b"": digestmod.new(d)
|
||||
# A module supporting PEP 247.
|
||||
make_hash = digestmod.new # C
|
||||
|
||||
self.outer = self.digest_cons()
|
||||
self.inner = self.digest_cons()
|
||||
self.digest_size = self.inner.digest_size
|
||||
self._outer = make_hash()
|
||||
self._inner = make_hash()
|
||||
|
||||
if hasattr(self.inner, "block_size"):
|
||||
blocksize = self.inner.block_size
|
||||
if blocksize < 16:
|
||||
_warnings.warn(
|
||||
"block_size of %d seems too small; using our "
|
||||
"default of %d." % (blocksize, self.blocksize),
|
||||
RuntimeWarning,
|
||||
2,
|
||||
)
|
||||
blocksize = self.blocksize
|
||||
else:
|
||||
_warnings.warn(
|
||||
"No block_size attribute on given digest object; "
|
||||
"Assuming %d." % (self.blocksize),
|
||||
RuntimeWarning,
|
||||
2,
|
||||
)
|
||||
blocksize = self.blocksize
|
||||
self.digest_size = getattr(self._inner, "digest_size", None)
|
||||
# If the provided hash doesn't support block_size (e.g. built-in
|
||||
# hashlib), 64 is the correct default for all built-in hash
|
||||
# functions (md5, sha1, sha256).
|
||||
self.block_size = getattr(self._inner, "block_size", 64)
|
||||
|
||||
# self.blocksize is the default blocksize. self.block_size is
|
||||
# effective block size as well as the public API attribute.
|
||||
self.block_size = blocksize
|
||||
# Truncate to digest_size if greater than block_size.
|
||||
if len(key) > self.block_size:
|
||||
key = make_hash(key).digest()
|
||||
|
||||
if len(key) > blocksize:
|
||||
key = self.digest_cons(key).digest()
|
||||
# Pad to block size.
|
||||
key = key + bytes(self.block_size - len(key))
|
||||
|
||||
self._outer.update(bytes(x ^ 0x5C for x in key))
|
||||
self._inner.update(bytes(x ^ 0x36 for x in key))
|
||||
|
||||
key = key + bytes(blocksize - len(key))
|
||||
self.outer.update(translate(key, trans_5C))
|
||||
self.inner.update(translate(key, trans_36))
|
||||
if msg is not None:
|
||||
self.update(msg)
|
||||
|
||||
@property
|
||||
def name(self):
|
||||
return "hmac-" + self.inner.name
|
||||
return "hmac-" + getattr(self._inner, "name", type(self._inner).__name__)
|
||||
|
||||
def update(self, msg):
|
||||
"""Update this hashing object with the string msg."""
|
||||
self.inner.update(msg)
|
||||
self._inner.update(msg)
|
||||
|
||||
def copy(self):
|
||||
"""Return a separate copy of this hashing object.
|
||||
An update to this copy won't affect the original object.
|
||||
"""
|
||||
if not hasattr(self._inner, "copy"):
|
||||
# Not supported for built-in hash functions.
|
||||
raise NotImplementedError()
|
||||
# Call __new__ directly to avoid the expensive __init__.
|
||||
other = self.__class__.__new__(self.__class__)
|
||||
other.digest_cons = self.digest_cons
|
||||
other.block_size = self.block_size
|
||||
other.digest_size = self.digest_size
|
||||
other.inner = self.inner.copy()
|
||||
other.outer = self.outer.copy()
|
||||
other._inner = self._inner.copy()
|
||||
other._outer = self._outer.copy()
|
||||
return other
|
||||
|
||||
def _current(self):
|
||||
"""Return a hash object for the current state.
|
||||
To be used only internally with digest() and hexdigest().
|
||||
"""
|
||||
h = self.outer.copy()
|
||||
h.update(self.inner.digest())
|
||||
h = self._outer
|
||||
if hasattr(h, "copy"):
|
||||
# built-in hash functions don't support this, and as a result,
|
||||
# digest() will finalise the hmac and further calls to
|
||||
# update/digest will fail.
|
||||
h = h.copy()
|
||||
h.update(self._inner.digest())
|
||||
return h
|
||||
|
||||
def digest(self):
|
||||
"""Return the hash value of this hashing object.
|
||||
This returns a string containing 8-bit data. The object is
|
||||
not altered in any way by this function; you can continue
|
||||
updating the object after calling this function.
|
||||
"""
|
||||
h = self._current()
|
||||
return h.digest()
|
||||
|
||||
def hexdigest(self):
|
||||
"""Like digest(), but returns a string of hexadecimal digits instead."""
|
||||
h = self._current()
|
||||
return h.hexdigest()
|
||||
import binascii
|
||||
|
||||
return str(binascii.hexlify(self.digest()), "utf-8")
|
||||
|
||||
|
||||
def new(key, msg=None, digestmod=None):
|
||||
"""Create a new hashing object and return it.
|
||||
key: The starting key for the hash.
|
||||
msg: if available, will immediately be hashed into the object's starting
|
||||
state.
|
||||
You can now feed arbitrary strings into the object using its update()
|
||||
method, and can ask for the hash value at any time by calling its digest()
|
||||
method.
|
||||
"""
|
||||
return HMAC(key, msg, digestmod)
|
||||
|
||||
@@ -4,7 +4,6 @@ import hmac
|
||||
import json
|
||||
from time import time
|
||||
|
||||
|
||||
def _to_b64url(data):
|
||||
return (
|
||||
binascii.b2a_base64(data)
|
||||
@@ -32,13 +31,13 @@ class exceptions:
|
||||
class InvalidSignatureError(PyJWTError):
|
||||
pass
|
||||
|
||||
class ExpiredTokenError(PyJWTError):
|
||||
class ExpiredSignatureError(PyJWTError):
|
||||
pass
|
||||
|
||||
|
||||
def encode(payload, key, algorithm="HS256"):
|
||||
if algorithm != "HS256":
|
||||
raise exceptions.InvalidAlgorithmError()
|
||||
raise exceptions.InvalidAlgorithmError
|
||||
|
||||
if isinstance(key, str):
|
||||
key = key.encode()
|
||||
@@ -50,30 +49,30 @@ def encode(payload, key, algorithm="HS256"):
|
||||
|
||||
def decode(token, key, algorithms=["HS256"]):
|
||||
if "HS256" not in algorithms:
|
||||
raise exceptions.InvalidAlgorithmError()
|
||||
raise exceptions.InvalidAlgorithmError
|
||||
|
||||
parts = token.encode().split(b".")
|
||||
if len(parts) != 3:
|
||||
raise exceptions.InvalidTokenError()
|
||||
raise exceptions.InvalidTokenError
|
||||
|
||||
try:
|
||||
header = json.loads(_from_b64url(parts[0]).decode())
|
||||
payload = json.loads(_from_b64url(parts[1]).decode())
|
||||
signature = _from_b64url(parts[2])
|
||||
except Exception:
|
||||
raise exceptions.InvalidTokenError()
|
||||
raise exceptions.InvalidTokenError
|
||||
|
||||
if header["alg"] not in algorithms or header["alg"] != "HS256":
|
||||
raise exceptions.InvalidAlgorithmError()
|
||||
raise exceptions.InvalidAlgorithmError
|
||||
|
||||
if isinstance(key, str):
|
||||
key = key.encode()
|
||||
calculated_signature = hmac.new(key, parts[0] + b"." + parts[1], hashlib.sha256).digest()
|
||||
if signature != calculated_signature:
|
||||
raise exceptions.InvalidSignatureError()
|
||||
raise exceptions.InvalidSignatureError
|
||||
|
||||
if "exp" in payload:
|
||||
if time() > payload["exp"]:
|
||||
raise exceptions.ExpiredTokenError()
|
||||
raise exceptions.ExpiredSignatureError
|
||||
|
||||
return payload
|
||||
|
||||
@@ -1,2 +0,0 @@
|
||||
def warn(msg, cat=None, stacklevel=1):
|
||||
print("%s: %s" % ("Warning" if cat is None else cat.__name__, msg))
|
||||
Reference in New Issue
Block a user