MITMf come proxy trasparente?

1

È possibile utilizzare MITMf per sniffare come proxy trasparente? Se mi collego a questo proxy vorrei vedere il mio vero IP, non l'IP del server. Se possibile, come posso farlo? Ho trovato questo file "ClientRequest.py", ma non conosco Python. Forse qualcuno può aiutarmi a impostare il proxy per non modificare le intestazioni?

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()        
    
posta johnmet 17.08.2016 - 10:56
fonte

2 risposte

1

In base alle risposte di questa domanda , la risposta è una questione di due principi:

  1. La configurazione del proxy . puoi impostare il proxy per non modificare le intestazioni, in particolare i campi come X-Forwarded-For e X-Client-IP .
  2. Modifiche del cliente . Molti proxy trasparenti permetteranno al traffico SSL di passare senza proxy, dal momento che il proxy di una connessione SSL richiede certificati di spoofing.
    Quindi l'indirizzo SSL è l'IP "reale" e l'indirizzo non SSL è l'indirizzo del proxy.
risposta data 17.08.2016 - 13:22
fonte
1

Non può, un proxy trasparente è più o meno un abuso linguistico, è trasparente per l'utente finale perché non richiede la configurazione sulla parte dell'utente finale (la workstation fa solo richieste normali).

Affinché un proxy funzioni, deve intercettare il flusso, terminerà il flusso della workstation e farà la richiesta per conto del client. L'indirizzo di origine sarà l'indirizzo proxy per il server remoto. (Alcuni firewall eseguiranno un'analisi fuori banda per il traffico di testo libero dove questo non è vero, ma di solito è "fragile" e di nuovo limitato al solo testo chiaro)

Per l'analisi delle richieste SSL, il firewall terminerà il flusso, presenterà un certificato che corrisponde al sito, principalmente firmando un nuovo certificato con lo stesso oggetto e i nomi alternativi, ma emesso da solo.
Quindi la workstation comunica ssl al firewall e il firewall comunica ssl al sito remoto. Solitamente (trasparenza) l'Autorità firewall sarà autofirmata / CA aziendale, quindi qualsiasi postazione di lavoro fuori controllo (ospiti) saprà che esiste un MITM.
Ma non c'è nulla che impedisca loro di usare un certificato "generalmente" di fiducia (e questo è solo una questione di soldi per ottenere il certificato corretto).

Il tuo codice Python funge da proxy "classico", la workstation si connette ad esso e il programma effettua la richiesta al sito remoto, restituendo la risposta alla workstation originale.

TL; Dr: un uomo nel mezzo è, come lo stato del nome, nel mezzo della comunicazione e quindi l'IP visto dal server remoto sarà l'IP pubblico proxy (che potrebbe essere l'IP pubblico di un firewall fare NAT più avanti nella catena di routing)

    
risposta data 13.02.2017 - 23:29
fonte

Leggi altre domande sui tag