home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_2585 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  4.9 KB  |  122 lines

  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import win32security
  5. import sspi
  6. import sspicon
  7. import win32api
  8. import unittest
  9.  
  10. class TestSSPI(unittest.TestCase):
  11.     
  12.     def assertRaisesHRESULT(self, hr, func, *args):
  13.         
  14.         try:
  15.             return func(*args)
  16.             raise RuntimeError, 'expecting %s failure' % (hr,)
  17.         except win32security.error:
  18.             (hr_got, func, msg) = None
  19.             self.failUnlessEqual(hr_got, hr)
  20.  
  21.  
  22.     
  23.     def _doAuth(self, pkg_name):
  24.         sspiclient = sspi.ClientAuth(pkg_name, targetspn = win32api.GetUserName())
  25.         sspiserver = sspi.ServerAuth(pkg_name)
  26.         sec_buffer = None
  27.         err = 1
  28.         while err != 0:
  29.             (err, sec_buffer) = sspiclient.authorize(sec_buffer)
  30.             (err, sec_buffer) = sspiserver.authorize(sec_buffer)
  31.         return (sspiclient, sspiserver)
  32.  
  33.     
  34.     def _doTestImpersonate(self, pkg_name):
  35.         (sspiclient, sspiserver) = self._doAuth(pkg_name)
  36.         sspiserver.ctxt.ImpersonateSecurityContext()
  37.         sspiserver.ctxt.RevertSecurityContext()
  38.  
  39.     
  40.     def testImpersonateKerberos(self):
  41.         self._doTestImpersonate('Kerberos')
  42.  
  43.     
  44.     def testImpersonateNTLM(self):
  45.         self._doTestImpersonate('NTLM')
  46.  
  47.     
  48.     def _doTestEncrypt(self, pkg_name):
  49.         (sspiclient, sspiserver) = self._doAuth(pkg_name)
  50.         pkg_size_info = sspiclient.ctxt.QueryContextAttributes(sspicon.SECPKG_ATTR_SIZES)
  51.         msg = 'some data to be encrypted ......'
  52.         trailersize = pkg_size_info['SecurityTrailer']
  53.         encbuf = win32security.PySecBufferDescType()
  54.         encbuf.append(win32security.PySecBufferType(len(msg), sspicon.SECBUFFER_DATA))
  55.         encbuf.append(win32security.PySecBufferType(trailersize, sspicon.SECBUFFER_TOKEN))
  56.         encbuf[0].Buffer = msg
  57.         sspiclient.ctxt.EncryptMessage(0, encbuf, 1)
  58.         sspiserver.ctxt.DecryptMessage(encbuf, 1)
  59.         self.failUnlessEqual(msg, encbuf[0].Buffer)
  60.         (data, sig) = sspiclient.encrypt('hello')
  61.         self.assertEqual(sspiserver.decrypt(data, sig), 'hello')
  62.         (data, sig) = sspiserver.encrypt('hello')
  63.         self.assertEqual(sspiclient.decrypt(data, sig), 'hello')
  64.  
  65.     
  66.     def testEncryptNTLM(self):
  67.         self._doTestEncrypt('NTLM')
  68.  
  69.     
  70.     def testEncryptKerberos(self):
  71.         self._doTestEncrypt('Kerberos')
  72.  
  73.     
  74.     def _doTestSign(self, pkg_name):
  75.         (sspiclient, sspiserver) = self._doAuth(pkg_name)
  76.         pkg_size_info = sspiclient.ctxt.QueryContextAttributes(sspicon.SECPKG_ATTR_SIZES)
  77.         msg = 'some data to be encrypted ......'
  78.         sigsize = pkg_size_info['MaxSignature']
  79.         sigbuf = win32security.PySecBufferDescType()
  80.         sigbuf.append(win32security.PySecBufferType(len(msg), sspicon.SECBUFFER_DATA))
  81.         sigbuf.append(win32security.PySecBufferType(sigsize, sspicon.SECBUFFER_TOKEN))
  82.         sigbuf[0].Buffer = msg
  83.         sspiclient.ctxt.MakeSignature(0, sigbuf, 0)
  84.         sspiserver.ctxt.VerifySignature(sigbuf, 0)
  85.         sspiclient.next_seq_num = 1
  86.         sspiserver.next_seq_num = 1
  87.         key = sspiclient.sign('hello')
  88.         sspiserver.verify('hello', key)
  89.         key = sspiclient.sign('hello')
  90.         self.assertRaisesHRESULT(sspicon.SEC_E_MESSAGE_ALTERED, sspiserver.verify, 'hellox', key)
  91.         key = sspiserver.sign('hello')
  92.         sspiclient.verify('hello', key)
  93.         key = sspiserver.sign('hello')
  94.         self.assertRaisesHRESULT(sspicon.SEC_E_MESSAGE_ALTERED, sspiclient.verify, 'hellox', key)
  95.  
  96.     
  97.     def testSignNTLM(self):
  98.         self._doTestSign('NTLM')
  99.  
  100.     
  101.     def testSignKerberos(self):
  102.         self._doTestSign('Kerberos')
  103.  
  104.     
  105.     def testSequenceSign(self):
  106.         (sspiclient, sspiserver) = self._doAuth('Kerberos')
  107.         key = sspiclient.sign('hello')
  108.         sspiclient.sign('hello')
  109.         self.assertRaisesHRESULT(sspicon.SEC_E_OUT_OF_SEQUENCE, sspiserver.verify, 'hello', key)
  110.  
  111.     
  112.     def testSequenceEncrypt(self):
  113.         (sspiclient, sspiserver) = self._doAuth('Kerberos')
  114.         (blob, key) = sspiclient.encrypt('hello')
  115.         (blob, key) = sspiclient.encrypt('hello')
  116.         self.assertRaisesHRESULT(sspicon.SEC_E_OUT_OF_SEQUENCE, sspiserver.decrypt, blob, key)
  117.  
  118.  
  119. if __name__ == '__main__':
  120.     unittest.main()
  121.  
  122.