Wie kann ich sicher bekommen die user die echte IP-Adresse im Kolben (mit mod_wsgi)?

Können Sie die - Anfrage.access_route - Attribut nur, wenn Sie definieren eine Liste von vertrauenswürdigen proxies.

Den access_route Attribut die X-Forwarded-For - header, fällt zurück auf die REMOTE_ADDR WSGI-variable; letzteres ist in Ordnung, da dein server bestimmt; die X-Forwarded-For könnte haben gerade über jedermann, aber wenn Sie Vertrauen, einen proxy, um den Wert korrekt, dann verwenden Sie das erste (vom Ende), das ist nicht trusted:

trusted_proxies = {'127.0.0.1'}  # define your own set
route = request.access_route + [request.remote_addr]

remote_addr = next((addr for addr in reversed(route) 
                    if addr not in trusted_proxies), request.remote_addr)

Diese Weise, selbst wenn jemand fälscht die X-Forwarded-For header mit fake_ip1,fake_ip2 ist, dass der proxy-server hinzufügen ,spoof_machine_ip zu Ende, und der obige code setzt die remote_addr zu spoof_machine_ip, egal, wie viele Vertrauenswürdige Proxys gibt es zusätzlich zu Ihrem äußersten proxy.

Dies ist der whitelist-Ansatz Ihrem verlinkten Artikel spricht über (kurz, in Rails verwendet es), und was Zope implementiert über 11 Jahren.

Ihre ProxyFix Ansatz funktioniert ganz gut, aber Sie missverstanden, was es tut. Es nur setzt request.remote_addr; die request.access_route Attribut ist unverändert (die X-Forwarded-For header ist nicht eingestellt werden, indem die middleware). Jedoch, wäre ich sehr vorsichtig mit blind-zählen-aus-proxies.

Anwendung der gleichen whitelist-Ansatz an die middleware würde wie folgt Aussehen:

class WhitelistRemoteAddrFix(object):
    """This middleware can be applied to add HTTP proxy support to an
    application that was not designed with HTTP proxies in mind.  It
    only sets `REMOTE_ADDR` from `X-Forwarded` headers.

    Tests proxies against a set of trusted proxies.

    The original value of `REMOTE_ADDR` is stored in the WSGI environment
    as `werkzeug.whitelist_remoteaddr_fix.orig_remote_addr`.

    :param app: the WSGI application
    :param trusted_proxies: a set or sequence of proxy ip addresses that can be trusted.
    """

    def __init__(self, app, trusted_proxies=()):
        self.app = app
        self.trusted_proxies = frozenset(trusted_proxies)

    def get_remote_addr(self, remote_addr, forwarded_for):
        """Selects the new remote addr from the given list of ips in
        X-Forwarded-For.  Picks first non-trusted ip address.
        """

        if remote_addr in self.trusted_proxies:
            return next((ip for ip in reversed(forwarded_for)
                         if ip not in self.trusted_proxies),
                        remote_addr)

    def __call__(self, environ, start_response):
        getter = environ.get
        remote_addr = getter('REMOTE_ADDR')
        forwarded_for = getter('HTTP_X_FORWARDED_FOR', '').split(',')
        environ.update({
            'werkzeug.whitelist_remoteaddr_fix.orig_remote_addr': remote_addr,
        })
        forwarded_for = [x for x in [x.strip() for x in forwarded_for] if x]
        remote_addr = self.get_remote_addr(remote_addr, forwarded_for)
        if remote_addr is not None:
            environ['REMOTE_ADDR'] = remote_addr
        return self.app(environ, start_response)

Explizit: dieser middleware auch nur setzt request.remote_addr; request.access_route bleibt unberührt.

Können Sie nicht sicher, denn das kann man nicht Vertrauen, alle Teile, die in einer http - (oder tcp -) Verbindung