← Back to branch summary

~gary/python-openid/python-openid-2.2.1-patched

« back to all changes in this revision

Viewing changes to openid/test/test_association.py

  • Committer: Launchpad Patch Queue Manager
  • Date: 2007-11-30 02:46:28 UTC
  • mfrom: (1.1.1 pyopenid-2.0)
  • Revision ID: launchpad@pqm.canonical.com-20071130024628-qktwsew3383iawmq
[rs=SteveA] upgrade to python-openid-2.0.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
openid/test/test_association.py
 
1
from openid.test import datadriven
 
2
 
 
3
import unittest
 
4
 
 
5
from openid.message import Message, BARE_NS, OPENID_NS, OPENID2_NS
 
6
from openid import association
 
7
import time
 
8
from openid import cryptutil
 
9
import warnings
 
10
 
 
11
class AssociationSerializationTest(unittest.TestCase):
 
12
    def test_roundTrip(self):
 
13
        issued = int(time.time())
 
14
        lifetime = 600
 
15
        assoc = association.Association(
 
16
            'handle', 'secret', issued, lifetime, 'HMAC-SHA1')
 
17
        s = assoc.serialize()
 
18
        assoc2 = association.Association.deserialize(s)
 
19
        self.failUnlessEqual(assoc.handle, assoc2.handle)
 
20
        self.failUnlessEqual(assoc.issued, assoc2.issued)
 
21
        self.failUnlessEqual(assoc.secret, assoc2.secret)
 
22
        self.failUnlessEqual(assoc.lifetime, assoc2.lifetime)
 
23
        self.failUnlessEqual(assoc.assoc_type, assoc2.assoc_type)
 
24
 
 
25
from openid.server.server import \
 
26
     DiffieHellmanSHA1ServerSession, \
 
27
     DiffieHellmanSHA256ServerSession, \
 
28
     PlainTextServerSession
 
29
 
 
30
from openid.consumer.consumer import \
 
31
     DiffieHellmanSHA1ConsumerSession, \
 
32
     DiffieHellmanSHA256ConsumerSession, \
 
33
     PlainTextConsumerSession
 
34
 
 
35
from openid.dh import DiffieHellman
 
36
 
 
37
def createNonstandardConsumerDH():
 
38
    nonstandard_dh = DiffieHellman(1315291, 2)
 
39
    return DiffieHellmanSHA1ConsumerSession(nonstandard_dh)
 
40
 
 
41
class DiffieHellmanSessionTest(datadriven.DataDrivenTestCase):
 
42
    secrets = [
 
43
        '\x00' * 20,
 
44
        '\xff' * 20,
 
45
        ' ' * 20,
 
46
        'This is a secret....',
 
47
        ]
 
48
 
 
49
    session_factories = [
 
50
        (DiffieHellmanSHA1ConsumerSession, DiffieHellmanSHA1ServerSession),
 
51
        (createNonstandardConsumerDH, DiffieHellmanSHA1ServerSession),
 
52
        (PlainTextConsumerSession, PlainTextServerSession),
 
53
        ]
 
54
 
 
55
    def generateCases(cls):
 
56
        return [(c, s, sec)
 
57
                for c, s in cls.session_factories
 
58
                for sec in cls.secrets]
 
59
 
 
60
    generateCases = classmethod(generateCases)
 
61
 
 
62
    def __init__(self, csess_fact, ssess_fact, secret):
 
63
        datadriven.DataDrivenTestCase.__init__(self, csess_fact.__name__)
 
64
        self.secret = secret
 
65
        self.csess_fact = csess_fact
 
66
        self.ssess_fact = ssess_fact
 
67
 
 
68
    def runOneTest(self):
 
69
        csess = self.csess_fact()
 
70
        msg = Message.fromOpenIDArgs(csess.getRequest())
 
71
        ssess = self.ssess_fact.fromMessage(msg)
 
72
        check_secret = csess.extractSecret(
 
73
            Message.fromOpenIDArgs(ssess.answer(self.secret)))
 
74
        self.failUnlessEqual(self.secret, check_secret)
 
75
 
 
76
 
 
77
 
 
78
class TestMakePairs(unittest.TestCase):
 
79
    """Check the key-value formatting methods of associations.
 
80
    """
 
81
 
 
82
    def setUp(self):
 
83
        self.message = m = Message(OPENID2_NS)
 
84
        m.updateArgs(OPENID2_NS, {
 
85
            'mode': 'id_res',
 
86
            'identifier': '=example',
 
87
            'signed': 'identifier,mode',
 
88
            'sig': 'cephalopod',
 
89
            })
 
90
        m.updateArgs(BARE_NS, {'xey': 'value'})
 
91
        self.assoc = association.Association.fromExpiresIn(
 
92
            3600, '{sha1}', 'very_secret', "HMAC-SHA1")
 
