Make hmac use bytes. Make test_hmac pass.

gvanrossum · gvanrossum · commit 3f42908051db · 2007-07-10T13:35:52.000Z
diff --git a/Lib/hmac.py b/Lib/hmac.py
@@ -3,8 +3,8 @@
 Implements the HMAC algorithm as described by RFC 2104.
 """
 
-trans_5C = "".join ([chr (x ^ 0x5C) for x in range(256)])
-trans_36 = "".join ([chr (x ^ 0x36) for x in range(256)])
+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.
@@ -30,19 +30,26 @@ def __init__(self, key, msg = None, digestmod = None):
         digestmod: A module supporting PEP 247.  *OR*
                    A hashlib constructor returning a new hash object.
                    Defaults to hashlib.md5.
+
+        Note: key and msg must be bytes objects.
         """
 
         if key is _secret_backdoor_key: # cheap
             return
 
+        if not isinstance(key, bytes):
+            if hasattr(key, "__index__"):
+                raise TypeError("key can't be a number")
+            key = bytes(key)
+
         if digestmod is None:
             import hashlib
             digestmod = hashlib.md5
 
         if hasattr(digestmod, '__call__'):
             self.digest_cons = digestmod
         else:
-            self.digest_cons = lambda d='': digestmod.new(d)
+            self.digest_cons = lambda d=b'': digestmod.new(d)
 
         self.outer = self.digest_cons()
         self.inner = self.digest_cons()
@@ -52,7 +59,7 @@ def __init__(self, key, msg = None, digestmod = None):
         if len(key) > blocksize:
             key = self.digest_cons(key).digest()
 
-        key = key + chr(0) * (blocksize - len(key))
+        key = key + bytes(blocksize - len(key))
         self.outer.update(key.translate(trans_5C))
         self.inner.update(key.translate(trans_36))
         if msg is not None:
@@ -64,6 +71,10 @@ def __init__(self, key, msg = None, digestmod = None):
     def update(self, msg):
         """Update this hashing object with the string msg.
         """
+        if not isinstance(msg, bytes):
+            if hasattr(msg, "__index__"):
+                raise TypeError("msg can't be a number")
+            msg = bytes(msg)
         self.inner.update(msg)
 
     def copy(self):
diff --git a/Lib/test/test_hmac.py b/Lib/test/test_hmac.py
@@ -12,31 +12,31 @@ def md5test(key, data, digest):
             h = hmac.HMAC(key, data)
             self.assertEqual(h.hexdigest().upper(), digest.upper())
 
-        md5test(chr(0x0b) * 16,
-                "Hi There",
+        md5test(b"\x0b" * 16,
+                b"Hi There",
                 "9294727A3638BB1C13F48EF8158BFC9D")
 
-        md5test("Jefe",
-                "what do ya want for nothing?",
+        md5test(b"Jefe",
+                b"what do ya want for nothing?",
                 "750c783e6ab0b503eaa86e310a5db738")
 
-        md5test(chr(0xAA)*16,
-                chr(0xDD)*50,
+        md5test(b"\xaa" * 16,
+                b"\xdd" * 50,
                 "56be34521d144c88dbb8c733f0e8b3f6")
 
         md5test("".join([chr(i) for i in range(1, 26)]),
-                chr(0xCD) * 50,
+                b"\xcd" * 50,
                 "697eaf0aca3a3aea3a75164746ffaa79")
 
         md5test(chr(0x0C) * 16,
                 "Test With Truncation",
                 "56461ef2342edc00f9bab995690efd4c")
 
-        md5test(chr(0xAA) * 80,
+        md5test(b"\xaa" * 80,
                 "Test Using Larger Than Block-Size Key - Hash Key First",
                 "6b1ab7fe4bd7bf8f0b62e6ce61b9d0cd")
 
-        md5test(chr(0xAA) * 80,
+        md5test(b"\xaa" * 80,
                 ("Test Using Larger Than Block-Size Key "
                  "and Larger Than One Block-Size Data"),
                 "6f630fad67cda0ee1fb1f562db3aa53e")
@@ -46,33 +46,33 @@ def shatest(key, data, digest):
             h = hmac.HMAC(key, data, digestmod=sha1)
             self.assertEqual(h.hexdigest().upper(), digest.upper())
 
-        shatest(chr(0x0b) * 20,
-                "Hi There",
+        shatest(b"\x0b" * 20,
+                b"Hi There",
                 "b617318655057264e28bc0b6fb378c8ef146be00")
 
-        shatest("Jefe",
-                "what do ya want for nothing?",
+        shatest(b"Jefe",
+                b"what do ya want for nothing?",
                 "effcdf6ae5eb2fa2d27416d5f184df9c259a7c79")
 
-        shatest(chr(0xAA)*20,
-                chr(0xDD)*50,
+        shatest(b"\xAA" * 20,
+                b"\xDD" * 50,
                 "125d7342b9ac11cd91a39af48aa17b4f63f175d3")
 
-        shatest("".join([chr(i) for i in range(1, 26)]),
-                chr(0xCD) * 50,
+        shatest(bytes(range(1, 26)),
+                b"\xCD" * 50,
                 "4c9007f4026250c6bc8414f9bf50c86c2d7235da")
 
         shatest(chr(0x0C) * 20,
                 "Test With Truncation",
                 "4c1a03424b55e07fe7f27be1d58bb9324a9a5a04")
 
-        shatest(chr(0xAA) * 80,
-                "Test Using Larger Than Block-Size Key - Hash Key First",
+        shatest(b"\xAA" * 80,
+                b"Test Using Larger Than Block-Size Key - Hash Key First",
                 "aa4ae5e15272d00e95705637ce8a3b55ed402112")
 
-        shatest(chr(0xAA) * 80,
-                ("Test Using Larger Than Block-Size Key "
-                 "and Larger Than One Block-Size Data"),
+        shatest(b"\xAA" * 80,
+                (b"Test Using Larger Than Block-Size Key "
+                 b"and Larger Than One Block-Size Data"),
                 "e8e99d0f45237d786d6bbaa7965c7808bbff1a91")
 
 
