home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_2536 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  6.2 KB  |  170 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import win32security
  5. import sspicon
  6. error = win32security.error
  7.  
  8. try:
  9.     (True, False)
  10. except NameError:
  11.     False = 1 == 0
  12.     True = not False
  13.  
  14.  
  15. class _BaseAuth(object):
  16.     
  17.     def __init__(self):
  18.         self.reset()
  19.  
  20.     
  21.     def reset(self):
  22.         self.ctxt = None
  23.         self.authenticated = False
  24.         self.next_seq_num = 0
  25.  
  26.     
  27.     def _get_next_seq_num(self):
  28.         ret = self.next_seq_num
  29.         self.next_seq_num = self.next_seq_num + 1
  30.         return ret
  31.  
  32.     
  33.     def encrypt(self, data):
  34.         pkg_size_info = self.ctxt.QueryContextAttributes(sspicon.SECPKG_ATTR_SIZES)
  35.         trailersize = pkg_size_info['SecurityTrailer']
  36.         encbuf = win32security.PySecBufferDescType()
  37.         encbuf.append(win32security.PySecBufferType(len(data), sspicon.SECBUFFER_DATA))
  38.         encbuf.append(win32security.PySecBufferType(trailersize, sspicon.SECBUFFER_TOKEN))
  39.         encbuf[0].Buffer = data
  40.         self.ctxt.EncryptMessage(0, encbuf, self._get_next_seq_num())
  41.         return (encbuf[0].Buffer, encbuf[1].Buffer)
  42.  
  43.     
  44.     def decrypt(self, data, trailer):
  45.         encbuf = win32security.PySecBufferDescType()
  46.         encbuf.append(win32security.PySecBufferType(len(data), sspicon.SECBUFFER_DATA))
  47.         encbuf.append(win32security.PySecBufferType(len(trailer), sspicon.SECBUFFER_TOKEN))
  48.         encbuf[0].Buffer = data
  49.         encbuf[1].Buffer = trailer
  50.         self.ctxt.DecryptMessage(encbuf, self._get_next_seq_num())
  51.         return encbuf[0].Buffer
  52.  
  53.     
  54.     def sign(self, data):
  55.         pkg_size_info = self.ctxt.QueryContextAttributes(sspicon.SECPKG_ATTR_SIZES)
  56.         sigsize = pkg_size_info['MaxSignature']
  57.         sigbuf = win32security.PySecBufferDescType()
  58.         sigbuf.append(win32security.PySecBufferType(len(data), sspicon.SECBUFFER_DATA))
  59.         sigbuf.append(win32security.PySecBufferType(sigsize, sspicon.SECBUFFER_TOKEN))
  60.         sigbuf[0].Buffer = data
  61.         self.ctxt.MakeSignature(0, sigbuf, self._get_next_seq_num())
  62.         return sigbuf[1].Buffer
  63.  
  64.     
  65.     def verify(self, data, sig):
  66.         sigbuf = win32security.PySecBufferDescType()
  67.         sigbuf.append(win32security.PySecBufferType(len(data), sspicon.SECBUFFER_DATA))
  68.         sigbuf.append(win32security.PySecBufferType(len(sig), sspicon.SECBUFFER_TOKEN))
  69.         sigbuf[0].Buffer = data
  70.         sigbuf[1].Buffer = sig
  71.         self.ctxt.VerifySignature(sigbuf, self._get_next_seq_num())
  72.  
  73.  
  74.  
  75. class ClientAuth(_BaseAuth):
  76.     
  77.     def __init__(self, pkg_name, client_name = None, auth_info = None, targetspn = None, scflags = None, datarep = sspicon.SECURITY_NETWORK_DREP):
  78.         if scflags is None:
  79.             scflags = sspicon.ISC_REQ_INTEGRITY | sspicon.ISC_REQ_SEQUENCE_DETECT | sspicon.ISC_REQ_REPLAY_DETECT | sspicon.ISC_REQ_CONFIDENTIALITY
  80.         
  81.         self.scflags = scflags
  82.         self.datarep = datarep
  83.         self.targetspn = targetspn
  84.         self.pkg_info = win32security.QuerySecurityPackageInfo(pkg_name)
  85.         (self.credentials, self.credentials_expiry) = win32security.AcquireCredentialsHandle(client_name, self.pkg_info['Name'], sspicon.SECPKG_CRED_OUTBOUND, None, auth_info)
  86.         _BaseAuth.__init__(self)
  87.  
  88.     
  89.     def authorize(self, sec_buffer_in):
  90.         if sec_buffer_in is not None and type(sec_buffer_in) != win32security.PySecBufferDescType:
  91.             sec_buffer_new = win32security.PySecBufferDescType()
  92.             tokenbuf = win32security.PySecBufferType(self.pkg_info['MaxToken'], sspicon.SECBUFFER_TOKEN)
  93.             tokenbuf.Buffer = sec_buffer_in
  94.             sec_buffer_new.append(tokenbuf)
  95.             sec_buffer_in = sec_buffer_new
  96.         
  97.         sec_buffer_out = win32security.PySecBufferDescType()
  98.         tokenbuf = win32security.PySecBufferType(self.pkg_info['MaxToken'], sspicon.SECBUFFER_TOKEN)
  99.         sec_buffer_out.append(tokenbuf)
  100.         ctxtin = self.ctxt
  101.         if self.ctxt is None:
  102.             self.ctxt = win32security.PyCtxtHandleType()
  103.         
  104.         (err, attr, exp) = win32security.InitializeSecurityContext(self.credentials, ctxtin, self.targetspn, self.scflags, self.datarep, sec_buffer_in, self.ctxt, sec_buffer_out)
  105.         self.ctxt_attr = attr
  106.         self.ctxt_expiry = exp
  107.         if err in (sspicon.SEC_I_COMPLETE_NEEDED, sspicon.SEC_I_COMPLETE_AND_CONTINUE):
  108.             self.ctxt.CompleteAuthToken(sec_buffer_out)
  109.         
  110.         self.authenticated = err == 0
  111.         return (err, sec_buffer_out)
  112.  
  113.  
  114.  
  115. class ServerAuth(_BaseAuth):
  116.     
  117.     def __init__(self, pkg_name, spn = None, scflags = None, datarep = sspicon.SECURITY_NETWORK_DREP):
  118.         self.spn = spn
  119.         self.datarep = datarep
  120.         if scflags is None:
  121.             scflags = sspicon.ASC_REQ_INTEGRITY | sspicon.ASC_REQ_SEQUENCE_DETECT | sspicon.ASC_REQ_REPLAY_DETECT | sspicon.ASC_REQ_CONFIDENTIALITY
  122.         
  123.         self.scflags = scflags
  124.         self.pkg_info = win32security.QuerySecurityPackageInfo(pkg_name)
  125.         (self.credentials, self.credentials_expiry) = win32security.AcquireCredentialsHandle(spn, self.pkg_info['Name'], sspicon.SECPKG_CRED_INBOUND, None, None)
  126.         _BaseAuth.__init__(self)
  127.  
  128.     
  129.     def authorize(self, sec_buffer_in):
  130.         if sec_buffer_in is not None and type(sec_buffer_in) != win32security.PySecBufferDescType:
  131.             sec_buffer_new = win32security.PySecBufferDescType()
  132.             tokenbuf = win32security.PySecBufferType(self.pkg_info['MaxToken'], sspicon.SECBUFFER_TOKEN)
  133.             tokenbuf.Buffer = sec_buffer_in
  134.             sec_buffer_new.append(tokenbuf)
  135.             sec_buffer_in = sec_buffer_new
  136.         
  137.         sec_buffer_out = win32security.PySecBufferDescType()
  138.         tokenbuf = win32security.PySecBufferType(self.pkg_info['MaxToken'], sspicon.SECBUFFER_TOKEN)
  139.         sec_buffer_out.append(tokenbuf)
  140.         ctxtin = self.ctxt
  141.         if self.ctxt is None:
  142.             self.ctxt = win32security.PyCtxtHandleType()
  143.         
  144.         (err, attr, exp) = win32security.AcceptSecurityContext(self.credentials, ctxtin, sec_buffer_in, self.scflags, self.datarep, self.ctxt, sec_buffer_out)
  145.         self.ctxt_attr = attr
  146.         self.ctxt_expiry = exp
  147.         if err in (sspicon.SEC_I_COMPLETE_NEEDED, sspicon.SEC_I_COMPLETE_AND_CONTINUE):
  148.             self.ctxt.CompleteAuthToken(sec_buffer_out)
  149.         
  150.         self.authenticated = err == 0
  151.         return (err, sec_buffer_out)
  152.  
  153.  
  154. if __name__ == '__main__':
  155.     sspiclient = ClientAuth('NTLM')
  156.     sspiserver = ServerAuth('NTLM')
  157.     sec_buffer = None
  158.     while None:
  159.         (err, sec_buffer) = sspiclient.authorize(sec_buffer)
  160.         (err, sec_buffer) = sspiserver.authorize(sec_buffer)
  161.         if err == 0:
  162.             break
  163.             continue
  164.         continue
  165.         sig = sspiclient.sign('hello')
  166.         sspiserver.verify('hello', sig)
  167.         (data, key) = sspiclient.encrypt('hello')
  168.         print 'cool!'
  169. __name__ == '__main__'
  170.