{0}
' '' '').format(html_escape(error.getErrorMessage())) log("Error connecting to remote host. Sending error response.", id=log_id, verbosity_level=3) log("pc< %s" % rsp.full_message, id=log_id, verbosity_level=3) transport.write(rsp.full_message) def get_http_proxy_addr(): """ Returns the main session's """ from pappyproxy import pappy if not pappy.session.config.http_proxy: return None host = pappy.session.config.http_proxy['host'] port = pappy.session.config.http_proxy['port'] return (host, port) def start_maybe_tls(transport, tls_host, start_tls_callback=None): newprot = MaybeTLSProtocol(transport.protocol, tls_host=tls_host, start_tls_callback=start_tls_callback) newprot.transport = transport transport.protocol = newprot class ServerTLSContext(ssl.ContextFactory): def __init__(self, private_key, certificate): self.private_key = private_key self.certificate = certificate self.sslmethod = SSL.TLSv1_METHOD self.cacheContext() def cacheContext(self): ctx = SSL.Context(self.sslmethod) ctx.use_certificate(self.certificate) ctx.use_privatekey(self.private_key) self._context = ctx def __getstate__(self): d = self.__dict__.copy() del d['_context'] return d def __setstate__(self, state): self.__dict__ = state self.cacheContext() def getContext(self): """Create an SSL context. """ return self._context class ProtocolProxy(object): """ A base object to be used to implement a proxy for an object. Responsible for taking in data from the client and the server. Base class contains minimum for the protocol to hook into the listener. """ def __init__(self): self.client_transport = None self.client_connected = False self.client_buffer = '' self.client_start_tls = False self.client_protocol = None self.server_transport = None self.server_connected = False self.server_buffer = '' self.server_start_tls = False self.server_protocol = None self.conn_host = None self.conn_port = None self.conn_is_ssl = None self.connection_id = get_next_connection_id() def log(self, message, symbol='*', verbosity_level=3): if self.client_protocol: log(message, id=self.connection_id, symbol=symbol, verbosity_level=verbosity_level) else: log(message, symbol=symbol, verbosity_level=verbosity_level) def connect(self, host, port, use_ssl, use_socks=False): from pappyproxy.pappy import session self.connecting = True self.log("Connecting to %s:%d ssl=%s" % (host, port, use_ssl)) factory = PassthroughProtocolFactory(self.server_data_received, self.server_connection_made, self.server_connection_lost) self.conn_host = host self.conn_port = port self.conn_is_ssl = use_ssl if use_socks: socks_config = session.config.socks_proxy else: socks_config = None make_proxied_connection(factory, host, port, use_ssl, socks_config=socks_config, log_id=self.connection_id, http_error_transport=self.client_transport) ## Client interactions def send_client_data(self, data): self.log("pc< %s" % short_data(data)) if self.client_connected: self.client_transport.write(data) else: self.client_buffer += data def client_connection_made(self, protocol): self.client_transport = self.client_protocol.transport self.client_connected = True self.connecting = False if self.client_start_tls: self.start_client_tls() if self.client_buffer != '': self.client_transport.write(self.client_buffer) self.client_buffer = '' def client_connection_lost(self, reason): self.client_connected = False def add_client_data(self, data): """ Called when data is received from the client. """ pass def start_server_tls(self): if self.server_connected: self.log("Starting TLS on server transport") self.server_transport.startTLS(ssl.ClientContextFactory()) else: self.log("Server not yet connected, will start TLS on connect") self.start_server_tls = True def start_client_maybe_tls(self, cert_host): ctx = generate_tls_context(cert_host) start_maybe_tls(self.client_transport, tls_host=cert_host, start_tls_callback=self.start_server_tls) def start_client_tls(self, cert_host): if self.client_connected: self.log("Starting TLS on client transport") ctx = generate_tls_context(cert_host) self.client_transport.startTLS(ctx) else: self.log("Client not yet connected, will start TLS on connect") self.start_client_tls = True ## Server interactions def send_server_data(self, data): if self.server_connected: self.log("ps> %s" % short_data(data)) self.server_transport.write(data) else: self.log("Buffering...") self.log("pb> %s" % short_data(data)) self.server_buffer += data def server_connection_made(self, protocol): """ self.server_protocol must be set before calling """ self.log("Connection made") self.server_protocol = protocol self.server_transport = protocol.transport self.server_connected = True if self.server_start_tls: self.start_server_tls() if self.server_buffer != '': self.log("Writing buffer to server") self.log("ps> %s" % short_data(self.server_buffer)) self.server_transport.write(self.server_buffer) self.server_buffer = '' def server_connection_lost(self, reason): self.server_connected = False def add_server_data(self, data): """ Called when data is received from the server. """ pass def close_server_connection(self): if self.server_transport: self.log("Manually closing server connection") self.server_transport.loseConnection() self.server_transport = None self.server_connected = False self.server_buffer = '' self.server_protocol = None def close_client_connection(self): if self.client_transport: self.log("Manually closing client connection") self.client_transport.loseConnection() self.client_transport = None self.client_connected = False self.client_buffer = '' self.client_protocol = None def close_connections(self): self.close_server_connection() self.close_client_connection() class PassthroughProtocolFactory(ClientFactory): def __init__(self, data_callback, connection_made_callback, connection_lost_callback): self.data_callback = data_callback self.connection_made_callback = connection_made_callback self.connection_lost_callback = connection_lost_callback self.protocol = None def buildProtocol(self, addr): prot = PassthroughProtocol(self.data_callback, self.connection_made_callback, self.connection_lost_callback) self.protocol = prot prot.factory = self log("addr: %s" % str(addr)) return prot def clientConnectionFailed(self, connector, reason): pass def clientConnectionLost(self, connector, reason): pass class PassthroughProtocol(Protocol): """ A protocol that makes a connection to a remote server and makes callbacks to functions to handle network events """ def __init__(self, data_callback, connection_made_callback, connection_lost_callback): self.data_callback = data_callback self.connection_made_callback = connection_made_callback self.connection_lost_callback = connection_lost_callback self.connected = False def dataReceived(self, data): self.data_callback(data) def connectionMade(self): self.connected = True self.connection_made_callback(self) def connectionLost(self, reason): self.connected = False self.connection_lost_callback(reason) class ProxyProtocolFactory(ServerFactory): next_int_macro_id = 0 def __init__(self): self._int_macros = {} self._macro_order = [] self._macro_names = {} def add_intercepting_macro(self, macro, name=None): new_id = self._get_int_macro_id() self._int_macros[new_id] = macro self._macro_order.append(new_id) self._macro_names[new_id] = name def remove_intercepting_macro(self, macro_id=None, name=None): if macro_id is None and name is None: raise PappyException("Either macro_id or name must be given") ids_to_remove = [] if macro_id: ids_to_remove.append(macro_id) if name: for k, v in self._macro_names.iteritems(): if v == name: ids_to_remove.append(k) for i in ids_to_remove: if i in self._macro_order: self._macro_order.remove(i) if i in self._macro_names: del self._macro_names[i] if i in self._int_macros: del self._int_macros[i] def get_macro_list(self): return [self._int_macros[i] for i in self._macro_order] @staticmethod def _get_int_macro_id(): i = ProxyProtocolFactory.next_int_macro_id ProxyProtocolFactory.next_int_macro_id += 1 return i def buildProtocol(self, addr): prot = ProxyProtocol() prot.factory = self return prot class ProxyProtocol(Protocol): """ The protocol hooked on to a listening port. """ protocol = "http" def __init__(self): from pappyproxy.http import HTTPProtocolProxy self.protocol_proxy = HTTPProtocolProxy() self.protocol_proxy.client_protocol = self def dataReceived(self, data): self.protocol_proxy.client_data_received(data) def connectionMade(self): self.protocol_proxy.client_connection_made(self) def connectionLost(self, reason): self.protocol_proxy.client_connection_lost(reason) class MaybeTLSProtocol(Protocol): """ A protocol that wraps another protocol and will guess whether the incoming data is TLS and if it is, attempts to strip the TLS before passing it to the protocol """ STATE_DECIDING = 0 STATE_PASSTHROUGH = 1 def __init__(self, protocol, tls_host, start_tls_callback=None): self.protocol = protocol self.state = MaybeTLSProtocol.STATE_DECIDING self._data_buffer = '' self.start_tls_callback = start_tls_callback self.tls_host = tls_host def log(self, message, symbol='*', verbosity_level=3): if hasattr(self, "connection_id"): log(message, id=self.connection_id, symbol=symbol, verbosity_level=verbosity_level) else: log(message, symbol=symbol, verbosity_level=verbosity_level) def decide_plaintext(self): self.protocol.dataReceived(self._data_buffer) self._data_buffer = '' self.state = MaybeTLSProtocol.STATE_PASSTHROUGH def decide_tls(self): # Store the original transport. I think that startTLS changes self.transport transport = self.transport # Calling startTLS wraps whatever protocol is currently associated with the # transport in another protocol that handles TLS. We want to send the data # we already received to that protocol since the data we received is part # of the TLS handshake self.transport.startTLS(generate_tls_context(self.tls_host)) transport.protocol.dataReceived(self._data_buffer) # The TLS protocol wrapper will send us the decrypted data so we should go # into passthrough mode self._data_buffer = '' self.state = MaybeTLSProtocol.STATE_PASSTHROUGH # Make the callback if self.start_tls_callback is not None: self.start_tls_callback() def guess_if_tls(self): if self._data_buffer == '': return # Is the first byte the byte of a ClientHello? if ord(self._data_buffer[0]) == 0x16: # Yes! Assume TLS self.decide_tls() else: # Nope! It's plaintext self.decide_plaintext() def dataReceived(self, data): if self.state == MaybeTLSProtocol.STATE_DECIDING: self._data_buffer += data self.guess_if_tls() elif self.state == MaybeTLSProtocol.STATE_PASSTHROUGH: self.protocol.dataReceived(data) else: raise Exception("Protocol in invalid state")