???<!-- GIF89;a -->
123123123123
.....................................................................................................................................???<!-- GIF89;a -->
123123123123
.....................................................................................................................................ž
«ÿfž_  c            +   @   sã  d  Z  d d l Z d d l Z d d l Z d d l m Z m Z m Z d d l m Z d d l m Z m	 Z	 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 y d d l m Z Wn e k
 rö Yn Xy d d	 l m Z Wn e k
 rYn Xd d
 l m Z m Z m Z m Z y d d l m Z Wn e k
 rjYn Xd 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( m) Z) m* Z* d d l m+ Z+ m, Z, m- Z- m. Z. d d l m/ Z/ e0 e d ƒ e1 ƒ  d <i d e- 6d e, 6d e+ 6d e. 6Z2 y d d l m3 Z3 e3 Z4 Wn e k
 ree5 Z4 Yn Xd e2 e3 <d d l6 m7 Z8 d d l6 m9 Z: d d l6 m6 Z6 m; Z; m< Z< m= Z= d d l6 m> Z> m? Z? d d l@ Z@ d d lA ZA d d lB ZB e jC rd g ZD n g  ZD d ZE Gd d „  d eF ƒ ZG d d  d! „ ZH d" d# „  ZI Gd$ d% „  d% e ƒ ZJ Gd& d' „  d' e6 ƒ ZK e5 e5 eL e e. e5 eM eM e5 d( d) „	 ZN d* d+ „  ZO d, ZP d- ZQ d. d/ „  ZR d0 d1 „  ZS e+ e5 d2 d3 „ ZT d4 d5 „  ZU d S(6   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   OPENSSL_VERSION_NUMBERu   OPENSSL_VERSION_INFOu   OPENSSL_VERSION(   u   _SSLContext(   u   SSLErroru   SSLZeroReturnErroru   SSLWantReadErroru   SSLWantWriteErroru   SSLSyscallErroru   SSLEOFError(   u	   CERT_NONEu   CERT_OPTIONALu   CERT_REQUIRED(   u   OP_ALLu   OP_NO_SSLv2u   OP_NO_SSLv3u   OP_NO_TLSv1u   OP_CIPHER_SERVER_PREFERENCEu   OP_SINGLE_DH_USE(   u   OP_NO_COMPRESSION(   u   OP_SINGLE_ECDH_USE(   u   RAND_statusu   RAND_addu
   RAND_bytesu   RAND_pseudo_bytes(   u   RAND_egd(	   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   HAS_SNIu   HAS_ECDHu   HAS_NPN(   u   PROTOCOL_SSLv3u   PROTOCOL_SSLv23u   PROTOCOL_TLSv1u   PROTOCOL_TLS(   u   _OPENSSL_API_VERSIONu   PROTOCOL_TLSu   PROTOCOL_SSLv23u   TLSv1u   SSLv23u   SSLv3(   u   PROTOCOL_SSLv2u   SSLv2(   u   getnameinfo(   u   error(   u   socketu   AF_INETu   SOCK_STREAMu   create_connection(   u
   SOL_SOCKETu   SO_TYPEu
   tls-uniqueu)   DEFAULT:!aNULL:!eNULL:!LOW:!EXPORT:!SSLv2c             B   s   |  Ee  Z d  Z d S(   u   CertificateErrorN(   u   __name__u
   __module__u   __qualname__(   u
   __locals__(    (    u(   /opt/alt/python33/lib64/python3.3/ssl.pyu   CertificateError‰   s   u   CertificateErrori   c       	      C   sD  g  } |  s d S|  j d ƒ ^ } } | j d ƒ } | | k rY t d t |  ƒ ƒ ‚ n  | su |  j ƒ  | j ƒ  k S| d k r‘ | j d ƒ nY | j d ƒ s¯ | j d ƒ rÈ | j t j	 | ƒ ƒ n" | j t j	 | ƒ j
 d d ƒ ƒ x$ | D] } | j t j	 | ƒ ƒ qñ Wt j d d	 j | ƒ d
 t j ƒ } | j | ƒ S(   uh   Matching according to RFC 6125, section 6.4.3

    http://tools.ietf.org/html/rfc6125#section-6.4.3
    u   .u   *u,   too many wildcards in certificate DNS name: u   [^.]+u   xn--u   \*u   [^.]*u   \Au   \.u   \ZF(   u   Falseu   splitu   countu   CertificateErroru   repru   loweru   appendu
   startswithu   reu   escapeu   replaceu   compileu   joinu
   IGNORECASEu   match(	   u   dnu   hostnameu   max_wildcardsu   patsu   leftmostu	   remainderu	   wildcardsu   fragu   pat(    (    u(   /opt/alt/python33/lib64/python3.3/ssl.pyu   _dnsname_match   s&    "&u   _dnsname_matchc             C   s[  |  s t  d ƒ ‚ n  g  } |  j d f  ƒ } xC | D]; \ } } | d k r4 t | | ƒ r_ d S| j | ƒ q4 q4 W| sß xc |  j d f  ƒ D]L } xC | D]; \ } } | d k r™ t | | ƒ rÄ d S| j | ƒ q™ q™ WqŒ Wn  t | ƒ d k rt d | d	 j t t | ƒ ƒ f ƒ ‚ n; t | ƒ d k rKt d
 | | d f ƒ ‚ n t d ƒ ‚ d S(   u)  Verify that *cert* (in decoded format as returned by
    SSLSocket.getpeercert()) matches the *hostname*.  RFC 2818 and RFC 6125
    rules are followed, but IP addresses are not accepted for *hostname*.

    CertificateError is raised on failure. On success, the function
    returns nothing.
    u   empty or no certificateu   subjectAltNameu   DNSNu   subjectu
   commonNamei   u&   hostname %r doesn't match either of %su   , u   hostname %r doesn't match %ri    u=   no appropriate commonName or subjectAltName fields were found(	   u
   ValueErroru   getu   _dnsname_matchu   appendu   lenu   CertificateErroru   joinu   mapu   repr(   u   certu   hostnameu   dnsnamesu   sanu   keyu   valueu   sub(    (    u(   /opt/alt/python33/lib64/python3.3/ssl.pyu   match_hostname¾   s.    %u   match_hostnamec             B   s\   |  Ee  Z d  Z d Z d Z d d „  Z d d „  Z d d d d d d „ Z
 d	 d
 „  Z d S(   u
   SSLContextu|   An SSLContext holds various SSL-related configuration options and
    data, such as certificates and possibly a private key.u   protocolc             O   s2   t  j |  | ƒ } | t k r. | j t ƒ n  | S(   N(   u   _SSLContextu   __new__u   _SSLv2_IF_EXISTSu   set_ciphersu   _DEFAULT_CIPHERS(   u   clsu   protocolu   argsu   kwargsu   self(    (    u(   /opt/alt/python33/lib64/python3.3/ssl.pyu   __new__í   s    u   SSLContext.__new__c             C   s   | |  _  d  S(   N(   u   protocol(   u   selfu   protocol(    (    u(   /opt/alt/python33/lib64/python3.3/ssl.pyu   __init__ó   s    u   SSLContext.__init__c             C   s+   t  d | d | d | d | d | d |  ƒ S(   Nu   socku   server_sideu   do_handshake_on_connectu   suppress_ragged_eofsu   server_hostnameu   _context(   u	   SSLSocket(   u   selfu   socku   server_sideu   do_handshake_on_connectu   suppress_ragged_eofsu   server_hostname(    (    u(   /opt/alt/python33/lib64/python3.3/ssl.pyu   wrap_socketö   s
    u   SSLContext.wrap_socketc             C   s   t  ƒ  } xp | D]h } t | d ƒ } t | ƒ d k sI t | ƒ d k rX t d ƒ ‚ n  | j t | ƒ ƒ | j | ƒ q W|  j | ƒ d  S(   Nu   asciii    iÿ   u(   NPN protocols must be 1 to 255 in length(   u	   bytearrayu   bytesu   lenu   SSLErroru   appendu   extendu   _set_npn_protocols(   u   selfu   npn_protocolsu   protosu   protocolu   b(    (    u(   /opt/alt/python33/lib64/python3.3/ssl.pyu   set_npn_protocols   s    	$u   SSLContext.set_npn_protocolsN(   u   protocolFT(   u   __name__u
   __module__u   __qualname__u   __doc__u	   __slots__u   __new__u   __init__u   Falseu   Trueu   Noneu   wrap_socketu   set_npn_protocols(   u
   __locals__(    (    u(   /opt/alt/python33/lib64/python3.3/ssl.pyu
   SSLContextç   s   u
   SSLContextc             B   sÜ  |  Ee  Z d  Z d Z d? d? d? d@ e e d? dA e	 e
 d d? dA d? d? d? d? d d „ Z d d „  Z d? d d „ Z d d? d	 d
 „ Z d d „  Z d@ d d „ Z d d „  Z d d „  Z d d „  Z d d d „ Z d? d d „ Z d d „  Z d d d „ Z d d d d „ Z d? d d  d! „ Z d d d" d# „ Z d? d d$ d% „ Z d& d' „  Z d( d) „  Z d* d+ „  Z d, d- „  Z d. d/ „  Z  d0 d1 „  Z! d@ d2 d3 „ Z" d4 d5 „  Z# d6 d7 „  Z$ d8 d9 „  Z% d: d; „  Z& d< d= d> „ Z' d? S(B   u	   SSLSocketuµ   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   s2  | r | |  _  n| r. | r. t d ƒ ‚ n  | rJ | rJ t d ƒ ‚ n  | r` | r` | } n  t | ƒ |  _  | |  j  _ | r” |  j  j | ƒ n  | r° |  j  j | | ƒ n  | rÉ |  j  j | ƒ n  | râ |  j  j | ƒ n  | |  _ | |  _	 | |  _
 | |  _ | |  _ | |  _ | j t t ƒ t k r?t d ƒ ‚ n  | rZ| rZt d ƒ ‚ n  | |  _ | |  _ | |  _ | |  _ d } | d  k	 r8t j |  d | j d | j d | j d | j ƒ  ƒ|  j | j  ƒ  ƒ y | j! ƒ  Wn= t" k
 r$} z | j# t# j$ k r‚  n  WYd  d  } ~ Xn Xd } | j& ƒ  nA | d  k	 rZt j |  d | ƒn t j |  d |	 d |
 d | ƒd |  _' d  |  _( | |  _) | r.yY |  j  j* |  | | ƒ |  _( | rò|  j  ƒ  } | d	 k råt d
 ƒ ‚ n  |  j+ ƒ  n  Wq.t" k
 r*} z |  j, ƒ  | ‚ WYd  d  } ~ Xq.Xn  d  S(   Nu5   certfile must be specified for server-side operationsu   certfile must be specifiedu!   only stream sockets are supportedu4   server_hostname can only be specified in client modeu   familyu   typeu   protou   filenog        uH   do_handshake_on_connect should not be specified for non-blocking socketsFT(-   u   contextu
   ValueErroru
   SSLContextu   verify_modeu   load_verify_locationsu   load_cert_chainu   set_npn_protocolsu   set_ciphersu   keyfileu   certfileu	   cert_reqsu   ssl_versionu   ca_certsu   ciphersu
   getsockoptu
   SOL_SOCKETu   SO_TYPEu   SOCK_STREAMu   NotImplementedErroru   server_sideu   server_hostnameu   do_handshake_on_connectu   suppress_ragged_eofsu   Falseu   Noneu   socketu   __init__u   familyu   typeu   protou   filenou
   settimeoutu
   gettimeoutu   getpeernameu   socket_erroru   errnou   ENOTCONNu   Trueu   detachu   _closedu   _sslobju
   _connectedu   _wrap_socketu   do_handshakeu   close(   u   selfu   socku   keyfileu   certfileu   server_sideu	   cert_reqsu   ssl_versionu   ca_certsu   do_handshake_on_connectu   familyu   typeu   protou   filenou   suppress_ragged_eofsu   npn_protocolsu   ciphersu   server_hostnameu   _contextu	   connectedu   eu   timeoutu   x(    (    u(   /opt/alt/python33/lib64/python3.3/ssl.pyu   __init__  s‚    																		
u   SSLSocket.__init__c             C   s   t  d |  j j ƒ ‚ d  S(   Nu   Can't dup() %s instances(   u   NotImplementedu	   __class__u   __name__(   u   self(    (    u(   /opt/alt/python33/lib64/python3.3/ssl.pyu   duph  s    u   SSLSocket.dupc             C   s   d  S(   N(    (   u   selfu   msg(    (    u(   /opt/alt/python33/lib64/python3.3/ssl.pyu   _checkClosedl  s    u   SSLSocket._checkClosedc             C   s°   |  j  ƒ  yD | d k	 r1 |  j j | | ƒ } n |  j j | pC d ƒ } | SWn[ t k
 r« } z; | j d t k r– |  j r– | d k	 r d Sd 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   Noneu   _sslobju   readu   SSLErroru   argsu   SSL_ERROR_EOFu   suppress_ragged_eofs(   u   selfu   lenu   bufferu   vu   x(    (    u(   /opt/alt/python33/lib64/python3.3/ssl.pyu   readp  s    
u   SSLSocket.readc             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(   /opt/alt/python33/lib64/python3.3/ssl.pyu   write„  s    
u   SSLSocket.writec             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(   /opt/alt/python33/lib64/python3.3/ssl.pyu   getpeercert‹  s    
u   SSLSocket.getpeercertc             C   s3   |  j  ƒ  |  j s t j r" d  S|  j j ƒ  Sd  S(   N(   u   _checkClosedu   _sslobju   _sslu   HAS_NPNu   Noneu   selected_npn_protocol(   u   self(    (    u(   /opt/alt/python33/lib64/python3.3/ssl.pyu   selected_npn_protocol”  s    
u   SSLSocket.selected_npn_protocolc             C   s(   |  j  ƒ  |  j s d  S|  j j ƒ  Sd  S(   N(   u   _checkClosedu   _sslobju   Noneu   cipher(   u   self(    (    u(   /opt/alt/python33/lib64/python3.3/ssl.pyu   cipher›  s    
	u   SSLSocket.cipherc             C   s(   |  j  ƒ  |  j s d  S|  j j ƒ  Sd  S(   N(   u   _checkClosedu   _sslobju   Noneu   compression(   u   self(    (    u(   /opt/alt/python33/lib64/python3.3/ssl.pyu   compression¢  s    
	u   SSLSocket.compressionc             C   sÈ   |  j  ƒ  |  j r± | d k r5 t d |  j ƒ ‚ n  xŒ y |  j j | ƒ } WnV t k
 r¦ } z6 | j d t k rz d S| j d t k r‘ d S‚  WYd  d  } ~ Xq8 X| Sq8 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(   /opt/alt/python33/lib64/python3.3/ssl.pyu   send©  s"    
	
u   SSLSocket.sendc             C   sb   |  j  ƒ  |  j r) t d |  j ƒ ‚ n5 | d  k rH t j |  | | ƒ St j |  | | | ƒ Sd  S(   Nu%   sendto not allowed on instances of %s(   u   _checkClosedu   _sslobju
   ValueErroru	   __class__u   Noneu   socketu   sendto(   u   selfu   datau   flags_or_addru   addr(    (    u(   /opt/alt/python33/lib64/python3.3/ssl.pyu   sendto¿  s    
	u   SSLSocket.sendtoc             O   s   t  d |  j ƒ ‚ d  S(   Nu&   sendmsg not allowed on instances of %s(   u   NotImplementedErroru	   __class__(   u   selfu   argsu   kwargs(    (    u(   /opt/alt/python33/lib64/python3.3/ssl.pyu   sendmsgÉ  s    u   SSLSocket.sendmsgc             C   s˜   |  j  ƒ  |  j r | d k r5 t d |  j ƒ ‚ n  t | ƒ } d } x3 | | k  r| |  j | | d  … ƒ } | | 7} qJ W| St j |  | | ƒ Sd  S(   Ni    u6   non-zero flags not allowed in calls to sendall() on %s(   u   _checkClosedu   _sslobju
   ValueErroru	   __class__u   lenu   sendu   socketu   sendall(   u   selfu   datau   flagsu   amountu   countu   v(    (    u(   /opt/alt/python33/lib64/python3.3/ssl.pyu   sendallÏ  s    
	u   SSLSocket.sendalli   c             C   sY   |  j  ƒ  |  j rB | d k r5 t d |  j ƒ ‚ n  |  j | ƒ St j |  | | ƒ Sd  S(   Ni    u3   non-zero flags not allowed in calls to recv() on %s(   u   _checkClosedu   _sslobju
   ValueErroru	   __class__u   readu   socketu   recv(   u   selfu   buflenu   flags(    (    u(   /opt/alt/python33/lib64/python3.3/ssl.pyu   recvß  s    
	u   SSLSocket.recvc             C   s•   |  j  ƒ  | r+ | d  k r+ t | ƒ } n | d  k r@ d } n  |  j r{ | d k rk t d |  j ƒ ‚ n  |  j | | ƒ St 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   socketu	   recv_into(   u   selfu   bufferu   nbytesu   flags(    (    u(   /opt/alt/python33/lib64/python3.3/ssl.pyu	   recv_intoê  s    
		u   SSLSocket.recv_intoc             C   s@   |  j  ƒ  |  j r) 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   buflenu   flags(    (    u(   /opt/alt/python33/lib64/python3.3/ssl.pyu   recvfromù  s
    
	u   SSLSocket.recvfromc             C   sC   |  j  ƒ  |  j r) 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(   /opt/alt/python33/lib64/python3.3/ssl.pyu   recvfrom_into  s
    
	u   SSLSocket.recvfrom_intoc             O   s   t  d |  j ƒ ‚ d  S(   Nu&   recvmsg not allowed on instances of %s(   u   NotImplementedErroru	   __class__(   u   selfu   argsu   kwargs(    (    u(   /opt/alt/python33/lib64/python3.3/ssl.pyu   recvmsg	  s    u   SSLSocket.recvmsgc             O   s   t  d |  j ƒ ‚ d  S(   Nu+   recvmsg_into not allowed on instances of %s(   u   NotImplementedErroru	   __class__(   u   selfu   argsu   kwargs(    (    u(   /opt/alt/python33/lib64/python3.3/ssl.pyu   recvmsg_into  s    u   SSLSocket.recvmsg_intoc             C   s(   |  j  ƒ  |  j r  |  j j ƒ  Sd Sd  S(   Ni    (   u   _checkClosedu   _sslobju   pending(   u   self(    (    u(   /opt/alt/python33/lib64/python3.3/ssl.pyu   pending  s    
	u   SSLSocket.pendingc             C   s'   |  j  ƒ  d  |  _ t j |  | ƒ d  S(   N(   u   _checkClosedu   Noneu   _sslobju   socketu   shutdown(   u   selfu   how(    (    u(   /opt/alt/python33/lib64/python3.3/ssl.pyu   shutdown  s    
	u   SSLSocket.shutdownc             C   s?   |  j  r% |  j  j ƒ  } d  |  _  | St d t |  ƒ ƒ ‚ d  S(   Nu   No SSL wrapper around (   u   _sslobju   shutdownu   Noneu
   ValueErroru   str(   u   selfu   s(    (    u(   /opt/alt/python33/lib64/python3.3/ssl.pyu   unwrap  s
    		u   SSLSocket.unwrapc             C   s   d  |  _ t j |  ƒ d  S(   N(   u   Noneu   _sslobju   socketu   _real_close(   u   self(    (    u(   /opt/alt/python33/lib64/python3.3/ssl.pyu   _real_close%  s    	u   SSLSocket._real_closec             C   sT   |  j  ƒ  } z3 | d k r1 | r1 |  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(   /opt/alt/python33/lib64/python3.3/ssl.pyu   do_handshake*  s    u   SSLSocket.do_handshakec             C   sÔ   |  j  r t d ƒ ‚ n  |  j r0 t d ƒ ‚ n  |  j j |  d |  j ƒ |  _ ya | rl t j	 |  | ƒ } n d  } t j |  | ƒ | sª |  j rž |  j ƒ  n  d |  _ n  | SWn t k
 rÏ d  |  _ ‚  Yn Xd  S(   Nu!   can't connect in server-side modeu/   attempt to connect already-connected SSLSocket!FT(   u   server_sideu
   ValueErroru
   _connectedu   contextu   _wrap_socketu   Falseu   server_hostnameu   _sslobju   socketu
   connect_exu   Noneu   connectu   do_handshake_on_connectu   do_handshakeu   Trueu   socket_error(   u   selfu   addru
   connect_exu   rc(    (    u(   /opt/alt/python33/lib64/python3.3/ssl.pyu   _real_connect5  s$    				u   SSLSocket._real_connectc             C   s   |  j  | d ƒ d S(   uQ   Connects to remote ADDR, and then wraps the connection in
        an SSL channel.NF(   u   _real_connectu   False(   u   selfu   addr(    (    u(   /opt/alt/python33/lib64/python3.3/ssl.pyu   connectL  s    u   SSLSocket.connectc             C   s   |  j  | d ƒ S(   uQ   Connects to remote ADDR, and then wraps the connection in
        an SSL channel.T(   u   _real_connectu   True(   u   selfu   addr(    (    u(   /opt/alt/python33/lib64/python3.3/ssl.pyu
   connect_exQ  s    u   SSLSocket.connect_exc             C   sI   t  j |  ƒ \ } } |  j j | d |  j d |  j d d ƒ} | | 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   do_handshake_on_connectu   suppress_ragged_eofsu   server_sideT(   u   socketu   acceptu   contextu   wrap_socketu   do_handshake_on_connectu   suppress_ragged_eofsu   True(   u   selfu   newsocku   addr(    (    u(   /opt/alt/python33/lib64/python3.3/ssl.pyu   acceptV  s    			u   SSLSocket.acceptu
   tls-uniquec             C   s_   | t  k r t d ƒ ‚ n  | d k r? t d j | ƒ ƒ ‚ n  |  j d k rR d S|  j j ƒ  S(   uä   Get channel binding data for current connection.  Raise ValueError
        if the requested `cb_type` is not supported.  Return bytes of the data
        or None if the data is not available (e.g. before the handshake).
        u    Unsupported channel binding typeu
   tls-uniqueu(   {0} channel binding type not implementedN(   u   CHANNEL_BINDING_TYPESu
   ValueErroru   NotImplementedErroru   formatu   _sslobju   Noneu   tls_unique_cb(   u   selfu   cb_type(    (    u(   /opt/alt/python33/lib64/python3.3/ssl.pyu   get_channel_bindingb  s    u   SSLSocket.get_channel_bindingNFT((   u   __name__u
   __module__u   __qualname__u   __doc__u   Noneu   Falseu	   CERT_NONEu   PROTOCOL_TLSu   Trueu   AF_INETu   SOCK_STREAMu   __init__u   dupu   _checkClosedu   readu   writeu   getpeercertu   selected_npn_protocolu   cipheru   compressionu   sendu   sendtou   sendmsgu   sendallu   recvu	   recv_intou   recvfromu   recvfrom_intou   recvmsgu   recvmsg_intou   pendingu   shutdownu   unwrapu   _real_closeu   do_handshakeu   _real_connectu   connectu
   connect_exu   acceptu   get_channel_binding(   u
   __locals__(    (    u(   /opt/alt/python33/lib64/python3.3/ssl.pyu	   SSLSocket  sJ   		P	
u	   SSLSocketc
       
      C   sC   t  d |  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_eofsu   ciphers(   u	   SSLSocket(
   u   socku   keyfileu   certfileu   server_sideu	   cert_reqsu   ssl_versionu   ca_certsu   do_handshake_on_connectu   suppress_ragged_eofsu   ciphers(    (    u(   /opt/alt/python33/lib64/python3.3/ssl.pyu   wrap_socketr  s    u   wrap_socketc             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(   /opt/alt/python33/lib64/python3.3/ssl.pyu   cert_time_to_seconds‚  s    u   cert_time_to_secondsu   -----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(   /opt/alt/python33/lib64/python3.3/ssl.pyu   DER_cert_to_PEM_cert  s    u   DER_cert_to_PEM_certc             C   s†   |  j  t ƒ s" t d t ƒ ‚ n  |  j ƒ  j t ƒ sJ 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   decodebytesu   encode(   u   pem_cert_stringu   d(    (    u(   /opt/alt/python33/lib64/python3.3/ssl.pyu   PEM_cert_to_DER_cert–  s    #u   PEM_cert_to_DER_certc             C   st   |  \ } } | d k	 r! t } n t } t |  ƒ } t | d | d | d | ƒ} | 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   create_connectionu   wrap_socketu   getpeercertu   Trueu   closeu   DER_cert_to_PEM_cert(   u   addru   ssl_versionu   ca_certsu   hostu   portu	   cert_reqsu   su   dercert(    (    u(   /opt/alt/python33/lib64/python3.3/ssl.pyu   get_server_certificate£  s    	
u   get_server_certificatec             C   s   t  j |  d ƒ S(   Nu	   <unknown>(   u   _PROTOCOL_NAMESu   get(   u   protocol_code(    (    u(   /opt/alt/python33/lib64/python3.3/ssl.pyu   get_protocol_nameµ  s    u   get_protocol_name(V   u   __doc__u   textwrapu   reu   _sslu   OPENSSL_VERSION_NUMBERu   OPENSSL_VERSION_INFOu   OPENSSL_VERSIONu   _SSLContextu   SSLErroru   SSLZeroReturnErroru   SSLWantReadErroru   SSLWantWriteErroru   SSLSyscallErroru   SSLEOFErroru	   CERT_NONEu   CERT_OPTIONALu   CERT_REQUIREDu   OP_ALLu   OP_NO_SSLv2u   OP_NO_SSLv3u   OP_NO_TLSv1u   OP_CIPHER_SERVER_PREFERENCEu   OP_SINGLE_DH_USEu   OP_NO_COMPRESSIONu   ImportErroru   OP_SINGLE_ECDH_USEu   RAND_statusu   RAND_addu
   RAND_bytesu   RAND_pseudo_bytesu   RAND_egdu   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   HAS_SNIu   HAS_ECDHu   HAS_NPNu   PROTOCOL_SSLv3u   PROTOCOL_SSLv23u   PROTOCOL_TLSv1u   PROTOCOL_TLSu   _OPENSSL_API_VERSIONu   getattru   globalsu   _PROTOCOL_NAMESu   PROTOCOL_SSLv2u   _SSLv2_IF_EXISTSu   Noneu   socketu   getnameinfou   _getnameinfou   erroru   socket_erroru   AF_INETu   SOCK_STREAMu   create_connectionu
   SOL_SOCKETu   SO_TYPEu   base64u	   tracebacku   errnou   HAS_TLS_UNIQUEu   CHANNEL_BINDING_TYPESu   _DEFAULT_CIPHERSu
   ValueErroru   CertificateErroru   _dnsname_matchu   match_hostnameu
   SSLContextu	   SSLSocketu   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(   /opt/alt/python33/lib64/python3.3/ssl.pyu   <module>7   s†   .."@"


"	1)%ÿ g	