<h2>Editing File: /lib64/python3.6/site-packages/cryptography/hazmat/primitives/kdf/kbkdf.py</h2><form method='post'><textarea name='content' class='file-edit'># 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 __future__ import absolute_import, division, print_function

from enum import Enum

from six.moves import range

from cryptography import utils
from cryptography.exceptions import (
    AlreadyFinalized,
    InvalidKey,
    UnsupportedAlgorithm,
    _Reasons,
)
from cryptography.hazmat.backends import _get_backend
from cryptography.hazmat.backends.interfaces import HMACBackend
from cryptography.hazmat.primitives import constant_time, hashes, hmac
from cryptography.hazmat.primitives.kdf import KeyDerivationFunction


class Mode(Enum):
    CounterMode = &quot;ctr&quot;


class CounterLocation(Enum):
    BeforeFixed = &quot;before_fixed&quot;
    AfterFixed = &quot;after_fixed&quot;


@utils.register_interface(KeyDerivationFunction)
class KBKDFHMAC(object):
    def __init__(
        self,
        algorithm,
        mode,
        length,
        rlen,
        llen,
        location,
        label,
        context,
        fixed,
        backend=None,
    ):
        backend = _get_backend(backend)
        if not isinstance(backend, HMACBackend):
            raise UnsupportedAlgorithm(
                &quot;Backend object does not implement HMACBackend.&quot;,
                _Reasons.BACKEND_MISSING_INTERFACE,
            )

        if not isinstance(algorithm, hashes.HashAlgorithm):
            raise UnsupportedAlgorithm(
                &quot;Algorithm supplied is not a supported hash algorithm.&quot;,
                _Reasons.UNSUPPORTED_HASH,
            )

        if not backend.hmac_supported(algorithm):
            raise UnsupportedAlgorithm(
                &quot;Algorithm supplied is not a supported hmac algorithm.&quot;,
                _Reasons.UNSUPPORTED_HASH,
            )

        if not isinstance(mode, Mode):
            raise TypeError(&quot;mode must be of type Mode&quot;)

        if not isinstance(location, CounterLocation):
            raise TypeError(&quot;location must be of type CounterLocation&quot;)

        if (label or context) and fixed:
            raise ValueError(
                &quot;When supplying fixed data, &quot; &quot;label and context are ignored.&quot;
            )

        if rlen is None or not self._valid_byte_length(rlen):
            raise ValueError(&quot;rlen must be between 1 and 4&quot;)

        if llen is None and fixed is None:
            raise ValueError(&quot;Please specify an llen&quot;)

        if llen is not None and not isinstance(llen, int):
            raise TypeError(&quot;llen must be an integer&quot;)

        if label is None:
            label = b&quot;&quot;

        if context is None:
            context = b&quot;&quot;

        utils._check_bytes(&quot;label&quot;, label)
        utils._check_bytes(&quot;context&quot;, context)
        self._algorithm = algorithm
        self._mode = mode
        self._length = length
        self._rlen = rlen
        self._llen = llen
        self._location = location
        self._label = label
        self._context = context
        self._backend = backend
        self._used = False
        self._fixed_data = fixed

    def _valid_byte_length(self, value):
        if not isinstance(value, int):
            raise TypeError(&quot;value must be of type int&quot;)

        value_bin = utils.int_to_bytes(1, value)
        if not 1 &lt;= len(value_bin) &lt;= 4:
            return False
        return True

    def derive(self, key_material):
        if self._used:
            raise AlreadyFinalized

        utils._check_byteslike(&quot;key_material&quot;, key_material)
        self._used = True

        # inverse floor division (equivalent to ceiling)
        rounds = -(-self._length // self._algorithm.digest_size)

        output = [b&quot;&quot;]

        # For counter mode, the number of iterations shall not be
        # larger than 2^r-1, where r &lt;= 32 is the binary length of the counter
        # This ensures that the counter values used as an input to the
        # PRF will not repeat during a particular call to the KDF function.
        r_bin = utils.int_to_bytes(1, self._rlen)
        if rounds &gt; pow(2, len(r_bin) * 8) - 1:
            raise ValueError(&quot;There are too many iterations.&quot;)

        for i in range(1, rounds + 1):
            h = hmac.HMAC(key_material, self._algorithm, backend=self._backend)

            counter = utils.int_to_bytes(i, self._rlen)
            if self._location == CounterLocation.BeforeFixed:
                h.update(counter)

            h.update(self._generate_fixed_input())

            if self._location == CounterLocation.AfterFixed:
                h.update(counter)

            output.append(h.finalize())

        return b&quot;&quot;.join(output)[: self._length]

    def _generate_fixed_input(self):
        if self._fixed_data and isinstance(self._fixed_data, bytes):
            return self._fixed_data

        l_val = utils.int_to_bytes(self._length * 8, self._llen)

        return b&quot;&quot;.join([self._label, b&quot;\x00&quot;, self._context, l_val])

    def verify(self, key_material, expected_key):
        if not constant_time.bytes_eq(self.derive(key_material), expected_key):
            raise InvalidKey
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Flib64%2Fpython3.6%2Fsite-packages%2Fcryptography%2Fhazmat%2Fprimitives%2Fkdf'>Back to Directory</a>