home *** CD-ROM | disk | FTP | other *** search
/ Freelog 116 / FreelogNo116-JuilletSeptembre2013.iso / Bureautique / gImageReader / gimagereader_0.9-1_win32.exe / bin / ssl.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2011-03-24  |  13KB  |  356 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.7)
  3.  
  4. '''This module provides some more Pythonic support for SSL.
  5.  
  6. Object types:
  7.  
  8.   SSLSocket -- subtype of socket.socket which does SSL over the socket
  9.  
  10. Exceptions:
  11.  
  12.   SSLError -- exception raised for I/O errors
  13.  
  14. Functions:
  15.  
  16.   cert_time_to_seconds -- convert time string used for certificate
  17.                           notBefore and notAfter functions to integer
  18.                           seconds past the Epoch (the time values
  19.                           returned from time.time())
  20.  
  21.   fetch_server_certificate (HOST, PORT) -- fetch the certificate provided
  22.                           by the server running on HOST at port PORT.  No
  23.                           validation of the certificate is performed.
  24.  
  25. Integer constants:
  26.  
  27. SSL_ERROR_ZERO_RETURN
  28. SSL_ERROR_WANT_READ
  29. SSL_ERROR_WANT_WRITE
  30. SSL_ERROR_WANT_X509_LOOKUP
  31. SSL_ERROR_SYSCALL
  32. SSL_ERROR_SSL
  33. SSL_ERROR_WANT_CONNECT
  34.  
  35. SSL_ERROR_EOF
  36. SSL_ERROR_INVALID_ERROR_CODE
  37.  
  38. The following group define certificate requirements that one side is
  39. allowing/requiring from the other side:
  40.  
  41. CERT_NONE - no certificates from the other side are required (or will
  42.             be looked at if provided)
  43. CERT_OPTIONAL - certificates are not required, but if provided will be
  44.                 validated, and if validation fails, the connection will
  45.                 also fail
  46. CERT_REQUIRED - certificates are required, and will be validated, and
  47.                 if validation fails, the connection will also fail
  48.  
  49. The following constants identify various SSL protocol variants:
  50.  
  51. PROTOCOL_SSLv2
  52. PROTOCOL_SSLv3
  53. PROTOCOL_SSLv23
  54. PROTOCOL_TLSv1
  55. '''
  56. import textwrap
  57. import _ssl
  58. from _ssl import OPENSSL_VERSION_NUMBER, OPENSSL_VERSION_INFO, OPENSSL_VERSION
  59. from _ssl import SSLError
  60. from _ssl import CERT_NONE, CERT_OPTIONAL, CERT_REQUIRED
  61. from _ssl import PROTOCOL_SSLv2, PROTOCOL_SSLv3, PROTOCOL_SSLv23, PROTOCOL_TLSv1
  62. from _ssl import RAND_status, RAND_egd, RAND_add
  63. 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
  64. from socket import socket, _fileobject, _delegate_methods, error as socket_error
  65. from socket import getnameinfo as _getnameinfo
  66. import base64
  67. import errno
  68.  
  69. class SSLSocket(socket):
  70.     '''This class implements a subtype of socket.socket that wraps
  71.     the underlying OS socket in an SSL context when necessary, and
  72.     provides read and write methods over that channel.'''
  73.     
  74.     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):
  75.         socket.__init__(self, _sock = sock._sock)
  76.         for attr in _delegate_methods:
  77.             
  78.             try:
  79.                 delattr(self, attr)
  80.             continue
  81.             except AttributeError:
  82.                 continue
  83.             
  84.  
  85.         
  86.         if certfile and not keyfile:
  87.             keyfile = certfile
  88.         
  89.         try:
  90.             socket.getpeername(self)
  91.         except socket_error:
  92.             e = None
  93.             if e.errno != errno.ENOTCONN:
  94.                 raise 
  95.             self._sslobj = None
  96.  
  97.         self._sslobj = _ssl.sslwrap(self._sock, server_side, keyfile, certfile, cert_reqs, ssl_version, ca_certs, ciphers)
  98.         if do_handshake_on_connect:
  99.             self.do_handshake()
  100.         self.keyfile = keyfile
  101.         self.certfile = certfile
  102.         self.cert_reqs = cert_reqs
  103.         self.ssl_version = ssl_version
  104.         self.ca_certs = ca_certs
  105.         self.ciphers = ciphers
  106.         self.do_handshake_on_connect = do_handshake_on_connect
  107.         self.suppress_ragged_eofs = suppress_ragged_eofs
  108.         self._makefile_refs = 0
  109.  
  110.     
  111.     def read(self, len = 1024):
  112.         '''Read up to LEN bytes and return them.
  113.         Return zero-length string on EOF.'''
  114.         
  115.         try:
  116.             return self._sslobj.read(len)
  117.         except SSLError:
  118.             x = None
  119.             if x.args[0] == SSL_ERROR_EOF and self.suppress_ragged_eofs:
  120.                 return ''
  121.  
  122.  
  123.     
  124.     def write(self, data):
  125.         '''Write DATA to the underlying SSL channel.  Returns
  126.         number of bytes of DATA actually transmitted.'''
  127.         return self._sslobj.write(data)
  128.  
  129.     
  130.     def getpeercert(self, binary_form = False):
  131.         '''Returns a formatted version of the data in the
  132.         certificate provided by the other end of the SSL channel.
  133.         Return None if no certificate was provided, {} if a
  134.         certificate was provided, but not validated.'''
  135.         return self._sslobj.peer_certificate(binary_form)
  136.  
  137.     
  138.     def cipher(self):
  139.         if not self._sslobj:
  140.             return None
  141.         return None._sslobj.cipher()
  142.  
  143.     
  144.     def send(self, data, flags = 0):
  145.         if self._sslobj:
  146.             if flags != 0:
  147.                 raise ValueError('non-zero flags not allowed in calls to send() on %s' % self.__class__)
  148.             while True:
  149.                 
  150.                 try:
  151.                     v = self._sslobj.write(data)
  152.                 except SSLError:
  153.                     x = None
  154.                     if x.args[0] == SSL_ERROR_WANT_READ:
  155.                         return 0
  156.                     if None.args[0] == SSL_ERROR_WANT_WRITE:
  157.                         return 0
  158.                     continue
  159.  
  160.                 return v
  161.         else:
  162.             return self._sock.send(data, flags)
  163.  
  164.     
  165.     def sendto(self, data, flags_or_addr, addr = None):
  166.         if self._sslobj:
  167.             raise ValueError('sendto not allowed on instances of %s' % self.__class__)
  168.         if addr is None:
  169.             return self._sock.sendto(data, flags_or_addr)
  170.         return None._sock.sendto(data, flags_or_addr, addr)
  171.  
  172.     
  173.     def sendall(self, data, flags = 0):
  174.         if self._sslobj:
  175.             if flags != 0:
  176.                 raise ValueError('non-zero flags not allowed in calls to sendall() on %s' % self.__class__)
  177.             amount = len(data)
  178.             count = 0
  179.             while count < amount:
  180.                 v = self.send(data[count:])
  181.                 count += v
  182.             return amount
  183.         return None.sendall(self, data, flags)
  184.  
  185.     
  186.     def recv(self, buflen = 1024, flags = 0):
  187.         if self._sslobj:
  188.             if flags != 0:
  189.                 raise ValueError('non-zero flags not allowed in calls to recv() on %s' % self.__class__)
  190.             return self.read(buflen)
  191.         return None._sock.recv(buflen, flags)
  192.  
  193.     
  194.     def recv_into(self, buffer, nbytes = None, flags = 0):
  195.         if buffer and nbytes is None:
  196.             nbytes = len(buffer)
  197.         elif nbytes is None:
  198.             nbytes = 1024
  199.         if self._sslobj:
  200.             if flags != 0:
  201.                 raise ValueError('non-zero flags not allowed in calls to recv_into() on %s' % self.__class__)
  202.             tmp_buffer = self.read(nbytes)
  203.             v = len(tmp_buffer)
  204.             buffer[:v] = tmp_buffer
  205.             return v
  206.         return None._sock.recv_into(buffer, nbytes, flags)
  207.  
  208.     
  209.     def recvfrom(self, buflen = 1024, flags = 0):
  210.         if self._sslobj:
  211.             raise ValueError('recvfrom not allowed on instances of %s' % self.__class__)
  212.         return self._sock.recvfrom(buflen, flags)
  213.  
  214.     
  215.     def recvfrom_into(self, buffer, nbytes = None, flags = 0):
  216.         if self._sslobj:
  217.             raise ValueError('recvfrom_into not allowed on instances of %s' % self.__class__)
  218.         return self._sock.recvfrom_into(buffer, nbytes, flags)
  219.  
  220.     
  221.     def pending(self):
  222.         if self._sslobj:
  223.             return self._sslobj.pending()
  224.         return None
  225.  
  226.     
  227.     def unwrap(self):
  228.         if self._sslobj:
  229.             s = self._sslobj.shutdown()
  230.             self._sslobj = None
  231.             return s
  232.         raise None('No SSL wrapper around ' + str(self))
  233.  
  234.     
  235.     def shutdown(self, how):
  236.         self._sslobj = None
  237.         socket.shutdown(self, how)
  238.  
  239.     
  240.     def close(self):
  241.         pass
  242.  
  243.     
  244.     def do_handshake(self):
  245.         '''Perform a TLS/SSL handshake.'''
  246.         self._sslobj.do_handshake()
  247.  
  248.     
  249.     def connect(self, addr):
  250.         '''Connects to remote ADDR, and then wraps the connection in
  251.         an SSL channel.'''
  252.         if self._sslobj:
  253.             raise ValueError('attempt to connect already-connected SSLSocket!')
  254.         socket.connect(self, addr)
  255.         self._sslobj = _ssl.sslwrap(self._sock, False, self.keyfile, self.certfile, self.cert_reqs, self.ssl_version, self.ca_certs, self.ciphers)
  256.         if self.do_handshake_on_connect:
  257.             self.do_handshake()
  258.  
  259.     
  260.     def accept(self):
  261.         '''Accepts a new connection from a remote client, and returns
  262.         a tuple containing that new connection wrapped with a server-side
  263.         SSL channel, and the address of the remote client.'''
  264.         (newsock, addr) = socket.accept(self)
  265.         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)
  266.  
  267.     
  268.     def makefile(self, mode = 'r', bufsize = -1):
  269.         '''Make and return a file-like object that
  270.         works with the SSL connection.  Just use the code
  271.         from the socket module.'''
  272.         self._makefile_refs += 1
  273.         return _fileobject(self, mode, bufsize, close = True)
  274.  
  275.  
  276.  
  277. 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):
  278.     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)
  279.  
  280.  
  281. def cert_time_to_seconds(cert_time):
  282.     '''Takes a date-time string in standard ASN1_print form
  283.     ("MON DAY 24HOUR:MINUTE:SEC YEAR TIMEZONE") and return
  284.     a Python time value in seconds past the epoch.'''
  285.     import time as time
  286.     return time.mktime(time.strptime(cert_time, '%b %d %H:%M:%S %Y GMT'))
  287.  
  288. PEM_HEADER = '-----BEGIN CERTIFICATE-----'
  289. PEM_FOOTER = '-----END CERTIFICATE-----'
  290.  
  291. def DER_cert_to_PEM_cert(der_cert_bytes):
  292.     '''Takes a certificate in binary DER format and returns the
  293.     PEM version of it as a string.'''
  294.     if hasattr(base64, 'standard_b64encode'):
  295.         f = base64.standard_b64encode(der_cert_bytes)
  296.         return PEM_HEADER + '\n' + textwrap.fill(f, 64) + '\n' + PEM_FOOTER + '\n'
  297.     return None + '\n' + base64.encodestring(der_cert_bytes) + PEM_FOOTER + '\n'
  298.  
  299.  
  300. def PEM_cert_to_DER_cert(pem_cert_string):
  301.     '''Takes a certificate in ASCII PEM format and returns the
  302.     DER-encoded version of it as a byte sequence'''
  303.     if not pem_cert_string.startswith(PEM_HEADER):
  304.         raise ValueError('Invalid PEM encoding; must start with %s' % PEM_HEADER)
  305.     if not pem_cert_string.strip().endswith(PEM_FOOTER):
  306.         raise ValueError('Invalid PEM encoding; must end with %s' % PEM_FOOTER)
  307.     d = pem_cert_string.strip()[len(PEM_HEADER):-len(PEM_FOOTER)]
  308.     return base64.decodestring(d)
  309.  
  310.  
  311. def get_server_certificate(addr, ssl_version = PROTOCOL_SSLv3, ca_certs = None):
  312.     """Retrieve the certificate from the server at the specified address,
  313.     and return it as a PEM-encoded string.
  314.     If 'ca_certs' is specified, validate the server cert against it.
  315.     If 'ssl_version' is specified, use it in the connection attempt."""
  316.     (host, port) = addr
  317.     if ca_certs is not None:
  318.         cert_reqs = CERT_REQUIRED
  319.     else:
  320.         cert_reqs = CERT_NONE
  321.     s = wrap_socket(socket(), ssl_version = ssl_version, cert_reqs = cert_reqs, ca_certs = ca_certs)
  322.     s.connect(addr)
  323.     dercert = s.getpeercert(True)
  324.     s.close()
  325.     return DER_cert_to_PEM_cert(dercert)
  326.  
  327.  
  328. def get_protocol_name(protocol_code):
  329.     if protocol_code == PROTOCOL_TLSv1:
  330.         return 'TLSv1'
  331.     if None == PROTOCOL_SSLv23:
  332.         return 'SSLv23'
  333.     if None == PROTOCOL_SSLv2:
  334.         return 'SSLv2'
  335.     if None == PROTOCOL_SSLv3:
  336.         return 'SSLv3'
  337.     return None
  338.  
  339.  
  340. def sslwrap_simple(sock, keyfile = None, certfile = None):
  341.     '''A replacement for the old socket.ssl function.  Designed
  342.     for compability with Python 2.5 and earlier.  Will disappear in
  343.     Python 3.0.'''
  344.     if hasattr(sock, '_sock'):
  345.         sock = sock._sock
  346.     ssl_sock = _ssl.sslwrap(sock, 0, keyfile, certfile, CERT_NONE, PROTOCOL_SSLv23, None)
  347.     
  348.     try:
  349.         sock.getpeername()
  350.     except socket_error:
  351.         pass
  352.  
  353.     ssl_sock.do_handshake()
  354.     return ssl_sock
  355.  
  356.