summaryrefslogtreecommitdiffstats
path: root/Lib/test/test_hmac.py
blob: b7b3c079244b55b10397eadc40ee38c2b9342b1d (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
import hmac
import unittest
import test_support

class TestVectorsTestCase(unittest.TestCase):
    def test_vectors(self):
        """Test the HMAC module against test vectors from the RFC."""

        def md5test(key, data, digest):
            h = hmac.HMAC(key, data)
            self.failUnless(h.hexdigest().upper() == digest.upper())

        md5test(chr(0x0b) * 16,
                "Hi There",
                "9294727A3638BB1C13F48EF8158BFC9D")

        md5test("Jefe",
                "what do ya want for nothing?",
                "750c783e6ab0b503eaa86e310a5db738")

        md5test(chr(0xAA)*16,
                chr(0xDD)*50,
                "56be34521d144c88dbb8c733f0e8b3f6")

class ConstructorTestCase(unittest.TestCase):
    def test_normal(self):
        """Standard constructor call."""
        failed = 0
        try:
            h = hmac.HMAC("key")
        except:
            self.fail("Standard constructor call raised exception.")

    def test_withtext(self):
        """Constructor call with text."""
        try:
            h = hmac.HMAC("key", "hash this!")
        except:
            self.fail("Constructor call with text argument raised exception.")

    def test_withmodule(self):
        """Constructor call with text and digest module."""
        import sha
        try:
            h = hmac.HMAC("key", "", sha)
        except:
            self.fail("Constructor call with sha module raised exception.")

class SanityTestCase(unittest.TestCase):
    def test_default_is_md5(self):
        """Testing if HMAC defaults to MD5 algorithm."""
        import md5
        h = hmac.HMAC("key")
        self.failUnless(h.digestmod == md5)

    def test_exercise_all_methods(self):
        """Exercising all methods once."""
        # This must not raise any exceptions
        try:
            h = hmac.HMAC("my secret key")
            h.update("compute the hash of this text!")
            dig = h.digest()
            dig = h.hexdigest()
            h2 = h.copy()
        except:
            self.fail("Exception raised during normal usage of HMAC class.")

class CopyTestCase(unittest.TestCase):
    def test_attributes(self):
        """Testing if attributes are of same type."""
        h1 = hmac.HMAC("key")
        h2 = h1.copy()
        self.failUnless(h1.digestmod == h2.digestmod,
            "Modules don't match.")
        self.failUnless(type(h1.inner) == type(h2.inner),
            "Types of inner don't match.")
        self.failUnless(type(h1.outer) == type(h2.outer),
            "Types of outer don't match.")

    def test_realcopy(self):
        """Testing if the copy method created a real copy."""
        h1 = hmac.HMAC("key")
        h2 = h1.copy()
        # Using id() in case somebody has overridden __cmp__.
        self.failUnless(id(h1) != id(h2), "No real copy of the HMAC instance.")
        self.failUnless(id(h1.inner) != id(h2.inner),
            "No real copy of the attribute 'inner'.")
        self.failUnless(id(h1.outer) != id(h2.outer),
            "No real copy of the attribute 'outer'.")

    def test_equality(self):
        """Testing if the copy has the same digests."""
        h1 = hmac.HMAC("key")
        h1.update("some random text")
        h2 = h1.copy()
        self.failUnless(h1.digest() == h2.digest(),
            "Digest of copy doesn't match original digest.")
        self.failUnless(h1.hexdigest() == h2.hexdigest(),
            "Hexdigest of copy doesn't match original hexdigest.")

def test_main():
    test_support.run_unittest(TestVectorsTestCase)
    test_support.run_unittest(ConstructorTestCase)
    test_support.run_unittest(SanityTestCase)
    test_support.run_unittest(CopyTestCase)

if __name__ == "__main__":
    test_main()