home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-9.10-netbook-remix-PL.iso / casper / filesystem.squashfs / usr / lib / python2.6 / ssl.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-11-11  |  14.3 KB  |  410 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  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 SSLError
  59. from _ssl import CERT_NONE, CERT_OPTIONAL, CERT_REQUIRED
  60. from _ssl import PROTOCOL_SSLv2, PROTOCOL_SSLv3, PROTOCOL_SSLv23, PROTOCOL_TLSv1
  61. from _ssl import RAND_status, RAND_egd, RAND_add
  62. 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
  63. from socket import socket, _fileobject
  64. from socket import getnameinfo as _getnameinfo
  65. import base64
  66.  
  67. class SSLSocket(socket):
  68.     '''This class implements a subtype of socket.socket that wraps
  69.     the underlying OS socket in an SSL context when necessary, and
  70.     provides read and write methods over that channel.'''
  71.     
  72.     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):
  73.         socket.__init__(self, _sock = sock._sock)
  74.         
  75.         self.send = lambda data, flags = (0,): SSLSocket.send(self, data, flags)
  76.         
  77.         self.sendto = lambda data, addr, flags = (0,): SSLSocket.sendto(self, data, addr, flags)
  78.         
  79.         self.recv = lambda buflen = 1024, flags = (0,): SSLSocket.recv(self, buflen, flags)
  80.         
  81.         self.recvfrom = lambda addr, buflen = 1024, flags = (0,): SSLSocket.recvfrom(self, addr, buflen, flags)
  82.         
  83.         self.recv_into = lambda buffer, nbytes = None, flags = (0,): SSLSocket.recv_into(self, buffer, nbytes, flags)
  84.         
  85.         self.recvfrom_into = lambda buffer, nbytes = None, flags = (0,): SSLSocket.recvfrom_into(self, buffer, nbytes, flags)
  86.         if certfile and not keyfile:
  87.             keyfile = certfile
  88.         
  89.         
  90.         try:
  91.             socket.getpeername(self)
  92.         except:
  93.             self._sslobj = None
  94.  
  95.         self._sslobj = _ssl.sslwrap(self._sock, server_side, keyfile, certfile, cert_reqs, ssl_version, ca_certs)
  96.         if do_handshake_on_connect:
  97.             timeout = self.gettimeout()
  98.             
  99.             try:
  100.                 self.settimeout(None)
  101.                 self.do_handshake()
  102.             finally:
  103.                 self.settimeout(timeout)
  104.  
  105.         
  106.         self.keyfile = keyfile
  107.         self.certfile = certfile
  108.         self.cert_reqs = cert_reqs
  109.         self.ssl_version = ssl_version
  110.         self.ca_certs = ca_certs
  111.         self.do_handshake_on_connect = do_handshake_on_connect
  112.         self.suppress_ragged_eofs = suppress_ragged_eofs
  113.         self._makefile_refs = 0
  114.  
  115.     
  116.     def read(self, len = 1024):
  117.         '''Read up to LEN bytes and return them.
  118.         Return zero-length string on EOF.'''
  119.         
  120.         try:
  121.             return self._sslobj.read(len)
  122.         except SSLError:
  123.             x = None
  124.             if x.args[0] == SSL_ERROR_EOF and self.suppress_ragged_eofs:
  125.                 return ''
  126.             raise 
  127.         except:
  128.             self.suppress_ragged_eofs
  129.  
  130.  
  131.     
  132.     def write(self, data):
  133.         '''Write DATA to the underlying SSL channel.  Returns
  134.         number of bytes of DATA actually transmitted.'''
  135.         return self._sslobj.write(data)
  136.  
  137.     
  138.     def getpeercert(self, binary_form = False):
  139.         '''Returns a formatted version of the data in the
  140.         certificate provided by the other end of the SSL channel.
  141.         Return None if no certificate was provided, {} if a
  142.         certificate was provided, but not validated.'''
  143.         return self._sslobj.peer_certificate(binary_form)
  144.  
  145.     
  146.     def cipher(self):
  147.         if not self._sslobj:
  148.             return None
  149.         return self._sslobj.cipher()
  150.  
  151.     
  152.     def send(self, data, flags = 0):
  153.         if self._sslobj:
  154.             if flags != 0:
  155.                 raise ValueError('non-zero flags not allowed in calls to send() on %s' % self.__class__)
  156.             flags != 0
  157.             while True:
  158.                 
  159.                 try:
  160.                     v = self._sslobj.write(data)
  161.                 except SSLError:
  162.                     x = None
  163.                     if x.args[0] == SSL_ERROR_WANT_READ:
  164.                         return 0
  165.                     if x.args[0] == SSL_ERROR_WANT_WRITE:
  166.                         return 0
  167.                     raise 
  168.                     continue
  169.                     x.args[0] == SSL_ERROR_WANT_WRITE
  170.  
  171.                 return v
  172.         else:
  173.             return socket.send(self, data, flags)
  174.         return self._sslobj
  175.  
  176.     
  177.     def sendto(self, data, addr, flags = 0):
  178.         if self._sslobj:
  179.             raise ValueError('sendto not allowed on instances of %s' % self.__class__)
  180.         self._sslobj
  181.         return socket.sendto(self, data, addr, flags)
  182.  
  183.     
  184.     def sendall(self, data, flags = 0):
  185.         if self._sslobj:
  186.             if flags != 0:
  187.                 raise ValueError('non-zero flags not allowed in calls to sendall() on %s' % self.__class__)
  188.             flags != 0
  189.             amount = len(data)
  190.             count = 0
  191.             while count < amount:
  192.                 v = self.send(data[count:])
  193.                 count += v
  194.             return amount
  195.         return socket.sendall(self, data, flags)
  196.  
  197.     
  198.     def recv(self, buflen = 1024, flags = 0):
  199.         if self._sslobj:
  200.             if flags != 0:
  201.                 raise ValueError('non-zero flags not allowed in calls to sendall() on %s' % self.__class__)
  202.             flags != 0
  203.             while True:
  204.                 
  205.                 try:
  206.                     return self.read(buflen)
  207.                 continue
  208.                 except SSLError:
  209.                     x = None
  210.                     if x.args[0] == SSL_ERROR_WANT_READ:
  211.                         continue
  212.                     else:
  213.                         raise x
  214.                     x.args[0] == SSL_ERROR_WANT_READ
  215.                 
  216.  
  217.                 None<EXCEPTION MATCH>SSLError
  218.         else:
  219.             return socket.recv(self, buflen, flags)
  220.         return self._sslobj
  221.  
  222.     
  223.     def recv_into(self, buffer, nbytes = None, flags = 0):
  224.         if buffer and nbytes is None:
  225.             nbytes = len(buffer)
  226.         elif nbytes is None:
  227.             nbytes = 1024
  228.         
  229.         if self._sslobj:
  230.             if flags != 0:
  231.                 raise ValueError('non-zero flags not allowed in calls to recv_into() on %s' % self.__class__)
  232.             flags != 0
  233.             while True:
  234.                 
  235.                 try:
  236.                     tmp_buffer = self.read(nbytes)
  237.                     v = len(tmp_buffer)
  238.                     buffer[:v] = tmp_buffer
  239.                     return v
  240.                 continue
  241.                 except SSLError:
  242.                     x = None
  243.                     if x.args[0] == SSL_ERROR_WANT_READ:
  244.                         continue
  245.                     else:
  246.                         raise x
  247.                     x.args[0] == SSL_ERROR_WANT_READ
  248.                 
  249.  
  250.                 None<EXCEPTION MATCH>SSLError
  251.         else:
  252.             return socket.recv_into(self, buffer, nbytes, flags)
  253.         return self._sslobj
  254.  
  255.     
  256.     def recvfrom(self, addr, buflen = 1024, flags = 0):
  257.         if self._sslobj:
  258.             raise ValueError('recvfrom not allowed on instances of %s' % self.__class__)
  259.         self._sslobj
  260.         return socket.recvfrom(self, addr, buflen, flags)
  261.  
  262.     
  263.     def recvfrom_into(self, buffer, nbytes = None, flags = 0):
  264.         if self._sslobj:
  265.             raise ValueError('recvfrom_into not allowed on instances of %s' % self.__class__)
  266.         self._sslobj
  267.         return socket.recvfrom_into(self, buffer, nbytes, flags)
  268.  
  269.     
  270.     def pending(self):
  271.         if self._sslobj:
  272.             return self._sslobj.pending()
  273.         return 0
  274.  
  275.     
  276.     def unwrap(self):
  277.         if self._sslobj:
  278.             s = self._sslobj.shutdown()
  279.             self._sslobj = None
  280.             return s
  281.         raise ValueError('No SSL wrapper around ' + str(self))
  282.  
  283.     
  284.     def shutdown(self, how):
  285.         self._sslobj = None
  286.         socket.shutdown(self, how)
  287.  
  288.     
  289.     def close(self):
  290.         pass
  291.  
  292.     
  293.     def do_handshake(self):
  294.         '''Perform a TLS/SSL handshake.'''
  295.         self._sslobj.do_handshake()
  296.  
  297.     
  298.     def connect(self, addr):
  299.         '''Connects to remote ADDR, and then wraps the connection in
  300.         an SSL channel.'''
  301.         if self._sslobj:
  302.             raise ValueError('attempt to connect already-connected SSLSocket!')
  303.         self._sslobj
  304.         socket.connect(self, addr)
  305.         self._sslobj = _ssl.sslwrap(self._sock, False, self.keyfile, self.certfile, self.cert_reqs, self.ssl_version, self.ca_certs)
  306.         if self.do_handshake_on_connect:
  307.             self.do_handshake()
  308.         
  309.  
  310.     
  311.     def accept(self):
  312.         '''Accepts a new connection from a remote client, and returns
  313.         a tuple containing that new connection wrapped with a server-side
  314.         SSL channel, and the address of the remote client.'''
  315.         (newsock, addr) = socket.accept(self)
  316.         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)
  317.  
  318.     
  319.     def makefile(self, mode = 'r', bufsize = -1):
  320.         '''Make and return a file-like object that
  321.         works with the SSL connection.  Just use the code
  322.         from the socket module.'''
  323.         self._makefile_refs += 1
  324.         return _fileobject(self, mode, bufsize)
  325.  
  326.  
  327.  
  328. 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):
  329.     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)
  330.  
  331.  
  332. def cert_time_to_seconds(cert_time):
  333.     '''Takes a date-time string in standard ASN1_print form
  334.     ("MON DAY 24HOUR:MINUTE:SEC YEAR TIMEZONE") and return
  335.     a Python time value in seconds past the epoch.'''
  336.     import time
  337.     return time.mktime(time.strptime(cert_time, '%b %d %H:%M:%S %Y GMT'))
  338.  
  339. PEM_HEADER = '-----BEGIN CERTIFICATE-----'
  340. PEM_FOOTER = '-----END CERTIFICATE-----'
  341.  
  342. def DER_cert_to_PEM_cert(der_cert_bytes):
  343.     '''Takes a certificate in binary DER format and returns the
  344.     PEM version of it as a string.'''
  345.     if hasattr(base64, 'standard_b64encode'):
  346.         f = base64.standard_b64encode(der_cert_bytes)
  347.         return PEM_HEADER + '\n' + textwrap.fill(f, 64) + PEM_FOOTER + '\n'
  348.     return PEM_HEADER + '\n' + base64.encodestring(der_cert_bytes) + PEM_FOOTER + '\n'
  349.  
  350.  
  351. def PEM_cert_to_DER_cert(pem_cert_string):
  352.     '''Takes a certificate in ASCII PEM format and returns the
  353.     DER-encoded version of it as a byte sequence'''
  354.     if not pem_cert_string.startswith(PEM_HEADER):
  355.         raise ValueError('Invalid PEM encoding; must start with %s' % PEM_HEADER)
  356.     pem_cert_string.startswith(PEM_HEADER)
  357.     if not pem_cert_string.strip().endswith(PEM_FOOTER):
  358.         raise ValueError('Invalid PEM encoding; must end with %s' % PEM_FOOTER)
  359.     pem_cert_string.strip().endswith(PEM_FOOTER)
  360.     d = pem_cert_string.strip()[len(PEM_HEADER):-len(PEM_FOOTER)]
  361.     return base64.decodestring(d)
  362.  
  363.  
  364. def get_server_certificate(addr, ssl_version = PROTOCOL_SSLv3, ca_certs = None):
  365.     """Retrieve the certificate from the server at the specified address,
  366.     and return it as a PEM-encoded string.
  367.     If 'ca_certs' is specified, validate the server cert against it.
  368.     If 'ssl_version' is specified, use it in the connection attempt."""
  369.     (host, port) = addr
  370.     if ca_certs is not None:
  371.         cert_reqs = CERT_REQUIRED
  372.     else:
  373.         cert_reqs = CERT_NONE
  374.     s = wrap_socket(socket(), ssl_version = ssl_version, cert_reqs = cert_reqs, ca_certs = ca_certs)
  375.     s.connect(addr)
  376.     dercert = s.getpeercert(True)
  377.     s.close()
  378.     return DER_cert_to_PEM_cert(dercert)
  379.  
  380.  
  381. def get_protocol_name(protocol_code):
  382.     if protocol_code == PROTOCOL_TLSv1:
  383.         return 'TLSv1'
  384.     if protocol_code == PROTOCOL_SSLv23:
  385.         return 'SSLv23'
  386.     if protocol_code == PROTOCOL_SSLv2:
  387.         return 'SSLv2'
  388.     if protocol_code == PROTOCOL_SSLv3:
  389.         return 'SSLv3'
  390.     return '<unknown>'
  391.  
  392.  
  393. def sslwrap_simple(sock, keyfile = None, certfile = None):
  394.     '''A replacement for the old socket.ssl function.  Designed
  395.     for compability with Python 2.5 and earlier.  Will disappear in
  396.     Python 3.0.'''
  397.     if hasattr(sock, '_sock'):
  398.         sock = sock._sock
  399.     
  400.     ssl_sock = _ssl.sslwrap(sock, 0, keyfile, certfile, CERT_NONE, PROTOCOL_SSLv23, None)
  401.     
  402.     try:
  403.         sock.getpeername()
  404.     except:
  405.         pass
  406.  
  407.     ssl_sock.do_handshake()
  408.     return ssl_sock
  409.  
  410.