MITMf como un Proxy transparente?

1

¿Es posible usar MITMf para oler como un proxy transparente? Si me conecto a este proxy, me gustaría ver mi IP real, no la IP del servidor. Si es posible, ¿cómo puedo hacerlo? Encontré este archivo "ClientRequest.py", pero no sé python. Tal vez alguien me pueda ayudar a configurar el proxy para que no edite los encabezados?

class ClientRequest(Request):

    ''' This class represents incoming client requests and is essentially where
    the magic begins.  Here we remove the client headers we dont like, and then
    respond with either favicon spoofing, session denial, or proxy through HTTP
    or SSL to the server.
    '''

    def __init__(self, channel, queued, reactor=reactor):
        Request.__init__(self, channel, queued)
        self.reactor       = reactor
        self.urlMonitor    = URLMonitor.getInstance()
        self.cookieCleaner = CookieCleaner.getInstance()
        self.dnsCache      = DnsCache.getInstance()
        #self.uniqueId      = random.randint(0, 10000)

    def cleanHeaders(self):
        headers = self.getAllHeaders().copy()

        if 'accept-encoding' in headers:
             del headers['accept-encoding']
             log.debug("[ClientRequest] Zapped encoding")

        if 'if-modified-since' in headers:
            del headers['if-modified-since']

        if 'cache-control' in headers:
            del headers['cache-control']

        if 'host' in headers:
            try:
                for entry in self.urlMonitor.cookies[self.urlMonitor.hijack_client]:
                    if headers['host'] == entry['host']:
                        log.info("Hijacking session for host: {}".format(headers['host']))
                        headers['cookie'] = entry['cookie']
            except KeyError:
                log.error("No captured sessions (yet) from {}".format(self.urlMonitor.hijack_client))

        return headers

    def getPathFromUri(self):
        if (self.uri.find("http://") == 0):
            index = self.uri.find('/', 7)
            return self.uri[index:]

        return self.uri   

    def handleHostResolvedSuccess(self, address):
        log.debug("[ClientRequest] Resolved host successfully: {} -> {}".format(self.getHeader('host'), address))
        host              = self.getHeader("host")
        headers           = self.cleanHeaders()
        client            = self.getClientIP()
        path              = self.getPathFromUri()
        url               = 'http://' + host + path
        self.uri = url # set URI to absolute

        if self.content:
            self.content.seek(0,0)

        postData = self.content.read()

        hostparts = host.split(':')
        self.dnsCache.cacheResolution(hostparts[0], address)

        if (not self.cookieCleaner.isClean(self.method, client, host, headers)):
            log.debug("[ClientRequest] Sending expired cookies")
            self.sendExpiredCookies(host, path, self.cookieCleaner.getExpireHeaders(self.method, client, host, headers, path))

        elif self.urlMonitor.isSecureLink(client, url):
            log.debug("[ClientRequest] Sending request via SSL ({})".format((client,url)))
            self.proxyViaSSL(address, self.method, path, postData, headers, self.urlMonitor.getSecurePort(client, url))

        else:
            log.debug("[ClientRequest] Sending request via HTTP")
            #self.proxyViaHTTP(address, self.method, path, postData, headers)
            port = 80
            if len(hostparts) > 1:
                port = int(hostparts[1])

            self.proxyViaHTTP(address, self.method, path, postData, headers, port)

    def handleHostResolvedError(self, error):
        log.debug("[ClientRequest] Host resolution error: {}".format(error))
        try:
            self.finish()
        except:
            pass

    def resolveHost(self, host):
        address = self.dnsCache.getCachedAddress(host)

        if address != None:
            log.debug("[ClientRequest] Host cached: {} {}".format(host, address))
            return defer.succeed(address)
        else:
            return reactor.resolve(host)

    def process(self):
        log.debug("[ClientRequest] Resolving host: {}".format(self.getHeader('host')))
        host = self.getHeader('host').split(":")[0]              

        deferred = self.resolveHost(host)
        deferred.addCallback(self.handleHostResolvedSuccess)
        deferred.addErrback(self.handleHostResolvedError)

    def proxyViaHTTP(self, host, method, path, postData, headers, port):
        connectionFactory          = ServerConnectionFactory(method, path, postData, headers, self)
        connectionFactory.protocol = ServerConnection
        #self.reactor.connectTCP(host, 80, connectionFactory)
        self.reactor.connectTCP(host, port, connectionFactory)

    def proxyViaSSL(self, host, method, path, postData, headers, port):
        clientContextFactory       = ssl.ClientContextFactory()
        connectionFactory          = ServerConnectionFactory(method, path, postData, headers, self)
        connectionFactory.protocol = SSLServerConnection
        self.reactor.connectSSL(host, port, connectionFactory, clientContextFactory)

    def sendExpiredCookies(self, host, path, expireHeaders):
        self.setResponseCode(302, "Moved")
        self.setHeader("Connection", "close")
        self.setHeader("Location", "http://" + host + path)

        for header in expireHeaders:
            self.setHeader("Set-Cookie", header)

        self.finish()        
    
pregunta johnmet 17.08.2016 - 10:56
fuente

2 respuestas

1

Basado en las respuestas de esta pregunta , la respuesta es una cuestión de dos principios:

  1. La configuración de proxy . puede configurar el proxy para que no edite encabezados, especialmente los campos como X-Forwarded-For y X-Client-IP .
  2. Modificaciones del cliente . Muchos proxies transparentes permitirán que pase el tráfico SSL sin proxy, ya que el proxy de una conexión SSL requiere certificados de suplantación de identidad.
    Así que la dirección SSL es la IP "real" y la dirección no SSL es la dirección del proxy. / li>
respondido por el Emadeddin 17.08.2016 - 13:22
fuente
1

No puede, un proxy transparente es más o menos un abuso de idioma, es transparente para el usuario final porque no requiere configuración en la parte del usuario final (la estación de trabajo simplemente realiza las solicitudes normales).

Para que un proxy funcione, debe interceptar el flujo, finalizará el flujo de la estación de trabajo y realizará la solicitud en nombre del cliente. La dirección de origen será la dirección proxy del servidor remoto. (Algunos cortafuegos realizarán un análisis fuera de banda para el tráfico de texto claro cuando esto no sea cierto, pero por lo general es "quebradizo" y, de nuevo, se limita a texto claro)

Para el análisis de las solicitudes SSL, el firewall finalizará el flujo, presentará un certificado que coincida con el sitio, principalmente firmando un nuevo certificado con el mismo tema y nombres alternativos, pero emitido por sí mismo.
Por lo tanto, la estación de trabajo habla ssl con el firewall, y el firewall habla ssl con el sitio remoto. Por lo general (transparencia), la Autoridad del firewall será autofirmada / AC de la empresa, por lo que cualquier estación de trabajo fuera de control (invitados) sabrá que hay un MITM. Pero no hay nada que les impida utilizar un certificado de confianza "generalmente" (y eso es solo una cuestión de dinero para obtener el certificado correcto).

Su código de Python actúa como un proxy 'clásico', la estación de trabajo se conecta a él y el programa realiza la solicitud al sitio remoto, pasando la respuesta a la estación de trabajo original.

TL; Dr: un hombre en el medio está, como nombre del estado, en medio de la comunicación y, por lo tanto, la IP vista por el servidor remoto será la IP pública proxy (que podría ser la IP pública de un firewall) haciendo NAT más adelante en la cadena de enrutamiento)

    
respondido por el Tensibai 13.02.2017 - 23:29
fuente

Lea otras preguntas en las etiquetas