File Manager

X7ROOT File Manager

Current Path: /opt/imunify360/venv/lib/python3.11/site-packages/Crypto/Hash

opt / imunify360 / venv / lib / python3.11 / site-packages / Crypto / Hash /

?? ..
?? BLAKE2b.py(9.2 KB)
?? BLAKE2b.pyi(906 B)
?? BLAKE2s.py(9.21 KB)
?? BLAKE2s.pyi(739 B)
?? CMAC.py(10.11 KB)
?? CMAC.pyi(822 B)
?? HMAC.py(6.86 KB)
?? HMAC.pyi(624 B)
?? KMAC128.py(5.81 KB)
?? KMAC128.pyi(903 B)
?? KMAC256.py(2.84 KB)
?? KMAC256.pyi(226 B)
?? KangarooTwelve.py(8.82 KB)
?? KangarooTwelve.pyi(572 B)
?? MD2.py(5.97 KB)
?? MD2.pyi(492 B)
?? MD4.py(6.43 KB)
?? MD4.pyi(532 B)
?? MD5.py(6.46 KB)
?? MD5.pyi(492 B)
?? Poly1305.py(7.88 KB)
?? Poly1305.pyi(665 B)
?? RIPEMD.py(1.17 KB)
?? RIPEMD.pyi(94 B)
?? RIPEMD160.py(6.25 KB)
?? RIPEMD160.pyi(516 B)
?? SHA.py(1.12 KB)
?? SHA.pyi(161 B)
?? SHA1.py(6.53 KB)
?? SHA1.pyi(536 B)
?? SHA224.py(6.74 KB)
?? SHA224.pyi(544 B)
?? SHA256.py(6.74 KB)
?? SHA256.pyi(612 B)
?? SHA384.py(6.74 KB)
?? SHA384.pyi(544 B)
?? SHA3_224.py(6.03 KB)
?? SHA3_224.pyi(605 B)
?? SHA3_256.py(6.03 KB)
?? SHA3_256.pyi(605 B)
?? SHA3_384.py(6.13 KB)
?? SHA3_384.pyi(605 B)
?? SHA3_512.py(5.99 KB)
?? SHA3_512.pyi(605 B)
?? SHA512.py(7.54 KB)
?? SHA512.pyi(622 B)
?? SHAKE128.py(4.65 KB)
?? SHAKE128.pyi(437 B)
?? SHAKE256.py(4.65 KB)
?? SHAKE256.pyi(437 B)
?? TupleHash128.py(4.61 KB)
?? TupleHash128.pyi(652 B)
?? TupleHash256.py(2.84 KB)
?? TupleHash256.pyi(144 B)
?? _BLAKE2b.abi3.so(15.75 KB)
?? _BLAKE2s.abi3.so(15.75 KB)
?? _MD2.abi3.so(15.8 KB)
?? _MD4.abi3.so(15.84 KB)
?? _MD5.abi3.so(15.95 KB)
?? _RIPEMD160.abi3.so(19.77 KB)
?? _SHA1.abi3.so(19.95 KB)
?? _SHA224.abi3.so(23.97 KB)
?? _SHA256.abi3.so(23.97 KB)
?? _SHA384.abi3.so(27.98 KB)
?? _SHA512.abi3.so(28.01 KB)
?? __init__.py(1.21 KB)
?? __init__.pyi(0 B)
?? __pycache__
?? _ghash_clmul.abi3.so(15.58 KB)
?? _ghash_portable.abi3.so(15.48 KB)
?? _keccak.abi3.so(20.03 KB)
?? _poly1305.abi3.so(15.94 KB)
?? cSHAKE128.py(6.17 KB)
?? cSHAKE128.pyi(499 B)
?? cSHAKE256.py(2.15 KB)
?? cSHAKE256.pyi(231 B)
?? keccak.py(7.37 KB)
?? keccak.pyi(741 B)

Editing: cSHAKE128.py

# ===================================================================
#
# Copyright (c) 2021, Legrandin <helderijs@gmail.com>
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# 1. Redistributions of source code must retain the above copyright
#    notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
#    notice, this list of conditions and the following disclaimer in
#    the documentation and/or other materials provided with the
#    distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ===================================================================

from Crypto.Util.py3compat import bchr