93
 
 
94
 
 
95
    def testMakePairs(self):
 
96
        """Make pairs using the OpenID 1.x type signed list."""
 
97
        pairs = self.assoc._makePairs(self.message)
 
98
        expected = [
 
99
            ('identifier', '=example'),
 
100
            ('mode', 'id_res'),
 
101
            ]
 
102
        self.failUnlessEqual(pairs, expected)
 
103
 
 
104
 
 
105
 
 
106
class TestMac(unittest.TestCase):
 
107
    def setUp(self):
 
108
        self.pairs = [('key1', 'value1'),
 
109
                      ('key2', 'value2')]
 
110
 
 
111
 
 
112
    def test_sha1(self):
 
113
        assoc = association.Association.fromExpiresIn(
 
114
            3600, '{sha1}', 'very_secret', "HMAC-SHA1")
 
115
        expected = ('\xe0\x1bv\x04\xf1G\xc0\xbb\x7f\x9a\x8b'
 
116
                    '\xe9\xbc\xee}\\\xe5\xbb7*')
 
117
        sig = assoc.sign(self.pairs)
 
118
        self.failUnlessEqual(sig, expected)
 
119
 
 
120
    if cryptutil.SHA256_AVAILABLE:
 
121
        def test_sha256(self):
 
122
            assoc = association.Association.fromExpiresIn(
 
123
                3600, '{sha256SA}', 'very_secret', "HMAC-SHA256")
 
124
            expected = ('\xfd\xaa\xfe;\xac\xfc*\x988\xad\x05d6-\xeaVy'
 
125
                        '\xd5\xa5Z.<\xa9\xed\x18\x82\\$\x95x\x1c&')
 
126
            sig = assoc.sign(self.pairs)
 
127
            self.failUnlessEqual(sig, expected)
 
128
 
 
129
 
 
130
 
 
131
class TestMessageSigning(unittest.TestCase):
 
132
    def setUp(self):
 
133
        self.message = m = Message(OPENID2_NS)
 
134
        m.updateArgs(OPENID2_NS, {'mode': 'id_res',
 
135
                                  'identifier': '=example'})
 
136
        m.updateArgs(BARE_NS, {'xey': 'value'})
 
137
        self.args = {'openid.mode': 'id_res',
 
138
                     'openid.identifier': '=example',
 
139
                     'xey': 'value'}
 
140
 
 
141
 
 
142
    def test_signSHA1(self):
 
143
        assoc = association.Association.fromExpiresIn(
 
144
            3600, '{sha1}', 'very_secret', "HMAC-SHA1")
 
145
        signed = assoc.signMessage(self.message)
 
146
        self.failUnless(signed.getArg(OPENID_NS, "sig"))
 
147
        self.failUnlessEqual(signed.getArg(OPENID_NS, "signed"),
 
148
                             "assoc_handle,identifier,mode,ns,signed")
 
149
        self.failUnlessEqual(signed.getArg(BARE_NS, "xey"), "value",
 
150
                             signed)
 
151
 
 
152
    if cryptutil.SHA256_AVAILABLE:
 
153
        def test_signSHA256(self):
 
154
            assoc = association.Association.fromExpiresIn(
 
155
                3600, '{sha1}', 'very_secret', "HMAC-SHA256")
 
156
            signed = assoc.signMessage(self.message)
 
157
            self.failUnless(signed.getArg(OPENID_NS, "sig"))
 
158
            self.failUnlessEqual(signed.getArg(OPENID_NS, "signed"),
 
159
                                 "assoc_handle,identifier,mode,ns,signed")
 
160
            self.failUnlessEqual(signed.getArg(BARE_NS, "xey"), "value",
 
161
                                 signed)
 
162
 
 
163
 
 
164
class TestCheckMessageSignature(unittest.TestCase):
 
165
    def test_aintGotSignedList(self):
 
166
        m = Message(OPENID2_NS)
 
167
        m.updateArgs(OPENID2_NS, {'mode': 'id_res',
 
168
                                  'identifier': '=example',
 
169
                                  'sig': 'coyote',
 
170
                                  })
 
171
        m.updateArgs(BARE_NS, {'xey': 'value'})
 
172
        assoc = association.Association.fromExpiresIn(
 
173
            3600, '{sha1}', 'very_secret', "HMAC-SHA1")
 
174
        self.failUnlessRaises(ValueError, assoc.checkMessageSignature, m)
 
175
 
 
176
 
 
177
def pyUnitTests():
 
178
    return datadriven.loadTests(__name__)
 
179
 
 
180
if __name__ == '__main__':
 
181
    suite = pyUnitTests()
 
182
    runner = unittest.TextTestRunner()
 
183
    runner.run(suite)