def read(self, size=0): if not self.readable(): raise IOError('cannot read') if size: return m2.bio_read(self.bio, size) else: return m2.bio_read(self.bio, m2.bio_ctrl_pending(self.bio))
def _encrypt(self, data='', clientHello=0): # XXX near mirror image of _decrypt - refactor self.data += data g = m2.bio_ctrl_get_write_guarantee(self.sslBio._ptr()) if g > 0 and self.data != '' or clientHello: r = m2.bio_write(self.sslBio._ptr(), self.data) if r <= 0: assert (m2.bio_should_retry(self.sslBio._ptr())) else: assert (self.checked) self.data = self.data[r:] encryptedData = '' while 1: pending = m2.bio_ctrl_pending(self.networkBio) if pending: d = m2.bio_read(self.networkBio, pending) if d is not None: # This is strange, but d can be None encryptedData += d else: assert (m2.bio_should_retry(self.networkBio)) else: break return encryptedData
def read(self, size=None): if not self.readable(): raise IOError('cannot read') if size is None: buf = io.BytesIO() while 1: data = m2.bio_read(self.bio, 4096) if not data: break buf.write(data) return buf.getvalue() elif size == 0: return '' elif size < 0: raise ValueError('read count is negative') else: return m2.bio_read(self.bio, size)
def read(self, size=None): if not self.readable(): raise IOError('cannot read') if size is None: buf = StringIO() while 1: data = m2.bio_read(self.bio, 4096) if not data: break buf.write(data) return buf.getvalue() elif size == 0: return '' elif size < 0: raise ValueError('read count is negative') else: return m2.bio_read(self.bio, size)
def read(self, size=None): # type: (int) -> Union[bytes, bytearray] if not self.readable(): raise IOError('cannot read') if size is None: buf = bytearray() while 1: data = m2.bio_read(self.bio, 4096) if not data: break buf += data return buf elif size == 0: return b'' elif size < 0: raise ValueError('read count is negative') else: return bytes(m2.bio_read(self.bio, size))
def _translate(self, write_bio, write_bio_buf, read_bio, force_write=False): data = [] encrypting = write_bio is self._bio_ssl write_bio = write_bio.obj read_bio = read_bio.obj while True: writable = m2.bio_ctrl_get_write_guarantee(write_bio) > 0 if (writable and write_bio_buf) or force_write: # If force_write is True, we want to start the handshake. We call # bio_write() even if there's nothing in the buffer, to cause OpenSSL to # implicitly send the client hello. chunk = write_bio_buf.pop(0) if write_bio_buf else '' r = m2.bio_write(write_bio, chunk) if r <= 0: # If BIO_write returns <= 0 due to an error condition, it should # raise. Otherwise we expect bio_should_retry() to return True. Do a # quick sanity check. if not m2.bio_should_retry(write_bio): raise TLSProtocolError('Unexpected internal state: should_retry()' 'is False without error') if not self._rmon.active and m2.bio_should_read(self._bio_ssl.obj): # The BIO write failed, the SSL BIO is now telling us we should # read, and the read monitor is not active. Update the read # monitor now, which will register with the notifier because the # SSL BIO should read, allowing us to read from the socket to # satisfy whatever the underlying SSL protocol is doing. self._update_read_monitor() else: if encrypting: # We are encrypting user data to send to peer. Require the # remote end be validated first. We should not normally # get here until ClientHello is completed successfully. assert(self._validated) chunk = chunk[r:] if chunk: # Insert remainder of chunk back into the buffer. write_bio_buf.insert(0, chunk) pending = m2.bio_ctrl_pending(read_bio) if not pending: break chunk = m2.bio_read(read_bio, pending) if chunk is not None: data.append(chunk) else: # It's possible for chunk to be None, even though bio_ctrl_pending() # told us there was data waiting in the BIO. I suspect this happens # when all the bytes in the BIO are used for the SSL protocol and # none are user data. assert(m2.bio_should_retry(read_bio)) return ''.join(data)
def _decrypt(self, data=''): # XXX near mirror image of _encrypt - refactor self.encrypted += data g = m2.bio_ctrl_get_write_guarantee(self.networkBio) if g > 0 and self.encrypted != '': r = m2.bio_write(self.networkBio, self.encrypted) if r <= 0: assert (m2.bio_should_retry(self.networkBio)) else: self.encrypted = self.encrypted[r:] decryptedData = '' while 1: pending = m2.bio_ctrl_pending(self.sslBio._ptr()) if pending: d = m2.bio_read(self.sslBio._ptr(), pending) if d is not None: # This is strange, but d can be None decryptedData += d else: assert (m2.bio_should_retry(self.sslBio._ptr())) else: break return decryptedData
def _translate(self, write_bio, write_bio_buf, read_bio, force_write=False): data = [] encrypting = write_bio is self._bio_ssl write_bio = write_bio.obj read_bio = read_bio.obj while True: writable = m2.bio_ctrl_get_write_guarantee(write_bio) > 0 if (writable and write_bio_buf) or force_write: # If force_write is True, we want to start the handshake. We call # bio_write() even if there's nothing in the buffer, to cause OpenSSL to # implicitly send the client hello. chunk = write_bio_buf.pop(0) if write_bio_buf else '' r = m2.bio_write(write_bio, chunk) if r <= 0: # If BIO_write returns <= 0 due to an error condition, it should # raise. Otherwise we expect bio_should_retry() to return True. Do a # quick sanity check. if not m2.bio_should_retry(write_bio): raise TLSProtocolError( 'Unexpected internal state: should_retry()' 'is False without error') if not self._rmon.active and m2.bio_should_read( self._bio_ssl.obj): # The BIO write failed, the SSL BIO is now telling us we should # read, and the read monitor is not active. Update the read # monitor now, which will register with the notifier because the # SSL BIO should read, allowing us to read from the socket to # satisfy whatever the underlying SSL protocol is doing. self._update_read_monitor() else: if encrypting: # We are encrypting user data to send to peer. Require the # remote end be validated first. We should not normally # get here until ClientHello is completed successfully. assert (self._validated) chunk = chunk[r:] if chunk: # Insert remainder of chunk back into the buffer. write_bio_buf.insert(0, chunk) pending = m2.bio_ctrl_pending(read_bio) if not pending: break chunk = m2.bio_read(read_bio, pending) if chunk is not None: data.append(chunk) else: # It's possible for chunk to be None, even though bio_ctrl_pending() # told us there was data waiting in the BIO. I suspect this happens # when all the bytes in the BIO are used for the SSL protocol and # none are user data. assert (m2.bio_should_retry(read_bio)) return ''.join(data)
def cmembufi(iter, txt=txt): buf = m2.bio_new(m2.bio_s_mem()) for i in range(iter): m2.bio_write(buf, txt) m2.bio_set_mem_eof_return(buf, 0) out = m2.bio_read(buf, m2.bio_ctrl_pending(buf))
if use_mem: bio = m2.bio_new(m2.bio_s_mem()) else: bio = m2.bio_new_file('XXX', 'wb') ciph = m2.bf_cbc() filt = m2.bio_new(m2.bio_f_cipher()) m2.bio_set_cipher(filt, ciph, 'key', 'iv', 1) m2.bio_push(filt, bio) m2.bio_write(filt, '12345678901234567890') m2.bio_flush(filt) m2.bio_pop(filt) m2.bio_free(filt) if use_mem: m2.bio_set_mem_eof_return(bio, 0) xxx = m2.bio_read(bio, 100) print `xxx`, len(xxx) m2.bio_free(bio) if use_mem: bio = m2.bio_new(m2.bio_s_mem()) m2.bio_write(bio, xxx) m2.bio_set_mem_eof_return(bio, 0) else: bio = m2.bio_new_file('XXX', 'rb') ciph = m2.bf_cbc() filt = m2.bio_new(m2.bio_f_cipher()) m2.bio_set_cipher(filt, ciph, 'key', 'iv', 0) m2.bio_push(filt, bio) yyy = m2.bio_read(filt, 100) print `yyy`