Como obtenho o endereço IP do usuário no django?


287

Como obtenho o IP do usuário no django?

Eu tenho uma visão como esta:

# Create your views
from django.contrib.gis.utils import GeoIP
from django.template import  RequestContext
from django.shortcuts import render_to_response


def home(request):
  g = GeoIP()
  client_ip = request.META['REMOTE_ADDR']
  lat,long = g.lat_lon(client_ip)
  return render_to_response('home_page_tmp.html',locals())

Mas eu recebo este erro:

KeyError at /mypage/
    'REMOTE_ADDR'
    Request Method: GET
    Request URL:    http://mywebsite.com/mypage/
    Django Version: 1.2.4
    Exception Type: KeyError
    Exception Value:    
    'REMOTE_ADDR'
    Exception Location: /mysite/homepage/views.py in home, line 9
    Python Executable:  /usr/bin/python
    Python Version: 2.6.6
    Python Path:    ['/mysite', '/usr/local/lib/python2.6/dist-packages/flup-1.0.2-py2.6.egg', '/usr/lib/python2.6', '/usr/lib/python2.6/plat-linux2', '/usr/lib/python2.6/lib-tk', '/usr/lib/python2.6/lib-old', '/usr/lib/python2.6/lib-dynload', '/usr/local/lib/python2.6/dist-packages', '/usr/lib/python2.6/dist-packages', '/usr/lib/pymodules/python2.6']
    Server time:    Sun, 2 Jan 2011 20:42:50 -0600

2
Tente despejar request.META.keys ()
Martin v. Löwis

2
['HTTP_COOKIE', 'SCRIPT_NAME', 'REQUEST_METHOD', 'PATH_INFO', 'SERVER_PROTOCOL', 'QUERY_STRING', 'CONTENT_LENGTH', 'HTTP_ACCEPT_CHARSET', 'HTTP_USER_AGENT', 'HTTP_CONNECTION', 'HTTP_CONNECTION', 'HTTP_CONNECTION'. , 'SERVER_PORT', 'wsgi.input', 'HTTP_HOST', 'wsgi.multithread', 'HTTP_CACHE_CONTROL', 'HTTP_ACCEPT', 'wsgi.version', 'wsgi.run_once', 'wsgi.errors', 'wsgi. multiprocess ',' HTTP_ACCEPT_LANGUAGE ',' CONTENT_TYPE ',' CSRF_COOKIE ',' HTTP_ACCEPT_ENCODING ']
avatar

2
Obrigado por esta ótima pergunta. Meu fastcgi não estava passando a meta-chave REMOTE_ADDR. Adicionei a linha abaixo no nginx.conf e resolvi o problema: fastcgi_param REMOTE_ADDR $ remote_addr;
avatar

Respostas:


435
def get_client_ip(request):
    x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
    if x_forwarded_for:
        ip = x_forwarded_for.split(',')[0]
    else:
        ip = request.META.get('REMOTE_ADDR')
    return ip

Verifique se o proxy reverso (se houver) está configurado corretamente (por exemplo, mod_rpafinstalado para o Apache).

Nota: o item acima usa o primeiro item X-Forwarded-For, mas você pode usar o último item (por exemplo, no caso do Heroku: obter o endereço IP real do cliente no Heroku )

E então apenas passe a solicitação como argumento para ela;

get_client_ip(request)

8
Chame ip = get_client_ip(request)sua função de visualização.
precisa saber é o seguinte

4
O endereço IP do cliente real não é o primeiro, mas o último em HTTP_X_FORWARDED_FOR (consulte a página wikipedia)
jujule

5
@ujujule Isso não está correto. O formato é tipicamente X-Forwarded-For: client, proxy1, proxy2. Portanto, o primeiro endereço é do cliente.
Michael Waterfall

51
Esta função é perigosa. Em muitas configurações, um usuário mal-intencionado pode facilmente fazer com que essa função retorne qualquer endereço que desejar (em vez do endereço real). Veja esd.io/blog/flask-apps-heroku-real-ip-spoofing.html
Eli

