FM / primitives

/usr/lib64/python2.6/site-packages/cryptography/hazmat/primitives/

/usr/lib64/python2.6/site-packages/cryptography/hazmat/primitives

Name	Size	Mode	Actions
asymmetric/	-	0755	rm
ciphers/	-	0755	rm
interfaces/	-	0755	rm
kdf/	-	0755	rm
twofactor/	-	0755	rm
cmac.py	2235	0644	edit dl rm
cmac.pyc	2993	0644	edit dl rm
constant_time.py	798	0644	edit dl rm
constant_time.pyc	1152	0644	edit dl rm
hashes.py	3954	0644	edit dl rm
hashes.pyc	7092	0644	edit dl rm
hmac.py	2353	0644	edit dl rm
hmac.pyc	3123	0644	edit dl rm
padding.py	3635	0644	edit dl rm
padding.pyc	5219	0644	edit dl rm
serialization.py	5152	0644	edit dl rm
serialization.pyc	7539	0644	edit dl rm
__init__.py	246	0644	edit dl rm
__init__.pyc	284	0644	edit dl rm

Edit: /usr/lib64/python2.6/site-packages/cryptography/hazmat/primitives/hmac.py (2353B)

# 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 cryptography import utils
from cryptography.exceptions import (
    AlreadyFinalized, UnsupportedAlgorithm, _Reasons
)
from cryptography.hazmat.backends.interfaces import HMACBackend
from cryptography.hazmat.primitives import hashes, interfaces

@utils.register_interface(interfaces.MACContext)
@utils.register_interface(hashes.HashContext)
class HMAC(object):
    def __init__(self, key, algorithm, backend, ctx=None):
        if not isinstance(backend, HMACBackend):
            raise UnsupportedAlgorithm(
                "Backend object does not implement HMACBackend.",
                _Reasons.BACKEND_MISSING_INTERFACE
            )

if not isinstance(algorithm, hashes.HashAlgorithm):
            raise TypeError("Expected instance of hashes.HashAlgorithm.")
        self._algorithm = algorithm

self._backend = backend
        self._key = key
        if ctx is None:
            self._ctx = self._backend.create_hmac_ctx(key, self.algorithm)
        else:
            self._ctx = ctx

algorithm = utils.read_only_property("_algorithm")

def update(self, data):
        if self._ctx is None:
            raise AlreadyFinalized("Context was already finalized.")
        if not isinstance(data, bytes):
            raise TypeError("data must be bytes.")
        self._ctx.update(data)

def copy(self):
        if self._ctx is None:
            raise AlreadyFinalized("Context was already finalized.")
        return HMAC(
            self._key,
            self.algorithm,
            backend=self._backend,
            ctx=self._ctx.copy()
        )

def finalize(self):
        if self._ctx is None:
            raise AlreadyFinalized("Context was already finalized.")
        digest = self._ctx.finalize()
        self._ctx = None
        return digest

def verify(self, signature):
        if not isinstance(signature, bytes):
            raise TypeError("signature must be bytes.")
        if self._ctx is None:
            raise AlreadyFinalized("Context was already finalized.")

ctx, self._ctx = self._ctx, None
        ctx.verify(signature)

cmd: