Ticket #41: hmac.py

#!/usr/bin/env python

#from pycryptopp import sha256
import sha256

digest_size = None

class HMAC(object):
    """RFC2104 HMAC class
    """

    blocksize = 64
    def __init__(self, key, msg=None, digestmod = None):
        """Create a new HMAC object

        key: key for the keyed hash object.
        msg: Initial input for the hash, if provided.
        digestmod: A module from pycrptopp hash package
        """

        if digestmod is None:
            digestmod = sha256.SHA256

        if callable(digestmod):
            self.digest_cons = digestmod
        else:
            self.digest_cons = lambda d='':digestmod.new(d)
        
        self.outer = self.digest_cons()
        self.inner = self.digest_cons()
        self.digest_size = len(self.digest_cons().digest())

        blocksize = self.blocksize
        if len(key) > blocksize:
            key = self.digest_cons(key).digest()

        key = key + chr(0)*(blocksize - len(key))
#       ikey = key ^ (imask*blocksize)
#       okey = key ^ (omask*blocksize)
        
        ikey = "".join(chr(ord(key[i])^0x5c) for i in xrange(blocksize))
        okey = "".join(chr(ord(key[i])^0x36) for i in xrange(blocksize))
        self.outer.update(ikey)
        self.inner.update(okey)
        if msg is not None:
            self.inner.update(msg)

    def digest(self):
        """Return the hash value of this hashing object
        """
        self.outer.update(self.inner.digest())
#       print "hi,xueyu coming\n"
        return self.outer.digest()

    def hexdigest(self):
        """Like digest(), but returns a string of hexadecimal digits instead.
        """
        self.outer.update(self.inner.digest())
        return self.outer.hexdigest()


def new(key, msg = None, digestmod = None):
    """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's starting 
    state.
    """
    return HMAC(key, msg, digestmod)