8
Nos documentos do django, "confiar em REMOTE_ADDR ou valores semelhantes é amplamente conhecido como a pior prática" ( djangoproject.com/weblog/2009/jul/28/security/#secondary-issue )
Zags

209

Você pode usar o django-ipware que suporta Python 2 e 3 e lida com IPv4 e IPv6 .

Instalar:

pip install django-ipware

Uso simples:

# In a view or a middleware where the `request` object is available

from ipware import get_client_ip
ip, is_routable = get_client_ip(request)
if ip is None:
    # Unable to get the client's IP address
else:
    # We got the client's IP address
    if is_routable:
        # The client's IP address is publicly routable on the Internet
    else:
        # The client's IP address is private

# Order of precedence is (Public, Private, Loopback, None)

Uso avançado:

  • Cabeçalho personalizado - Cabeçalho de solicitação personalizado para o ipware olhar para:

    i, r = get_client_ip(request, request_header_order=['X_FORWARDED_FOR'])
    i, r = get_client_ip(request, request_header_order=['X_FORWARDED_FOR', 'REMOTE_ADDR'])
    
  • Contagem de Proxy - O servidor Django está atrás de um número fixo de proxies:

    i, r = get_client_ip(request, proxy_count=1)
  • Proxies Confiáveis ​​- O servidor Django está atrás de um ou mais proxies conhecidos e confiáveis:

    i, r = get_client_ip(request, proxy_trusted_ips=('177.2.2.2'))
    
    # For multiple proxies, simply add them to the list
    i, r = get_client_ip(request, proxy_trusted_ips=('177.2.2.2', '177.3.3.3'))
    
    # For proxies with fixed sub-domain and dynamic IP addresses, use partial pattern
    i, r = get_client_ip(request, proxy_trusted_ips=('177.2.', '177.3.'))
    

Nota: leia este aviso .


17
Dê uma olhada no seu código fonte. Ele lida com todas as complicações identificadas pelas outras respostas aqui.
HostedMetrics.com

5
Thx @Heliodor - Sim, tornei o módulo muito simples para um caso de uso médio e muito flexível para um caso de uso complexo. No mínimo, você gostaria de ver a página do github antes de lançar a sua.
Un33k

3
Observe que as configurações do django-ipware não são seguras por padrão! Qualquer pessoa pode passar uma das outras variáveis ​​e seu site registrará esse IP. Sempre definido IPWARE_META_PRECEDENCE_LISTpara a variável que você usa, ou usar uma alternativa como pypi.python.org/pypi/WsgiUnproxy
vdboor

@vdboor Você poderia elaborar um pouco? Não consigo encontrar IPWARE_META_PRECEDENCE_LIST no repositório.
9156 Monolith

2
@ThaJay Observe que a partir da 2.0.0, você deve usar get_client_ip(). get_real_ipfoi descontinuado e será removido no 3.0.
Un33k

77

A resposta de Alexander é ótima, mas falta o tratamento de proxies que às vezes retornam vários IPs no cabeçalho HTTP_X_FORWARDED_FOR.

O IP real geralmente está no final da lista, conforme explicado aqui: http://en.wikipedia.org/wiki/X-Forwarded-For

A solução é uma simples modificação do código de Alexander:

def get_client_ip(request):
    x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
    if x_forwarded_for:
        ip = x_forwarded_for.split(',')[-1].strip()
    else:
        ip = request.META.get('REMOTE_ADDR')
    return ip

5
Sim, o ip está no início da lista. Isso aqui está errado.
Pykler

4
Na verdade, se o usuário estiver atrás de um proxy, você obterá o endereço IP interno do usuário, ou seja, um endereço RFC 1918. Na maioria dos casos, isso não é muito desejável. Esta solução se concentra em obter o endereço IP externo do cliente (o endereço proxy), que é o endereço mais à direita.
Sævar

2
Obrigado. Normalmente, quando solicito chaves request.META, incluo um valor padrão, pois os cabeçalhos costumam aparecer:request.META.get('REMOTE_ADDR', None)
Carl G

2
@CarlG, seu código é mais transparente, mas o método get é herdado de django.utils.datastructures.MultiValueDict e o valor padrão é None. Mas definitivamente faz sentido incluir um valor padrão se você realmente quiser que seja algo diferente de Nenhum.
Sævar

2
A menos que você esteja limpando o X-Forwarded-For quando as solicitações atingirem o seu primeiro servidor, o primeiro valor nessa lista será fornecido pelo usuário . Um usuário mal-intencionado pode falsificar facilmente qualquer endereço IP que desejar. O endereço que você deseja é o primeiro IP antes de qualquer um dos seus servidores, não necessariamente o primeiro da lista.
Eli

12

Eu gostaria de sugerir uma melhoria na resposta de yanchenko.

Em vez de pegar o primeiro ip na lista X_FORWARDED_FOR, eu pego o primeiro que não é um ip interno conhecido, pois alguns roteadores não respeitam o protocolo e você pode ver os ips internos como o primeiro valor da lista.

PRIVATE_IPS_PREFIX = ('10.', '172.', '192.', )

def get_client_ip(request):
    """get the client ip from the request
    """
    remote_address = request.META.get('REMOTE_ADDR')
    # set the default value of the ip to be the REMOTE_ADDR if available
    # else None
    ip = remote_address
    # try to get the first non-proxy ip (not a private ip) from the
    # HTTP_X_FORWARDED_FOR
    x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
    if x_forwarded_for:
        proxies = x_forwarded_for.split(',')
        # remove the private ips from the beginning
        while (len(proxies) > 0 and
                proxies[0].startswith(PRIVATE_IPS_PREFIX)):
            proxies.pop(0)
        # take the first ip which is not a private one (of a proxy)
        if len(proxies) > 0:
            ip = proxies[0]

    return ip

Espero que isso ajude outros Googlers que têm o mesmo problema.


Esse código não verifica se o ip de REMOTE_ADDR é privado antes de verificar o campo HTTP_X_FORWARDED_FOR, como provavelmente deveria (também '127.0.0.1' ou '127.' provavelmente deveria estar em PRIVATE_IPS_PREFIX, junto com os equivalentes do IPv6.
Rasmus Kaj

1
Tecnicamente, esses prefixos (172, 192) não significam necessariamente endereços privados.
maniexx

2
Os intervalos de endereços atribuídos para redes privadas são: 172.16.0.0–172.31.255.255 (16 redes “classe B”), 192.168.0.0–192.168.255.255 (1 rede “classe B”) e 10.0.0.0–10.255.255.255 (1 Redes "classe A" ou 256 "classe B").
tzot

is_valid_ip não definido
Prosenjit

7

aqui está uma lista curta para fazer isso:

request.META.get('HTTP_X_FORWARDED_FOR', request.META.get('REMOTE_ADDR', '')).split(',')[0].strip()

3
Se os dois retornarem Nenhum, você receberá um erro.
Gourav Chawla

6

A solução mais simples (caso você esteja usando o fastcgi + nignx) é o que o itgorilla comentou:

Obrigado por esta ótima pergunta. Meu fastcgi não estava passando a meta-chave REMOTE_ADDR. Adicionei a linha abaixo no nginx.conf e resolvi o problema: fastcgi_param REMOTE_ADDR $ remote_addr; - itgorilla

Ps: eu adicionei esta resposta apenas para tornar sua solução mais visível.


1
O que é uma solução comparável para nginx (proxy reverso) e gunicorn? proxy_set_header REMOTE_ADDR $remote_addr;não alivia o problema quando adicionado ao nginx.conf.
Hassan Baig

6

Sem mais confusão Nas versões recentes do Django, é mencionado claramente que o endereço IP do cliente está disponível em

request.META.get("REMOTE_ADDR")

para mais informações consulte o Django Docs


5

No meu caso, nenhuma das opções acima funciona, então eu tenho que verificar o uwsgi+ djangocódigo-fonte e passar o parâmetro estático no nginx e ver por que / como e abaixo está o que encontrei.

Informações do Env:
python version: 2.7.5
Django version: (1, 6, 6, 'final', 0)
nginx version: nginx/1.6.0
uwsgi:2.0.7

Informações da configuração do Env:
nginx como proxy reverso escutando na porta 80 uwsgi como soquete unix upstream, responderá à solicitação eventualmente

Informações de configuração do Django:

USE_X_FORWARDED_HOST = True # with or without this line does not matter

configuração nginx:

uwsgi_param      X-Real-IP              $remote_addr;
// uwsgi_param   X-Forwarded-For        $proxy_add_x_forwarded_for;
// uwsgi_param   HTTP_X_FORWARDED_FOR   $proxy_add_x_forwarded_for;

// hardcode for testing
uwsgi_param      X-Forwarded-For        "10.10.10.10";
uwsgi_param      HTTP_X_FORWARDED_FOR   "20.20.20.20";

obtendo todos os parâmetros no aplicativo django:

X-Forwarded-For :       10.10.10.10
HTTP_X_FORWARDED_FOR :  20.20.20.20

Conclusão:

Então, basicamente, você deve especificar exatamente o mesmo nome de campo / parâmetro no nginx e usar request.META[field/param]no aplicativo django.

E agora você pode decidir se deseja adicionar um middleware (interceptador) ou apenas analisar HTTP_X_FORWARDED_FORem determinadas visualizações.


2

A razão pela qual a funcionalidade foi removida do Django originalmente foi que o cabeçalho não pode ser confiável. A razão é que é fácil falsificar. Por exemplo, a maneira recomendada de configurar um proxy reverso nginx é:

add_header X-Forwarded-For $proxy_add_x_forwarded_for;
add_header X-Real-Ip       $remote_addr;

Quando você faz:

curl -H 'X-Forwarded-For: 8.8.8.8, 192.168.1.2' http://192.168.1.3/

Seu nginx em myhost.com enviará adiante:

X-Forwarded-For: 8.8.8.8, 192.168.1.2, 192.168.1.3

A X-Real-IPserá o IP do primeiro proxy anterior se você seguir as instruções cegamente.

No caso de confiar em quem são seus usuários, você pode tentar algo como django-xff: https://pypi.python.org/pypi/django-xff/


1

Também estava faltando proxy na resposta acima. Eu usei get_ip_address_from_requestde django_easy_timezones .

from easy_timezones.utils import get_ip_address_from_request, is_valid_ip, is_local_ip
ip = get_ip_address_from_request(request)
try:
    if is_valid_ip(ip):
        geoip_record = IpRange.objects.by_ip(ip)
except IpRange.DoesNotExist:
    return None

E aqui está o método get_ip_address_from_request, pronto para IPv4 e IPv6:

def get_ip_address_from_request(request):
    """ Makes the best attempt to get the client's real IP or return the loopback """
    PRIVATE_IPS_PREFIX = ('10.', '172.', '192.', '127.')
    ip_address = ''
    x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR', '')
    if x_forwarded_for and ',' not in x_forwarded_for:
        if not x_forwarded_for.startswith(PRIVATE_IPS_PREFIX) and is_valid_ip(x_forwarded_for):
            ip_address = x_forwarded_for.strip()
    else:
        ips = [ip.strip() for ip in x_forwarded_for.split(',')]
        for ip in ips:
            if ip.startswith(PRIVATE_IPS_PREFIX):
                continue
            elif not is_valid_ip(ip):
                continue
            else:
                ip_address = ip
                break
    if not ip_address:
        x_real_ip = request.META.get('HTTP_X_REAL_IP', '')
        if x_real_ip:
            if not x_real_ip.startswith(PRIVATE_IPS_PREFIX) and is_valid_ip(x_real_ip):
                ip_address = x_real_ip.strip()
    if not ip_address:
        remote_addr = request.META.get('REMOTE_ADDR', '')
        if remote_addr:
            if not remote_addr.startswith(PRIVATE_IPS_PREFIX) and is_valid_ip(remote_addr):
                ip_address = remote_addr.strip()
    if not ip_address:
        ip_address = '127.0.0.1'
    return ip_address

0

No manipulador de solicitações django.VERSION (2, 1, 1, 'final', 0)

sock=request._stream.stream.raw._sock
#<socket.socket fd=1236, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('192.168.1.111', 8000), raddr=('192.168.1.111', 64725)>
client_ip,port=sock.getpeername()

se você chamar o código acima duas vezes, poderá receber

AttributeError ("o objeto '_ io.BytesIO' não possui atributo 'stream'",)

AttributeError ("O objeto 'LimitedStream' não tem atributo 'bruto'")

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.