Découverte d'IP publique par programmation

StackOverflow https://stackoverflow.com/questions/613471

  •  03-07-2019
  •  | 
  •  

Question

Je suis derrière un routeur, il me faut une simple commande pour découvrir mon adresse IP publique (au lieu de googler mon adresse IP et de cliquer sur l'un des résultats)

Existe-t-il des protocoles standard pour cela? J'ai entendu parler de STUN mais je ne sais pas comment l'utiliser.

P.S. Je prévois d’écrire un court script python pour le faire

Était-ce utile?

La solution

MODIFIER : curlmyip.com n'est plus disponible. (merci maxywb)

Message d'origine :

À la date de rédaction de ce message, curlmyip.com fonctionne. A partir de la ligne de commande: 

curl curlmyip.com

Il s’agit d’un site Web tiers, qui pourrait ne pas être disponible dans quelques années. Mais pour le moment, cela semble assez simple et précis.

Autres conseils

C'est peut-être le moyen le plus simple. Analyser le résultat des commandes suivantes:

  1. lancez un traceroute pour trouver un routeur situé à moins de 3 sauts de votre ordinateur.
  2. lancez ping avec l'option pour enregistrer l'itinéraire source et analyser la sortie. La première adresse IP de l’itinéraire enregistré est votre adresse publique.

Par exemple, je suis sur un ordinateur Windows, mais la même idée devrait également fonctionner sous Unix. 

> tracert -d www.yahoo.com

Tracing route to www-real.wa1.b.yahoo.com [69.147.76.15]
over a maximum of 30 hops:

  1    <1 ms    <1 ms    <1 ms  192.168.14.203
  2     *        *        *     Request timed out.
  3     8 ms     8 ms     9 ms  68.85.228.121
  4     8 ms     8 ms     9 ms  68.86.165.234
  5    10 ms     9 ms     9 ms  68.86.165.237
  6    11 ms    10 ms    10 ms  68.86.165.242

Le 68.85.228.121 est un routeur Comcast (mon fournisseur). Nous pouvons cingler ça: 

> ping -r 9 68.85.228.121 -n 1

Pinging 68.85.228.121 with 32 bytes of data:

Reply from 68.85.228.121: bytes=32 time=10ms TTL=253
    Route: 66.176.38.51 ->
           68.85.228.121 ->
           68.85.228.121 ->
           192.168.14.203

voila! Le 66.176.38.51 est mon adresse IP publique.

J'ai créé un programme qui se connecte à http://automation.whatismyip.com/n09230945.asp. il est écrit en D et de demander à quelqu'un d'autre de vous dire ce qu'il voit votre adresse IP, car c'est probablement le moyen le plus fiable: 

/*
    Get my IP address
*/


import tango.net.http.HttpGet;
import tango.io.Stdout;

void main()
{
      try
      {
          auto page = new HttpGet ("http://automation.whatismyip.com/n09230945.asp");
          Stdout(cast(char[])page.read);
      }
      catch(Exception ex)
      {
          Stdout("An exception occurred");
      }
}

Modifier le code python devrait ressembler à: 

from urllib import urlopen
print urlopen('http://automation.whatismyip.com/n09230945.asp').read()

Cibler www.whatsmyip.org est impoli. Ils plaident de ne pas faire cela sur la page.

Seul un système ayant le même niveau de NAT que votre cible verra la même adresse IP. Par exemple, votre application peut se trouver derrière plusieurs couches de NAT (cela se produit davantage lorsque vous vous éloignez des États-Unis, où se trouvent la surabondance d'adresses IP).

STUN est en effet la meilleure méthode. En général, vous devriez planifier de lancer un serveur (STUN) quelque part que vous L'application peut demander: ne codez pas en dur les serveurs d'autres personnes. Vous devez coder d’envoyer des messages spécifiques comme décrit dans rfc5389.

Je suggère une bonne lecture et des liens connexes. http://www.ietf.org/html.charters/behave-charter.html

Vous préférerez peut-être regarder IPv6 et Teredo pour vous assurer de toujours avoir un accès IPv6. (Microsoft Vista rend cela très facile, me dit-on)

Chaque fois que je voulais faire cela, je ne ferais que gratter whatismyip.org . Lorsque vous visitez le site, il vous donne votre adresse IP publique en texte brut. Clair et simple.

Demandez à votre script d'accéder à ce site et de lire l'adresse IP.

Je ne sais pas si vous avez laissé entendre cela dans votre message ou non, mais il n'est pas possible d'obtenir votre adresse IP publique à partir de votre propre ordinateur. Cela doit venir d'une source externe.

Édition 2013: ce site renvoie une image maintenant au lieu d'un texte, il est donc inutile à cet effet.

J'aime le ipify.org :

  • son utilisation est libre (même par programmation et même un trafic important)
    • La réponse
  • contient uniquement l'adresse IP sans aucun déchet (aucune analyse nécessaire)
  • vous pouvez également demander une réponse en JSON
  • fonctionne à la fois pour IPv4 et IPv6
  • il est hébergé dans le cloud
  • c'est open source 
$ curl api.ipify.org
167.220.196.42

$ curl "api.ipify.org?format=json"
{"ip":"167.220.196.42"}

Comme l'ont mentionné plusieurs personnes, STUN est bien la solution appropriée.

Si le réseau dispose d'un serveur UpNp s'exécutant sur la passerelle, vous pouvez lui parler et lui demander votre adresse IP externe.

Votre façon la plus simple peut-être de demander à un serveur situé à l'extérieur de votre réseau.

Une chose à garder à l'esprit est que différentes destinations peuvent voir une adresse différente pour vous. Le routeur est peut-être multi-hôte. Et c’est vraiment là que les problèmes commencent.

Pour obtenir votre adresse IP externe, vous pouvez adresser une requête DNS à un serveur OpenGL avec le nom d’hôte spécial "myip.opendns.com":

. 
from subprocess import check_output

ip = check_output(["dig", "+short", "@resolver1.opendns.com",
                   "myip.opendns.com"]).decode().strip()

Sous Windows, vous pouvez essayer nslookup .

Il n’existe aucun module DNS dans Python stdlib qui permettrait de spécifier un serveur DNS personnalisé. Vous pouvez utiliser des bibliothèques tierces, par exemple, Twisted pour créer la requête DNS: 

from twisted.internet     import task # $ pip install twisted
from twisted.names.client import Resolver
from twisted.python.util  import println

def main(reactor):
    opendns_resolvers = [("208.67.222.222", 53), ("208.67.220.220", 53)]
    resolver = Resolver(servers=opendns_resolvers, reactor=reactor)
    # use magical hostname to get our public ip
    return resolver.getHostByName('myip.opendns.com').addCallback(println)
task.react(main)

Voici la même chose avec la dnspython bibliothèque : 

import dns.resolver # $ pip install dnspython

resolver = dns.resolver.Resolver(configure=False)
resolver.nameservers = ["208.67.222.222", "208.67.220.220"]
print(resolver.query('myip.opendns.com')[0])

une autre façon effrontée: Si votre routeur a la possibilité de mettre à jour son IP Web sur DynDNS , vous pouvez obtenir votre propre IP avec quelque chose comme: : 

IP=`resolveip -s myalias.dyndns-home.com`

Duck Duck Go donne un accès gratuit à leur API selon leur propre page ici: https://duckduckgo.com/api

Voici l'URL que vous avez indiquée si vous souhaitez connaître votre adresse IP: http://api.duckduckgo.com/?q=my+ip&format= json

Cela retourne un objet JSON. L'attribut Answer a une chaîne lisible par l'homme contenant votre adresse IP. Exemple: 

{
    ...
    "Answer": "Your IP address is ww.xx.yyy.zzz in <a href=\"http://open.mapquest.com/?q=aaaaa(bbbbb)\">aaaaa(bbbbb)</a>"
    ...
}

Vous pouvez extraire l'adresse ip de cette chaîne en utilisant split () [4] , si vous pensez qu'il est prudent de supposer que cette chaîne ne changera jamais ou si vous êtes prêt à le faire. besoin de le réparer périodiquement.

Autrement, si vous souhaitez utiliser une méthode plus fiable, vous pouvez effectuer une boucle sur tout ce qui est renvoyé par split () et renvoyer le premier élément représentant une adresse IP. Voir ici pour valider les adresses IP: Comment valider une adresse IP en Python?

curl api.infoip.io - tous les détails

curl api.infoip.io/ip - uniquement l'adresse IP

curl api.infoip.io/country - uniquement le nom du pays

... et plus du même

vous pouvez afficher les documents sur http://docs.ciokan.apiary.io/

Je vous partage ma méthode de récupération de l'adresse IP publique d'un serveur sans avoir à utiliser des API externes (ce qui pose évidemment un risque pour la sécurité) 

INTERFACE=`ip route get 8.8.8.8 | grep 8.8.8.8 | cut -d' ' -f5`
HOSTIP=`ifconfig $INTERFACE | grep "inet " | awk -F'[: ]+' '{ print $4 }'`

Ou en python si vous préférez: 

import subprocess
public_ip = subprocess.check_output(["ifconfig `ip route get 8.8.8.8 | grep 8.8.8.8 | cut -d' ' -f5` | grep \'inet \' | awk -F'[: ]+' '{ print $4 }'"], shell=True)

Cela fonctionne comme ceci:

  • détermine la meilleure interface pour atteindre le serveur google dns
  • greps adresse IP publique à partir de l'entrée ifconfig pour cette interface

C’est désormais très économique d’héberger votre propre " serveurless " API. Tous les principaux fournisseurs de cloud ont un service pour cela. Par exemple, avec Google Cloud Functions, il vous suffit: 

exports.requestIP = (req, res) => {
    res.status(200).send(req.ip)
}

Cette approche est probablement plus fiable que l'utilisation des services publics ci-dessus et vous pouvez ajouter une longue chaîne aléatoire au nom de la fonction pour la garder privée.

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top