;
Êâ"Ic               @   s£  d  Z  d d l Z d d l Z d d l m Z d d l m Z m Z m Z d d l m Z m Z m	 Z	 m
 Z
 d d l m Z m Z m Z d d l m Z m Z m Z m Z m Z m Z m Z m Z m Z d d l m Z d d	 l m Z d d
 l m Z d d l m Z m Z m Z d d l  Z  d d l! Z! Gd „  d e ƒ Z" e# e# e$ e e	 e# e% e% d „ Z& d „  Z' d Z( d Z) d „  Z* d „  Z+ e e# d „ Z, d „  Z- d S(   u  This module provides some more Pythonic support for SSL.

Object types:

  SSLSocket -- subtype of socket.socket which does SSL over the socket

Exceptions:

  SSLError -- exception raised for I/O errors

Functions:

  cert_time_to_seconds -- convert time string used for certificate
                          notBefore and notAfter functions to integer
                          seconds past the Epoch (the time values
                          returned from time.time())

  fetch_server_certificate (HOST, PORT) -- fetch the certificate provided
                          by the server running on HOST at port PORT.  No
                          validation of the certificate is performed.

Integer constants:

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

The following group define certificate requirements that one side is
allowing/requiring from the other side:

CERT_NONE - no certificates from the other side are required (or will
            be looked at if provided)
CERT_OPTIONAL - certificates are not required, but if provided will be
                validated, and if validation fails, the connection will
                also fail
CERT_REQUIRED - certificates are required, and will be validated, and
                if validation fails, the connection will also fail

The following constants identify various SSL protocol variants:

