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