ACIL FM

Nama	Ukuran	Aksi
__pycache__	-	Open
aead.py	6.1 MB	View DL Edit
backend.py	86.21 MB	View DL Edit
ciphers.py	10.15 MB	View DL Edit
cmac.py	2.78 MB	View DL Edit
decode_asn1.py	1.09 MB	View DL Edit
dh.py	10.95 MB	View DL Edit
dsa.py	10.46 MB	View DL Edit
ec.py	12.54 MB	View DL Edit
ed448.py	5.61 MB	View DL Edit
ed25519.py	5.65 MB	View DL Edit
encode_asn1.py	570 B	View DL Edit
hashes.py	3.03 MB	View DL Edit
hmac.py	2.87 MB	View DL Edit
poly1305.py	2.29 MB	View DL Edit
rsa.py	20.95 MB	View DL Edit
utils.py	2.39 MB	View DL Edit
x448.py	4.04 MB	View DL Edit
x509.py	1.42 MB	View DL Edit
x25519.py	4.51 MB	View DL Edit
__init__.py	271 B	View DL Edit

Edit file: /usr/lib64/python3.9/site-packages/cryptography/hazmat/backends/openssl/hashes.py

# This file is dual licensed under the terms of the Apache License, Version
# 2.0, and the BSD License. See the LICENSE file in the root of this repository
# for complete details.

from cryptography.exceptions import UnsupportedAlgorithm, _Reasons
from cryptography.hazmat.primitives import hashes

class _HashContext(hashes.HashContext):
    def __init__(self, backend, algorithm: hashes.HashAlgorithm, ctx=None):
        self._algorithm = algorithm

self._backend = backend

if ctx is None:
            ctx = self._backend._lib.EVP_MD_CTX_new()
            ctx = self._backend._ffi.gc(
                ctx, self._backend._lib.EVP_MD_CTX_free
            )
            evp_md = self._backend._evp_md_from_algorithm(algorithm)
            if evp_md == self._backend._ffi.NULL:
                raise UnsupportedAlgorithm(
                    "{} is not a supported hash on this backend.".format(
                        algorithm.name
                    ),
                    _Reasons.UNSUPPORTED_HASH,
                )
            res = self._backend._lib.EVP_DigestInit_ex(
                ctx, evp_md, self._backend._ffi.NULL
            )
            self._backend.openssl_assert(res != 0)

self._ctx = ctx

@property
    def algorithm(self) -> hashes.HashAlgorithm:
        return self._algorithm

def copy(self) -> "_HashContext":
        copied_ctx = self._backend._lib.EVP_MD_CTX_new()
        copied_ctx = self._backend._ffi.gc(
            copied_ctx, self._backend._lib.EVP_MD_CTX_free
        )
        res = self._backend._lib.EVP_MD_CTX_copy_ex(copied_ctx, self._ctx)
        self._backend.openssl_assert(res != 0)
        return _HashContext(self._backend, self.algorithm, ctx=copied_ctx)

def update(self, data: bytes) -> None:
        data_ptr = self._backend._ffi.from_buffer(data)
        res = self._backend._lib.EVP_DigestUpdate(
            self._ctx, data_ptr, len(data)
        )
        self._backend.openssl_assert(res != 0)

def finalize(self) -> bytes:
        if isinstance(self.algorithm, hashes.ExtendableOutputFunction):
            # extendable output functions use a different finalize
            return self._finalize_xof()
        else:
            buf = self._backend._ffi.new(
                "unsigned char[]", self._backend._lib.EVP_MAX_MD_SIZE
            )
            outlen = self._backend._ffi.new("unsigned int *")
            res = self._backend._lib.EVP_DigestFinal_ex(self._ctx, buf, outlen)
            self._backend.openssl_assert(res != 0)
            self._backend.openssl_assert(
                outlen[0] == self.algorithm.digest_size
            )
            return self._backend._ffi.buffer(buf)[: outlen[0]]

def _finalize_xof(self) -> bytes:
        buf = self._backend._ffi.new(
            "unsigned char[]", self.algorithm.digest_size
        )
        res = self._backend._lib.EVP_DigestFinalXOF(
            self._ctx, buf, self.algorithm.digest_size
        )
        self._backend.openssl_assert(res != 0)
        return self._backend._ffi.buffer(buf)[: self.algorithm.digest_size]

Batal