PROTOCOL_SSLv2
PROTOCOL_SSLv3
PROTOCOL_SSLv23
PROTOCOL_TLSv1
i    N(   u   SSLError(   u	   CERT_NONEu   CERT_OPTIONALu   CERT_REQUIRED(   u   PROTOCOL_SSLv2u   PROTOCOL_SSLv3u   PROTOCOL_SSLv23u   PROTOCOL_TLSv1(   u   RAND_statusu   RAND_egdu   RAND_add(	   u   SSL_ERROR_ZERO_RETURNu   SSL_ERROR_WANT_READu   SSL_ERROR_WANT_WRITEu   SSL_ERROR_WANT_X509_LOOKUPu   SSL_ERROR_SYSCALLu   SSL_ERROR_SSLu   SSL_ERROR_WANT_CONNECTu   SSL_ERROR_EOFu   SSL_ERROR_INVALID_ERROR_CODE(   u   getnameinfo(   u   error(   u   dup(   u   socketu   AF_INETu   SOCK_STREAMc             B   s1  |  Ee  Z d  Z d d d d e e d d e e	 d d d d „ Z
 d „  Z d d „ Z d d d „ Z d „  Z d d „ Z d „  Z d d	 „ Z d d
 „ Z d d „ Z d d d „ Z d d d „ Z d d d „ Z d d d „ Z d „  Z d „  Z d „  Z d „  Z d d „ Z d „  Z d „  Z d „  Z d S(   uµ   This class implements a subtype of socket.socket that wraps
    the underlying OS socket in an SSL context when necessary, and
    provides read and write methods over that channel.i    c             C   sÂ  | d  k	 oH t j |  d | j d | j d | j d t | j ƒ  ƒ ƒ| j ƒ  nD | d  k	 o t j |  d | ƒn  t j |  d |	 d |
 d | ƒd |  _
 | o | o
 | } n y t j |  ƒ Wn d  |  _ Yn¡ Xyf t j |  | | | | | | ƒ |  _ | o7 |  j ƒ  } | d k o t d ƒ ‚ n |  j ƒ  n Wn7 t k
 o+ } z |  j ƒ  | ‚ WYd  d  } ~ Xn X| |  _ | |  _ | |  _ | |  _ | |  _ | |  _ | |  _ d  S(   Nu   familyu   typeu   protou   filenog        uH   do_handshake_on_connect should not be specified for non-blocking socketsF(   u   Noneu   socketu   __init__u   familyu   typeu   protou   _dupu   filenou   closeu   Falseu   _closedu   getpeernameu   _sslobju   _sslu   sslwrapu
   gettimeoutu
   ValueErroru   do_handshakeu   socket_erroru   keyfileu   certfileu	   cert_reqsu   ssl_versionu   ca_certsu   do_handshake_on_connectu   suppress_ragged_eofs(   u   selfu   socku   keyfileu   certfileu   server_sideu	   cert_reqsu   ssl_versionu   ca_certsu   do_handshake_on_connectu   familyu   typeu   protou   filenou   suppress_ragged_eofsu   timeoutu   x(    (    u    /mit/python/lib/python3.0/ssl.pyu   __init__[   sH    				

						c             C   s   t  d |  j j ƒ ‚ d  S(   Nu   Can't dup() %s instances(   u   NotImplementedu	   __class__u   __name__(   u   self(    (    u    /mit/python/lib/python3.0/ssl.pyu   dup‘   s    c             C   s   d  S(   N(    (   u   selfu   msg(    (    u    /mit/python/lib/python3.0/ssl.pyu   _checkClosed•   s    c             C   s®   |  j  ƒ  yA | o |  j j | | ƒ } n |  j j | p d ƒ } | SWn\ t k
 oP } z: | j d t k o |  j o | o d Sd Sn ‚  WYd d } ~ Xn Xd S(   uO   Read up to LEN bytes and return them.
        Return zero-length string on EOF.i   i    s    N(   u   _checkClosedu   _sslobju   readu   SSLErroru   argsu   SSL_ERROR_EOFu   suppress_ragged_eofs(   u   selfu   lenu   bufferu   vu   x(    (    u    /mit/python/lib/python3.0/ssl.pyu   read™   s    
c             C   s   |  j  ƒ  |  j j | ƒ S(   uh   Write DATA to the underlying SSL channel.  Returns
        number of bytes of DATA actually transmitted.(   u   _checkClosedu   _sslobju   write(   u   selfu   data(    (    u    /mit/python/lib/python3.0/ssl.pyu   write­   s    
c             C   s   |  j  ƒ  |  j j | ƒ S(   uá   Returns a formatted version of the data in the
        certificate provided by the other end of the SSL channel.
        Return None if no certificate was provided, {} if a
        certificate was provided, but not validated.(   u   _checkClosedu   _sslobju   peer_certificate(   u   selfu   binary_form(    (    u    /mit/python/lib/python3.0/ssl.pyu   getpeercert´   s    
c             C   s*   |  j  ƒ  |  j p d  S|  j j ƒ  Sd  S(   N(   u   _checkClosedu   _sslobju   Noneu   cipher(   u   self(    (    u    /mit/python/lib/python3.0/ssl.pyu   cipher½   s    

c             C   sÒ   |  j  ƒ  |  j o§ | d k o t d |  j ƒ ‚ n x“ y |  j j | ƒ } Wn\ t k
 oP } z: | j d t k o d S| j d t k o d S‚  WYd  d  } ~ Xq; X| Sq; n t	 j
 |  | | ƒ Sd  S(   Ni    u3   non-zero flags not allowed in calls to send() on %s(   u   _checkClosedu   _sslobju
   ValueErroru	   __class__u   writeu   SSLErroru   argsu   SSL_ERROR_WANT_READu   SSL_ERROR_WANT_WRITEu   socketu   send(   u   selfu   datau   flagsu   vu   x(    (    u    /mit/python/lib/python3.0/ssl.pyu   sendÄ   s"    

c             C   sE   |  j  ƒ  |  j o t d |  j ƒ ‚ n t j |  | | | ƒ Sd  S(   Nu%   sendto not allowed on instances of %s(   u   _checkClosedu   _sslobju
   ValueErroru	   __class__u   socketu   sendto(   u   selfu   datau   addru   flags(    (    u    /mit/python/lib/python3.0/ssl.pyu   sendtoÚ   s
    

c             C   sz   |  j  ƒ  |  j oO t | ƒ } d } x5 | | k  o' |  j | | d  … ƒ } | | 7} q) W| St j |  | | ƒ Sd  S(   Ni    (   u   _checkClosedu   _sslobju   lenu   sendu   socketu   sendall(   u   selfu   datau   flagsu   amountu   countu   v(    (    u    /mit/python/lib/python3.0/ssl.pyu   sendallâ   s    

 i   c             C   sµ   |  j  ƒ  |  j oŠ | d k o t d |  j ƒ ‚ n xv y |  j | ƒ SWq; t k
 o< } z& | j d t k o w; n | ‚ WYd  d  } ~ Xq; Xq; n t j	 |  | | ƒ Sd  S(   Ni    u8   non-zero flags not allowed in calls to recv_into() on %s(
   u   _checkClosedu   _sslobju
   ValueErroru	   __class__u   readu   SSLErroru   argsu   SSL_ERROR_WANT_READu   socketu   recv(   u   selfu   buflenu   flagsu   x(    (    u    /mit/python/lib/python3.0/ssl.pyu   recvî   s    

!c             C   sü   |  j  ƒ  | o | d  k o t | ƒ } n | d  k o
 d } n |  j o“ | d k o t d |  j ƒ ‚ n x‚ y |  j | | ƒ } | SWqv t k
 o< } z& | j d t	 k o wv n | ‚ WYd  d  } ~ Xqv Xqv n t
 j |  | | | ƒ Sd  S(   Ni   i    u8   non-zero flags not allowed in calls to recv_into() on %s(   u   _checkClosedu   Noneu   lenu   _sslobju
   ValueErroru	   __class__u   readu   SSLErroru   argsu   SSL_ERROR_WANT_READu   socketu	   recv_into(   u   selfu   bufferu   nbytesu   flagsu   vu   x(    (    u    /mit/python/lib/python3.0/ssl.pyu	   recv_into   s&    


!c             C   sE   |  j  ƒ  |  j o t d |  j ƒ ‚ n t j |  | | | ƒ Sd  S(   Nu'   recvfrom not allowed on instances of %s(   u   _checkClosedu   _sslobju
   ValueErroru	   __class__u   socketu   recvfrom(   u   selfu   addru   buflenu   flags(    (    u    /mit/python/lib/python3.0/ssl.pyu   recvfrom  s
    

c             C   sE   |  j  ƒ  |  j o t d |  j ƒ ‚ n t j |  | | | ƒ Sd  S(   Nu,   recvfrom_into not allowed on instances of %s(   u   _checkClosedu   _sslobju
   ValueErroru	   __class__u   socketu   recvfrom_into(   u   selfu   bufferu   nbytesu   flags(    (    u    /mit/python/lib/python3.0/ssl.pyu   recvfrom_into  s
    

c             C   s*   |  j  ƒ  |  j o |  j j ƒ  Sd Sd  S(   Ni    (   u   _checkClosedu   _sslobju   pending(   u   self(    (    u    /mit/python/lib/python3.0/ssl.pyu   pending'  s    

c             C   s'   |  j  ƒ  d  |  _ t j |  | ƒ d  S(   N(   u   _checkClosedu   Noneu   _sslobju   socketu   shutdown(   u   selfu   how(    (    u    /mit/python/lib/python3.0/ssl.pyu   shutdown.  s    
	c             C   sA   |  j  o |  j  j ƒ  } d  |  _  | St d t |  ƒ ƒ ‚ d  S(   Nu   No SSL wrapper around (   u   _sslobju   shutdownu   Noneu
   ValueErroru   str(   u   selfu   s(    (    u    /mit/python/lib/python3.0/ssl.pyu   unwrap3  s
    
	c             C   s   d  |  _ t j |  ƒ d  S(   N(   u   Noneu   _sslobju   socketu   _real_close(   u   self(    (    u    /mit/python/lib/python3.0/ssl.pyu   _real_close;  s    	c          	   C   sW   |  j  ƒ  } z6 | d k o | o |  j d ƒ n |  j j ƒ  Wd |  j | ƒ Xd S(   u   Perform a TLS/SSL handshake.g        N(   u
   gettimeoutu
   settimeoutu   Noneu   _sslobju   do_handshake(   u   selfu   blocku   timeout(    (    u    /mit/python/lib/python3.0/ssl.pyu   do_handshake@  s    c             C   s”   |  j  o t d ƒ ‚ n t j |  | ƒ t j |  d |  j |  j |  j	 |  j
 |  j ƒ |  _  y |  j o |  j ƒ  n Wn d |  _  ‚  Yn Xd S(   uQ   Connects to remote ADDR, and then wraps the connection in
        an SSL channel.u/   attempt to connect already-connected SSLSocket!NF(   u   _sslobju
   ValueErroru   socketu   connectu   _sslu   sslwrapu   Falseu   keyfileu   certfileu	   cert_reqsu   ssl_versionu   ca_certsu   do_handshake_on_connectu   do_handshakeu   None(   u   selfu   addr(    (    u    /mit/python/lib/python3.0/ssl.pyu   connectK  s    

	c             C   sd   t  j |  ƒ \ } } t d | d |  j d |  j d d	 d |  j d |  j d |  j d |  j	 ƒ | f S(
   u¿   Accepts a new connection from a remote client, and returns
        a tuple containing that new connection wrapped with a server-side
        SSL channel, and the address of the remote client.u   socku   keyfileu   certfileu   server_sideu	   cert_reqsu   ssl_versionu   ca_certsu   do_handshake_on_connectT(
   u   socketu   acceptu	   SSLSocketu   keyfileu   certfileu   Trueu	   cert_reqsu   ssl_versionu   ca_certsu   do_handshake_on_connect(   u   selfu   newsocku   addr(    (    u    /mit/python/lib/python3.0/ssl.pyu   accept^  s    				c             C   s   |  j  ƒ  d  S(   N(   u   _real_close(   u   self(    (    u    /mit/python/lib/python3.0/ssl.pyu   __del__n  s    NFT(    u   __name__u
   __module__u   __doc__u   Noneu   Falseu	   CERT_NONEu   PROTOCOL_SSLv23u   Trueu   AF_INETu   SOCK_STREAMu   __init__u   dupu   _checkClosedu   readu   writeu   getpeercertu   cipheru   sendu   sendtou   sendallu   recvu	   recv_intou   recvfromu   recvfrom_intou   pendingu   shutdownu   unwrapu   _real_closeu   do_handshakeu   connectu   acceptu   __del__(   u
   __locals__(    (    u    /mit/python/lib/python3.0/ssl.pyu	   SSLSocketU   s8   
	1										u	   SSLSocketc	       	      C   s=   t  d |  d | d | d | d | d | d | d | d	 | ƒ 	S(
   Nu   socku   keyfileu   certfileu   server_sideu	   cert_reqsu   ssl_versionu   ca_certsu   do_handshake_on_connectu   suppress_ragged_eofs(   u	   SSLSocket(	   u   socku   keyfileu   certfileu   server_sideu	   cert_reqsu   ssl_versionu   ca_certsu   do_handshake_on_connectu   suppress_ragged_eofs(    (    u    /mit/python/lib/python3.0/ssl.pyu   wrap_sockets  s
    c             C   s%   d d l  } | j | j |  d ƒ ƒ S(   u¢   Takes a date-time string in standard ASN1_print form
    ("MON DAY 24HOUR:MINUTE:SEC YEAR TIMEZONE") and return
    a Python time value in seconds past the epoch.i    Nu   %b %d %H:%M:%S %Y GMT(   u   timeu   mktimeu   strptime(   u	   cert_timeu   time(    (    u    /mit/python/lib/python3.0/ssl.pyu   cert_time_to_seconds  s    u   -----BEGIN CERTIFICATE-----u   -----END CERTIFICATE-----c             C   s?   t  t j |  ƒ d d ƒ } t d t j | d ƒ d t d S(   u[   Takes a certificate in binary DER format and returns the
    PEM version of it as a string.u   ASCIIu   strictu   
i@   (   u   stru   base64u   standard_b64encodeu
   PEM_HEADERu   textwrapu   fillu
   PEM_FOOTER(   u   der_cert_bytesu   f(    (    u    /mit/python/lib/python3.0/ssl.pyu   DER_cert_to_PEM_certŒ  s    c             C   sŠ   |  j  t ƒ p t d t ƒ ‚ n |  j ƒ  j t ƒ p t d t ƒ ‚ n |  j ƒ  t t ƒ t t ƒ … } t j | j	 d d ƒ ƒ S(   uh   Takes a certificate in ASCII PEM format and returns the
    DER-encoded version of it as a byte sequenceu(   Invalid PEM encoding; must start with %su&   Invalid PEM encoding; must end with %su   ASCIIu   strict(
   u
   startswithu
   PEM_HEADERu
   ValueErroru   stripu   endswithu
   PEM_FOOTERu   lenu   base64u   decodestringu   encode(   u   pem_cert_stringu   d(    (    u    /mit/python/lib/python3.0/ssl.pyu   PEM_cert_to_DER_cert•  s    #c             C   sz   |  \ } } | d k	 o
 t } n t } t t ƒ  d | d | d | ƒ} | j |  ƒ | j d ƒ } | j ƒ  t	 | ƒ S(   u÷   Retrieve the certificate from the server at the specified address,
    and return it as a PEM-encoded string.
    If 'ca_certs' is specified, validate the server cert against it.
    If 'ssl_version' is specified, use it in the connection attempt.u   ssl_versionu	   cert_reqsu   ca_certsNT(
   u   Noneu   CERT_REQUIREDu	   CERT_NONEu   wrap_socketu   socketu   connectu   getpeercertu   Trueu   closeu   DER_cert_to_PEM_cert(   u   addru   ssl_versionu   ca_certsu   hostu   portu	   cert_reqsu   su   dercert(    (    u    /mit/python/lib/python3.0/ssl.pyu   get_server_certificate¢  s    

c             C   sP   |  t  k o d S|  t k o d S|  t k o d S|  t k o d Sd Sd  S(   Nu   TLSv1u   SSLv23u   SSLv2u   SSLv3u	   <unknown>(   u   PROTOCOL_TLSv1u   PROTOCOL_SSLv23u   PROTOCOL_SSLv2u   PROTOCOL_SSLv3(   u   protocol_code(    (    u    /mit/python/lib/python3.0/ssl.pyu   get_protocol_name´  s    (.   u   __doc__u   textwrapu   _sslu   SSLErroru	   CERT_NONEu   CERT_OPTIONALu   CERT_REQUIREDu   PROTOCOL_SSLv2u   PROTOCOL_SSLv3u   PROTOCOL_SSLv23u   PROTOCOL_TLSv1u   RAND_statusu   RAND_egdu   RAND_addu   SSL_ERROR_ZERO_RETURNu   SSL_ERROR_WANT_READu   SSL_ERROR_WANT_WRITEu   SSL_ERROR_WANT_X509_LOOKUPu   SSL_ERROR_SYSCALLu   SSL_ERROR_SSLu   SSL_ERROR_WANT_CONNECTu   SSL_ERROR_EOFu   SSL_ERROR_INVALID_ERROR_CODEu   socketu   getnameinfou   _getnameinfou   erroru   socket_erroru   dupu   _dupu   AF_INETu   SOCK_STREAMu   base64u	   tracebacku	   SSLSocketu   Noneu   Falseu   Trueu   wrap_socketu   cert_time_to_secondsu
   PEM_HEADERu
   PEM_FOOTERu   DER_cert_to_PEM_certu   PEM_cert_to_DER_certu   get_server_certificateu   get_protocol_name(    (    (    u    /mit/python/lib/python3.0/ssl.pyu   <module>7   s6   "@ÿ 
				