home *** CD-ROM | disk | FTP | other *** search
/ Chip 2011 November / CHIP_2011_11.iso / Programy / Narzedzia / Calibre / calibre-0.8.18.msi / file_262 / ssl.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-09-09  |  9.5 KB  |  270 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.7)
  3.  
  4. import textwrap
  5. import _ssl
  6. from _ssl import OPENSSL_VERSION_NUMBER, OPENSSL_VERSION_INFO, OPENSSL_VERSION
  7. from _ssl import SSLError
  8. from _ssl import CERT_NONE, CERT_OPTIONAL, CERT_REQUIRED
  9. from _ssl import PROTOCOL_SSLv2, PROTOCOL_SSLv3, PROTOCOL_SSLv23, PROTOCOL_TLSv1
  10. from _ssl import RAND_status, RAND_egd, RAND_add
  11. from _ssl import SSL_ERROR_ZERO_RETURN, SSL_ERROR_WANT_READ, SSL_ERROR_WANT_WRITE, SSL_ERROR_WANT_X509_LOOKUP, SSL_ERROR_SYSCALL, SSL_ERROR_SSL, SSL_ERROR_WANT_CONNECT, SSL_ERROR_EOF, SSL_ERROR_INVALID_ERROR_CODE
  12. from socket import socket, _fileobject, _delegate_methods, error as socket_error
  13. from socket import getnameinfo as _getnameinfo
  14. import base64
  15. import errno
  16.  
  17. class SSLSocket(socket):
  18.     
  19.     def __init__(self, sock, keyfile = None, certfile = None, server_side = False, cert_reqs = CERT_NONE, ssl_version = PROTOCOL_SSLv23, ca_certs = None, do_handshake_on_connect = True, suppress_ragged_eofs = True, ciphers = None):
  20.         socket.__init__(self, _sock = sock._sock)
  21.         for attr in _delegate_methods:
  22.             
  23.             try:
  24.                 delattr(self, attr)
  25.             continue
  26.             except AttributeError:
  27.                 continue
  28.             
  29.  
  30.         
  31.         if certfile and not keyfile:
  32.             keyfile = certfile
  33.         
  34.         try:
  35.             socket.getpeername(self)
  36.         except socket_error:
  37.             e = None
  38.             if e.errno != errno.ENOTCONN:
  39.                 raise 
  40.             self._sslobj = None
  41.  
  42.         self._sslobj = _ssl.sslwrap(self._sock, server_side, keyfile, certfile, cert_reqs, ssl_version, ca_certs, ciphers)
  43.         if do_handshake_on_connect:
  44.             self.do_handshake()
  45.         self.keyfile = keyfile
  46.         self.certfile = certfile
  47.         self.cert_reqs = cert_reqs
  48.         self.ssl_version = ssl_version
  49.         self.ca_certs = ca_certs
  50.         self.ciphers = ciphers
  51.         self.do_handshake_on_connect = do_handshake_on_connect
  52.         self.suppress_ragged_eofs = suppress_ragged_eofs
  53.         self._makefile_refs = 0
  54.  
  55.     
  56.     def read(self, len = 1024):
  57.         
  58.         try:
  59.             return self._sslobj.read(len)
  60.         except SSLError:
  61.             x = None
  62.             if x.args[0] == SSL_ERROR_EOF and self.suppress_ragged_eofs:
  63.                 return ''
  64.  
  65.  
  66.     
  67.     def write(self, data):
  68.         return self._sslobj.write(data)
  69.  
  70.     
  71.     def getpeercert(self, binary_form = False):
  72.         return self._sslobj.peer_certificate(binary_form)
  73.  
  74.     
  75.     def cipher(self):
  76.         if not self._sslobj:
  77.             return None
  78.         return None._sslobj.cipher()
  79.  
  80.     
  81.     def send(self, data, flags = 0):
  82.         if self._sslobj:
  83.             if flags != 0:
  84.                 raise ValueError('non-zero flags not allowed in calls to send() on %s' % self.__class__)
  85.             while True:
  86.                 
  87.                 try:
  88.                     v = self._sslobj.write(data)
  89.                 except SSLError:
  90.                     x = None
  91.                     if x.args[0] == SSL_ERROR_WANT_READ:
  92.                         return 0
  93.                     if None.args[0] == SSL_ERROR_WANT_WRITE:
  94.                         return 0
  95.                     continue
  96.  
  97.                 return v
  98.         else:
  99.             return self._sock.send(data, flags)
  100.  
  101.     
  102.     def sendto(self, data, flags_or_addr, addr = None):
  103.         if self._sslobj:
  104.             raise ValueError('sendto not allowed on instances of %s' % self.__class__)
  105.         if addr is None:
  106.             return self._sock.sendto(data, flags_or_addr)
  107.         return None._sock.sendto(data, flags_or_addr, addr)
  108.  
  109.     
  110.     def sendall(self, data, flags = 0):
  111.         if self._sslobj:
  112.             if flags != 0:
  113.                 raise ValueError('non-zero flags not allowed in calls to sendall() on %s' % self.__class__)
  114.             amount = len(data)
  115.             count = 0
  116.             while count < amount:
  117.                 v = self.send(data[count:])
  118.                 count += v
  119.             return amount
  120.         return None.sendall(self, data, flags)
  121.  
  122.     
  123.     def recv(self, buflen = 1024, flags = 0):
  124.         if self._sslobj:
  125.             if flags != 0:
  126.                 raise ValueError('non-zero flags not allowed in calls to recv() on %s' % self.__class__)
  127.             return self.read(buflen)
  128.         return None._sock.recv(buflen, flags)
  129.  
  130.     
  131.     def recv_into(self, buffer, nbytes = None, flags = 0):
  132.         if buffer and nbytes is None:
  133.             nbytes = len(buffer)
  134.         elif nbytes is None:
  135.             nbytes = 1024
  136.         if self._sslobj:
  137.             if flags != 0:
  138.                 raise ValueError('non-zero flags not allowed in calls to recv_into() on %s' % self.__class__)
  139.             tmp_buffer = self.read(nbytes)
  140.             v = len(tmp_buffer)
  141.             buffer[:v] = tmp_buffer
  142.             return v
  143.         return None._sock.recv_into(buffer, nbytes, flags)
  144.  
  145.     
  146.     def recvfrom(self, buflen = 1024, flags = 0):
  147.         if self._sslobj:
  148.             raise ValueError('recvfrom not allowed on instances of %s' % self.__class__)
  149.         return self._sock.recvfrom(buflen, flags)
  150.  
  151.     
  152.     def recvfrom_into(self, buffer, nbytes = None, flags = 0):
  153.         if self._sslobj:
  154.             raise ValueError('recvfrom_into not allowed on instances of %s' % self.__class__)
  155.         return self._sock.recvfrom_into(buffer, nbytes, flags)
  156.  
  157.     
  158.     def pending(self):
  159.         if self._sslobj:
  160.             return self._sslobj.pending()
  161.         return None
  162.  
  163.     
  164.     def unwrap(self):
  165.         if self._sslobj:
  166.             s = self._sslobj.shutdown()
  167.             self._sslobj = None
  168.             return s
  169.         raise None('No SSL wrapper around ' + str(self))
  170.  
  171.     
  172.     def shutdown(self, how):
  173.         self._sslobj = None
  174.         socket.shutdown(self, how)
  175.  
  176.     
  177.     def close(self):
  178.         pass
  179.  
  180.     
  181.     def do_handshake(self):
  182.         self._sslobj.do_handshake()
  183.  
  184.     
  185.     def connect(self, addr):
  186.         if self._sslobj:
  187.             raise ValueError('attempt to connect already-connected SSLSocket!')
  188.         socket.connect(self, addr)
  189.         self._sslobj = _ssl.sslwrap(self._sock, False, self.keyfile, self.certfile, self.cert_reqs, self.ssl_version, self.ca_certs, self.ciphers)
  190.         if self.do_handshake_on_connect:
  191.             self.do_handshake()
  192.  
  193.     
  194.     def accept(self):
  195.         (newsock, addr) = socket.accept(self)
  196.         return (SSLSocket(newsock, keyfile = self.keyfile, certfile = self.certfile, server_side = True, cert_reqs = self.cert_reqs, ssl_version = self.ssl_version, ca_certs = self.ca_certs, ciphers = self.ciphers, do_handshake_on_connect = self.do_handshake_on_connect, suppress_ragged_eofs = self.suppress_ragged_eofs), addr)
  197.  
  198.     
  199.     def makefile(self, mode = 'r', bufsize = -1):
  200.         self._makefile_refs += 1
  201.         return _fileobject(self, mode, bufsize, close = True)
  202.  
  203.  
  204.  
  205. def wrap_socket(sock, keyfile = None, certfile = None, server_side = False, cert_reqs = CERT_NONE, ssl_version = PROTOCOL_SSLv23, ca_certs = None, do_handshake_on_connect = True, suppress_ragged_eofs = True, ciphers = None):
  206.     return SSLSocket(sock, keyfile = keyfile, certfile = certfile, server_side = server_side, cert_reqs = cert_reqs, ssl_version = ssl_version, ca_certs = ca_certs, do_handshake_on_connect = do_handshake_on_connect, suppress_ragged_eofs = suppress_ragged_eofs, ciphers = ciphers)
  207.  
  208.  
  209. def cert_time_to_seconds(cert_time):
  210.     import time
  211.     return time.mktime(time.strptime(cert_time, '%b %d %H:%M:%S %Y GMT'))
  212.  
  213. PEM_HEADER = '-----BEGIN CERTIFICATE-----'
  214. PEM_FOOTER = '-----END CERTIFICATE-----'
  215.  
  216. def DER_cert_to_PEM_cert(der_cert_bytes):
  217.     if hasattr(base64, 'standard_b64encode'):
  218.         f = base64.standard_b64encode(der_cert_bytes)
  219.         return PEM_HEADER + '\n' + textwrap.fill(f, 64) + '\n' + PEM_FOOTER + '\n'
  220.     return None + '\n' + base64.encodestring(der_cert_bytes) + PEM_FOOTER + '\n'
  221.  
  222.  
  223. def PEM_cert_to_DER_cert(pem_cert_string):
  224.     if not pem_cert_string.startswith(PEM_HEADER):
  225.         raise ValueError('Invalid PEM encoding; must start with %s' % PEM_HEADER)
  226.     if not pem_cert_string.strip().endswith(PEM_FOOTER):
  227.         raise ValueError('Invalid PEM encoding; must end with %s' % PEM_FOOTER)
  228.     d = pem_cert_string.strip()[len(PEM_HEADER):-len(PEM_FOOTER)]
  229.     return base64.decodestring(d)
  230.  
  231.  
  232. def get_server_certificate(addr, ssl_version = PROTOCOL_SSLv3, ca_certs = None):
  233.     (host, port) = addr
  234.     if ca_certs is not None:
  235.         cert_reqs = CERT_REQUIRED
  236.     else:
  237.         cert_reqs = CERT_NONE
  238.     s = wrap_socket(socket(), ssl_version = ssl_version, cert_reqs = cert_reqs, ca_certs = ca_certs)
  239.     s.connect(addr)
  240.     dercert = s.getpeercert(True)
  241.     s.close()
  242.     return DER_cert_to_PEM_cert(dercert)
  243.  
  244.  
  245. def get_protocol_name(protocol_code):
  246.     if protocol_code == PROTOCOL_TLSv1:
  247.         return 'TLSv1'
  248.     if None == PROTOCOL_SSLv23:
  249.         return 'SSLv23'
  250.     if None == PROTOCOL_SSLv2:
  251.         return 'SSLv2'
  252.     if None == PROTOCOL_SSLv3:
  253.         return 'SSLv3'
  254.     return None
  255.  
  256.  
  257. def sslwrap_simple(sock, keyfile = None, certfile = None):
  258.     if hasattr(sock, '_sock'):
  259.         sock = sock._sock
  260.     ssl_sock = _ssl.sslwrap(sock, 0, keyfile, certfile, CERT_NONE, PROTOCOL_SSLv23, None)
  261.     
  262.     try:
  263.         sock.getpeername()
  264.     except socket_error:
  265.         pass
  266.  
  267.     ssl_sock.do_handshake()
  268.     return ssl_sock
  269.  
  270.