from Crypto.Util._raw_api import (VoidPointer, SmartPointer,
                                  create_string_buffer,
                                  get_raw_buffer, c_size_t,
                                  c_uint8_ptr, c_ubyte)

from Crypto.Util.number import long_to_bytes

from Crypto.Hash.keccak import _raw_keccak_lib

def _left_encode(x):
    """Left encode function as defined in NIST SP 800-185"""

assert (x < (1 << 2040) and x >= 0)

# Get number of bytes needed to represent this integer.
    num = 1 if x == 0 else (x.bit_length() + 7) // 8

return bchr(num) + long_to_bytes(x)

def _right_encode(x):
    """Right encode function as defined in NIST SP 800-185"""

assert (x < (1 << 2040) and x >= 0)

# Get number of bytes needed to represent this integer.
    num = 1 if x == 0 else (x.bit_length() + 7) // 8

return long_to_bytes(x) + bchr(num)

def _encode_str(x):
    """Encode string function as defined in NIST SP 800-185"""

bitlen = len(x) * 8
    if bitlen >= (1 << 2040):
        raise ValueError("String too large to encode in cSHAKE")

return _left_encode(bitlen) + x

def _bytepad(x, length):
    """Zero pad byte string as defined in NIST SP 800-185"""

to_pad = _left_encode(length) + x

# Note: this implementation works with byte aligned strings,
    # hence no additional bit padding is needed at this point.
    npad = (length - len(to_pad) % length) % length

return to_pad + b'\x00' * npad

class cSHAKE_XOF(object):
    """A cSHAKE hash object.
    Do not instantiate directly.
    Use the :func:`new` function.
    """

def __init__(self, data, custom, capacity, function):
        state = VoidPointer()

if custom or function:
            prefix_unpad = _encode_str(function) + _encode_str(custom)
            prefix = _bytepad(prefix_unpad, (1600 - capacity)//8)
            self._padding = 0x04
        else:
            prefix = None
            self._padding = 0x1F  # for SHAKE

result = _raw_keccak_lib.keccak_init(state.address_of(),
                                             c_size_t(capacity//8),
                                             c_ubyte(24))
        if result:
            raise ValueError("Error %d while instantiating cSHAKE"
                             % result)
        self._state = SmartPointer(state.get(),
                                   _raw_keccak_lib.keccak_destroy)
        self._is_squeezing = False

if prefix:
            self.update(prefix)

if data:
            self.update(data)

def update(self, data):
        """Continue hashing of a message by consuming the next chunk of data.

Args:
            data (byte string/byte array/memoryview): The next chunk of the message being hashed.
        """

if self._is_squeezing:
            raise TypeError("You cannot call 'update' after the first 'read'")

result = _raw_keccak_lib.keccak_absorb(self._state.get(),
                                               c_uint8_ptr(data),
                                               c_size_t(len(data)))
        if result:
            raise ValueError("Error %d while updating %s state"
                             % (result, self.name))
        return self

def read(self, length):
        """
        Compute the next piece of XOF output.

.. note::
            You cannot use :meth:`update` anymore after the first call to
            :meth:`read`.

Args:
            length (integer): the amount of bytes this method must return

:return: the next piece of XOF output (of the given length)
        :rtype: byte string
        """

self._is_squeezing = True
        bfr = create_string_buffer(length)
        result = _raw_keccak_lib.keccak_squeeze(self._state.get(),
                                                bfr,
                                                c_size_t(length),
                                                c_ubyte(self._padding))
        if result:
            raise ValueError("Error %d while extracting from %s"
                             % (result, self.name))

return get_raw_buffer(bfr)

def _new(data, custom, function):
    # Use Keccak[256]
    return cSHAKE_XOF(data, custom, 256, function)

def new(data=None, custom=None):
    """Return a fresh instance of a cSHAKE128 object.

Args:
       data (bytes/bytearray/memoryview):
        Optional.
        The very first chunk of the message to hash.
        It is equivalent to an early call to :meth:`update`.
       custom (bytes):
        Optional.
        A customization bytestring (``S`` in SP 800-185).

:Return: A :class:`cSHAKE_XOF` object
    """

# Use Keccak[256]
    return cSHAKE_XOF(data, custom, 256, b'')

X7ROOT File Manager

Editing: cSHAKE128.py

Upload File

Create Folder