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