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: KangarooTwelve.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._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.Util.py3compat import bchr

from .keccak import _raw_keccak_lib

def _length_encode(x):
    if x == 0:
        return b'\x00'

S = long_to_bytes(x)
    return S + bchr(len(S))

# Possible states for a KangarooTwelve instance, which depend on the amount of data processed so far.
SHORT_MSG = 1       # Still within the first 8192 bytes, but it is not certain we will exceed them.
LONG_MSG_S0 = 2     # Still within the first 8192 bytes, and it is certain we will exceed them.
LONG_MSG_SX = 3     # Beyond the first 8192 bytes.
SQUEEZING = 4       # No more data to process.

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

def __init__(self, data, custom):

if custom == None:
            custom = b''

self._custom = custom + _length_encode(len(custom))
        self._state = SHORT_MSG
        self._padding = None        # Final padding is only decided in read()

# Internal hash that consumes FinalNode
        self._hash1 = self._create_keccak()
        self._length1 = 0

# Internal hash that produces CV_i (reset each time)
        self._hash2 = None
        self._length2 = 0

# Incremented by one for each 8192-byte block
        self._ctr = 0

if data:
            self.update(data)

def _create_keccak(self):
        state = VoidPointer()
        result = _raw_keccak_lib.keccak_init(state.address_of(),
                                             c_size_t(32),  # 32 bytes of capacity (256 bits)
                                             c_ubyte(12))   # Reduced number of rounds
        if result:
            raise ValueError("Error %d while instantiating KangarooTwelve"
                             % result)
        return SmartPointer(state.get(), _raw_keccak_lib.keccak_destroy)

def _update(self, data, hash_obj):
        result = _raw_keccak_lib.keccak_absorb(hash_obj.get(),
                                               c_uint8_ptr(data),
                                               c_size_t(len(data)))
        if result:
            raise ValueError("Error %d while updating KangarooTwelve state"
                             % result)

def _squeeze(self, hash_obj, length, padding):
        bfr = create_string_buffer(length)
        result = _raw_keccak_lib.keccak_squeeze(hash_obj.get(),
                                                bfr,
                                                c_size_t(length),
                                                c_ubyte(padding))
        if result:
            raise ValueError("Error %d while extracting from KangarooTwelve"
                             % result)

return get_raw_buffer(bfr)

def _reset(self, hash_obj):
        result = _raw_keccak_lib.keccak_reset(hash_obj.get())
        if result:
            raise ValueError("Error %d while resetting KangarooTwelve state"
                             % result)

def update(self, data):
        """Hash the next piece of data.

.. note::
            For better performance, submit chunks with a length multiple of 8192 bytes.

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

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

if self._state == SHORT_MSG:
            next_length = self._length1 + len(data)

if next_length + len(self._custom) <= 8192:
                self._length1 = next_length
                self._update(data, self._hash1)
                return self

# Switch to tree hashing
            self._state = LONG_MSG_S0

if self._state == LONG_MSG_S0:
            data_mem = memoryview(data)
            assert(self._length1 < 8192)
            dtc = min(len(data), 8192 - self._length1)
            self._update(data_mem[:dtc], self._hash1)
            self._length1 += dtc

if self._length1 < 8192:
                return self

# Finish hashing S_0 and start S_1
            assert(self._length1 == 8192)

divider = b'\x03' + b'\x00' * 7
            self._update(divider, self._hash1)
            self._length1 += 8

self._hash2 = self._create_keccak()
            self._length2 = 0
            self._ctr = 1

self._state = LONG_MSG_SX
            return self.update(data_mem[dtc:])

# LONG_MSG_SX
        assert(self._state == LONG_MSG_SX)
        index = 0
        len_data = len(data)

# All iteractions could actually run in parallel
        data_mem = memoryview(data)
        while index < len_data:

new_index = min(index + 8192 - self._length2, len_data)
            self._update(data_mem[index:new_index], self._hash2)
            self._length2 += new_index - index
            index = new_index

if self._length2 == 8192:
                cv_i = self._squeeze(self._hash2, 32, 0x0B)
                self._update(cv_i, self._hash1)
                self._length1 += 32
                self._reset(self._hash2)
                self._length2 = 0
                self._ctr += 1

return self

def read(self, length):
        """
        Produce more bytes of the digest.

.. 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
        """

custom_was_consumed = False

if self._state == SHORT_MSG:
            self._update(self._custom, self._hash1)
            self._padding = 0x07
            self._state = SQUEEZING

if self._state == LONG_MSG_S0:
            self.update(self._custom)
            custom_was_consumed = True
            assert(self._state == LONG_MSG_SX)

if self._state == LONG_MSG_SX:
            if not custom_was_consumed:
                self.update(self._custom)

# Is there still some leftover data in hash2?
            if self._length2 > 0:
                cv_i = self._squeeze(self._hash2, 32, 0x0B)
                self._update(cv_i, self._hash1)
                self._length1 += 32
                self._reset(self._hash2)
                self._length2 = 0
                self._ctr += 1

trailer = _length_encode(self._ctr - 1) + b'\xFF\xFF'
            self._update(trailer, self._hash1)

self._padding = 0x06
            self._state = SQUEEZING

return self._squeeze(self._hash1, length, self._padding)

def new(self, data=None, custom=b''):
        return type(self)(data, custom)

def new(data=None, custom=None):
    """Return a fresh instance of a KangarooTwelve 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 byte string.

:Return: A :class:`K12_XOF` object
    """

return K12_XOF(data, custom)

X7ROOT File Manager

Editing: KangarooTwelve.py

Upload File

Create Folder