home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 February / maximum-cd-2011-02.iso / DiscContents / digsby_setup85.exe / lib / M2Crypto / SSL / Connection.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-11-24  |  13.9 KB  |  355 lines

  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. import socket
  5. from Cipher import Cipher, Cipher_Stack
  6. from Session import Session
  7. from M2Crypto import BIO, X509, m2
  8. import timeout
  9. import Checker
  10. from M2Crypto.SSL import SSLError
  11.  
  12. def _serverPostConnectionCheck(*args, **kw):
  13.     return 1
  14.  
  15.  
  16. class Connection:
  17.     clientPostConnectionCheck = Checker.Checker()
  18.     serverPostConnectionCheck = _serverPostConnectionCheck
  19.     m2_bio_free = m2.bio_free
  20.     m2_ssl_free = m2.ssl_free
  21.     
  22.     def __init__(self, ctx, sock = None):
  23.         self.ctx = ctx
  24.         self.ssl = m2.ssl_new(self.ctx.ctx)
  25.         if sock is not None:
  26.             self.socket = sock
  27.         else:
  28.             self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  29.             self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
  30.         self._fileno = self.socket.fileno()
  31.         self.blocking = self.socket.gettimeout()
  32.         self.ssl_close_flag = m2.bio_noclose
  33.  
  34.     
  35.     def __del__(self):
  36.         if getattr(self, 'sslbio', None):
  37.             self.m2_bio_free(self.sslbio)
  38.         
  39.         if getattr(self, 'sockbio', None):
  40.             self.m2_bio_free(self.sockbio)
  41.         
  42.         if self.ssl_close_flag == m2.bio_noclose and getattr(self, 'ssl', None):
  43.             self.m2_ssl_free(self.ssl)
  44.         
  45.         self.socket.close()
  46.  
  47.     
  48.     def close(self):
  49.         m2.ssl_shutdown(self.ssl)
  50.  
  51.     
  52.     def clear(self):
  53.         return m2.ssl_clear(self.ssl)
  54.  
  55.     
  56.     def set_shutdown(self, mode):
  57.         m2.ssl_set_shutdown1(self.ssl, mode)
  58.  
  59.     
  60.     def get_shutdown(self):
  61.         return m2.ssl_get_shutdown(self.ssl)
  62.  
  63.     
  64.     def bind(self, addr):
  65.         self.socket.bind(addr)
  66.  
  67.     
  68.     def listen(self, qlen = 5):
  69.         self.socket.listen(qlen)
  70.  
  71.     
  72.     def ssl_get_error(self, ret):
  73.         return m2.ssl_get_error(self.ssl, ret)
  74.  
  75.     
  76.     def set_bio(self, readbio, writebio):
  77.         m2.ssl_set_bio(self.ssl, readbio._ptr(), writebio._ptr())
  78.  
  79.     
  80.     def set_client_CA_list_from_file(self, cafile):
  81.         m2.ssl_set_client_CA_list_from_file(self.ssl, cafile)
  82.  
  83.     
  84.     def set_client_CA_list_from_context(self):
  85.         m2.ssl_set_client_CA_list_from_context(self.ssl, self.ctx.ctx)
  86.  
  87.     
  88.     def setup_addr(self, addr):
  89.         self.addr = addr
  90.  
  91.     
  92.     def set_ssl_close_flag(self, flag):
  93.         if flag not in (m2.bio_close, m2.bio_noclose):
  94.             raise ValueError('flag must be m2.bio_close or m2.bio_noclose')
  95.         flag not in (m2.bio_close, m2.bio_noclose)
  96.         self.ssl_close_flag = flag
  97.  
  98.     
  99.     def setup_ssl(self):
  100.         self.sockbio = m2.bio_new_socket(self.socket.fileno(), 0)
  101.         m2.ssl_set_bio(self.ssl, self.sockbio, self.sockbio)
  102.         self.sslbio = m2.bio_new(m2.bio_f_ssl())
  103.         m2.bio_set_ssl(self.sslbio, self.ssl, m2.bio_noclose)
  104.  
  105.     
  106.     def _setup_ssl(self, addr):
  107.         self.setup_addr(addr)
  108.         self.setup_ssl()
  109.  
  110.     
  111.     def set_accept_state(self):
  112.         m2.ssl_set_accept_state(self.ssl)
  113.  
  114.     
  115.     def accept_ssl(self):
  116.         return m2.ssl_accept(self.ssl)
  117.  
  118.     
  119.     def accept(self):
  120.         (sock, addr) = self.socket.accept()
  121.         ssl = Connection(self.ctx, sock)
  122.         ssl.addr = addr
  123.         ssl.setup_ssl()
  124.         ssl.set_accept_state()
  125.         ssl.accept_ssl()
  126.         check = getattr(self, 'postConnectionCheck', self.serverPostConnectionCheck)
  127.         if check is not None:
  128.             if not check(ssl.get_peer_cert(), ssl.addr[0]):
  129.                 raise Checker.SSLVerificationError, 'post connection check failed'
  130.             check(ssl.get_peer_cert(), ssl.addr[0])
  131.         
  132.         return (ssl, addr)
  133.  
  134.     
  135.     def set_connect_state(self):
  136.         m2.ssl_set_connect_state(self.ssl)
  137.  
  138.     
  139.     def connect_ssl(self):
  140.         return m2.ssl_connect(self.ssl)
  141.  
  142.     
  143.     def connect(self, addr):
  144.         self.socket.connect(addr)
  145.         self.addr = addr
  146.         self.setup_ssl()
  147.         self.set_connect_state()
  148.         ret = self.connect_ssl()
  149.         check = getattr(self, 'postConnectionCheck', self.clientPostConnectionCheck)
  150.         if check is not None:
  151.             if not check(self.get_peer_cert(), self.addr[0]):
  152.                 raise Checker.SSLVerificationError, 'post connection check failed'
  153.             check(self.get_peer_cert(), self.addr[0])
  154.         
  155.         return ret
  156.  
  157.     
  158.     def shutdown(self, how):
  159.         m2.ssl_set_shutdown(self.ssl, how)
  160.  
  161.     
  162.     def renegotiate(self):
  163.         return m2.ssl_renegotiate(self.ssl)
  164.  
  165.     
  166.     def pending(self):
  167.         return m2.ssl_pending(self.ssl)
  168.  
  169.     
  170.     def _write_bio(self, data):
  171.         return m2.ssl_write(self.ssl, data)
  172.  
  173.     
  174.     def _write_nbio(self, data):
  175.         return m2.ssl_write_nbio(self.ssl, data)
  176.  
  177.     
  178.     def _read_bio(self, size = 1024):
  179.         if size <= 0:
  180.             raise ValueError, 'size <= 0'
  181.         size <= 0
  182.         return m2.ssl_read(self.ssl, size)
  183.  
  184.     
  185.     def _read_nbio(self, size = 1024):
  186.         if size <= 0:
  187.             raise ValueError, 'size <= 0'
  188.         size <= 0
  189.         return m2.ssl_read_nbio(self.ssl, size)
  190.  
  191.     
  192.     def write(self, data):
  193.         if self.blocking:
  194.             return self._write_bio(data)
  195.         return self._write_nbio(data)
  196.  
  197.     sendall = send = write
  198.     
  199.     def read(self, size = 1024):
  200.         if self.blocking:
  201.             return self._read_bio(size)
  202.         return self._read_nbio(size)
  203.  
  204.     recv = read
  205.     
  206.     def setblocking(self, mode):
  207.         self.socket.setblocking(mode)
  208.         self.blocking = mode
  209.  
  210.     
  211.     def fileno(self):
  212.         return self.socket.fileno()
  213.  
  214.     
  215.     def getsockopt(self, *args):
  216.         return apply(self.socket.getsockopt, args)
  217.  
  218.     
  219.     def setsockopt(self, *args):
  220.         return apply(self.socket.setsockopt, args)
  221.  
  222.     
  223.     def get_context(self):
  224.         return m2.ssl_get_ssl_ctx(self.ssl)
  225.  
  226.     
  227.     def get_state(self):
  228.         return m2.ssl_get_state(self.ssl)
  229.  
  230.     
  231.     def verify_ok(self):
  232.         return m2.ssl_get_verify_result(self.ssl) == m2.X509_V_OK
  233.  
  234.     
  235.     def get_verify_mode(self):
  236.         return m2.ssl_get_verify_mode(self.ssl)
  237.  
  238.     
  239.     def get_verify_depth(self):
  240.         return m2.ssl_get_verify_depth(self.ssl)
  241.  
  242.     
  243.     def get_verify_result(self):
  244.         return m2.ssl_get_verify_result(self.ssl)
  245.  
  246.     
  247.     def get_peer_cert(self):
  248.         c = m2.ssl_get_peer_cert(self.ssl)
  249.         if c is None:
  250.             return None
  251.         return X509.X509(c, 1)
  252.  
  253.     
  254.     def get_peer_cert_chain(self):
  255.         c = m2.ssl_get_peer_cert_chain(self.ssl)
  256.         if c is None:
  257.             return None
  258.         return X509.X509_Stack(c)
  259.  
  260.     
  261.     def get_cipher(self):
  262.         c = m2.ssl_get_current_cipher(self.ssl)
  263.         if c is None:
  264.             return None
  265.         return Cipher(c)
  266.  
  267.     
  268.     def get_ciphers(self):
  269.         c = m2.ssl_get_ciphers(self.ssl)
  270.         if c is None:
  271.             return None
  272.         return Cipher_Stack(c)
  273.  
  274.     
  275.     def get_cipher_list(self, idx = 0):
  276.         return m2.ssl_get_cipher_list(self.ssl, idx)
  277.  
  278.     
  279.     def set_cipher_list(self, cipher_list):
  280.         return m2.ssl_set_cipher_list(self.ssl, cipher_list)
  281.  
  282.     
  283.     def makefile(self, mode = 'rb', bufsize = 'ignored'):
  284.         if not 'r' in mode:
  285.             pass
  286.         r = '+' in mode
  287.         if not 'w' in mode and 'a' in mode:
  288.             pass
  289.         w = '+' in mode
  290.         b = 'b' in mode
  291.         m2mode = [
  292.             '',
  293.             'r'][r] + [
  294.             '',
  295.             'w'][w] + [
  296.             '',
  297.             'b'][b]
  298.         bio = BIO.BIO(self.sslbio, _close_cb = self.close)
  299.         m2.bio_do_handshake(bio._ptr())
  300.         return BIO.IOBuffer(bio, m2mode, _pyfree = 0)
  301.  
  302.     
  303.     def getsockname(self):
  304.         return self.socket.getsockname()
  305.  
  306.     
  307.     def getpeername(self):
  308.         return self.socket.getpeername()
  309.  
  310.     
  311.     def set_session_id_ctx(self, id):
  312.         ret = m2.ssl_set_session_id_context(self.ssl, id)
  313.         if not ret:
  314.             raise SSLError(m2.err_reason_error_string(m2.err_get_error()))
  315.         ret
  316.  
  317.     
  318.     def get_session(self):
  319.         sess = m2.ssl_get_session(self.ssl)
  320.         return Session(sess)
  321.  
  322.     
  323.     def set_session(self, session):
  324.         m2.ssl_set_session(self.ssl, session._ptr())
  325.  
  326.     
  327.     def get_default_session_timeout(self):
  328.         return m2.ssl_get_default_session_timeout(self.ssl)
  329.  
  330.     
  331.     def get_socket_read_timeout(self):
  332.         return timeout.struct_to_timeout(self.socket.getsockopt(socket.SOL_SOCKET, socket.SO_RCVTIMEO, timeout.struct_size()))
  333.  
  334.     
  335.     def get_socket_write_timeout(self):
  336.         return timeout.struct_to_timeout(self.socket.getsockopt(socket.SOL_SOCKET, socket.SO_SNDTIMEO, timeout.struct_size()))
  337.  
  338.     
  339.     def set_socket_read_timeout(self, timeo):
  340.         self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_RCVTIMEO, timeo.pack())
  341.  
  342.     
  343.     def set_socket_write_timeout(self, timeo):
  344.         self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_SNDTIMEO, timeo.pack())
  345.  
  346.     
  347.     def get_version(self):
  348.         return m2.ssl_get_version(self.ssl)
  349.  
  350.     
  351.     def set_post_connection_check_callback(self, postConnectionCheck):
  352.         self.postConnectionCheck = postConnectionCheck
  353.  
  354.  
  355.