Bonsoir j aimerai savoir comment récupérer l adresse Ip EXTERNE pour créer un socket NON-LOCAL

Java ne permet pas de faire ça ? 

Salut. L'adresse IP externe de qui?

Bonjour,

Je pense qu'il te manque une ou deux infos sur le fonctionnement d'un réseau.

Bonjour,

Tu ne peux pas "binder" un socket sur une IP qui ne t'appartient pas...hors l'adresse IP publique (que tu appelles "externe") est celle de ta box (qui est un modem routeur).

Si tu veux accéder à ton serveur depuis l'extérieur de ton réseau local (WAN), il te faut faire plusieurs manips :

- Ouvrir les pare feu pour qu'il laisse passer les flux (IN et OUT) sur le port que tu utilises (Sur ton PC et ta box)

- Créer une règle PAT (Port Adress Translation) qui permet de rediriger les requêtes (TCP par exemple ) que ta box reçoit sur son adresse IP (qui est l'adresse IP publique) vers l'adresse IP privé (de ton réseau local) et le port de ton choix. (Edit : Ou utiliser le protocol UPNP pour papoter avec ta box et qu'elle fasse le boulot seul).

Autrement dit...aucun langage ne permettra de faire cela...dans le cas contraire, ça m'intéresse, mais c'est de la sorcellerie.

Sinon, voilà un moyen de récupérer ton adresse IP publique en Java :

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.Authenticator;
import java.net.HttpURLConnection;
import java.net.InetAddress;
import java.net.PasswordAuthentication;
import java.net.URL;
import java.net.UnknownHostException;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.X509TrustManager;

import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;

public class HTTPFactory {

	private static Logger logger = LogManager.getLogger(HTTPFactory.class);
	private boolean httpsMode = false;
	private Authenticator authentificator;

	/**
	 * @param args
	 */
	public HTTPFactory(String user, String pwd, boolean httpsMode) {
		setAuthentificator(new HTTPAuthenticator(user, pwd));
		setHttpsMode(httpsMode);

		if (httpsMode) {
			javax.net.ssl.HttpsURLConnection.setDefaultHostnameVerifier(new javax.net.ssl.HostnameVerifier() {
				public boolean verify(String hostname, javax.net.ssl.SSLSession sslSession) {
					return true;
				}
			});
			SSLContext context = null;
			try {
				context = SSLContext.getInstance("TLS");
				context.init(null, new X509TrustManager[] { new X509TrustManager() {
					public void checkClientTrusted(X509Certificate[] chain, String authType)
							throws CertificateException {
					}

					public void checkServerTrusted(X509Certificate[] chain, String authType)
							throws CertificateException {
					}

					public X509Certificate[] getAcceptedIssuers() {
						return new X509Certificate[0];
					}
				} }, new SecureRandom());
			} catch (KeyManagementException e) {
				e.printStackTrace();
			} catch (NoSuchAlgorithmException e) {
				e.printStackTrace();
			}
			HttpsURLConnection.setDefaultSSLSocketFactory(context.getSocketFactory());
		}

	}

	public HTTPFactory() {

	}

	public String getHtmlContentOf(String adresse) {
		String htmlContent = null;
		try {
			URL url = new URL(adresse);

			HttpURLConnection connection;
			if (httpsMode) {
				connection = (HttpsURLConnection) url.openConnection();
			} else {
				connection = (HttpURLConnection) url.openConnection();
			}
			connection.setRequestMethod("GET");
			connection.setDoOutput(true);
			InputStream content = (InputStream) connection.getInputStream();
			BufferedReader in = new BufferedReader(new InputStreamReader(content));
			String line;
			while ((line = in.readLine()) != null) {
				htmlContent += line;
			}

			in.close();
			content.close();
			connection.disconnect();
		} catch (Exception e) {
			e.printStackTrace();
			try {
				return InetAddress.getLocalHost().getHostAddress();
			} catch (UnknownHostException e1) {
				e1.printStackTrace();
			}
		}
		return htmlContent;
	}

	public String getIp() {
		String ip = null;
		String content = getHtmlContentOf("http://www.monip.org/");
		Matcher matcher = Pattern.compile("(\\d{1,3}\\.){3}\\d{1,3}").matcher(content);
		if (matcher.find()) {
			ip = matcher.group();
		}
		if (ip != null) {
			logger.info("My IP is " + ip);
			return ip;
		} else {
			logger.info("Unknown IP :(");
		}
		return null;
	}

	public boolean get(String urlString) throws IOException {
		try {
			URL url = new URL(urlString);

			HttpURLConnection connection;
			if (httpsMode) {
				connection = (HttpsURLConnection) url.openConnection();
			} else {
				connection = (HttpURLConnection) url.openConnection();
			}
			connection.setRequestMethod("GET");
			connection.setDoOutput(true);
			InputStream content = (InputStream) connection.getInputStream();
			BufferedReader in = new BufferedReader(new InputStreamReader(content));
			String line;
			while ((line = in.readLine()) != null) {
				logger.debug(line);
			}

			in.close();
			content.close();
			connection.disconnect();
			return true;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return false;
	}

	public static void main(String agrs[]) {
		HTTPFactory http = new HTTPFactory();
		// TorUtils.torifySockets(true);
		http.getIp();		
	}

	public boolean isHttpsMode() {
		return httpsMode;
	}

	public void setHttpsMode(boolean httpsMode) {
		this.httpsMode = httpsMode;
	}

	public Authenticator getAuthentificator() {
		return authentificator;
	}

	private void setAuthentificator(Authenticator authentificator) {
		this.authentificator = authentificator;
	}

	public static class HTTPAuthenticator extends Authenticator {
		private String username, password;

		public HTTPAuthenticator(String user, String pass) {
			username = user;
			password = pass;
		}

		protected PasswordAuthentication getPasswordAuthentication() {
			logger.info("Requesting Host  : " + getRequestingHost());
			logger.info("Requesting Port  : " + getRequestingPort());
			logger.info("Requesting Prompt : " + getRequestingPrompt());
			logger.info("Requesting Protocol: " + getRequestingProtocol());
			logger.info("Requesting Scheme : " + getRequestingScheme());
			logger.info("Requesting Site  : " + getRequestingSite());
			return new PasswordAuthentication(username, password.toCharArray());
		}
	}

}

-
Edité par CeBiM 13 août 2018 à 20:14:39

Salut merci pour ta réponse, j avais déjà trouver cette solution sur le net  c est donc celle que j utilise à peu près, il y a des lignes de code que je ne comprends pas la dedans, comme celle du Pattern.compile par exemple

De plus j ai lu que ce n était pas correct de solliciter un site pour ce genre de requête trop souvent

Salut,

"Pattern.compile" c'est pour utiliser les "expressions régulières". Dans ce cas, pour trouver l'IP dans le contenu HTML de la page web.

Tu as raison, il ne faut pas abuser et envoyer une requête par minute...mais théoriquement ton IP publique change tous les 3 jours au pire. Quelques requêtes par jour suffisent...mais si jamais tu veux éviter de te faire chier avec des adresses IP...tu peux louer un nom de domaine que tu payes ~30€ à l'année et tu installes un client DNS sur ton poste ("ddclient" pour linux ou équivalent pour windows). "ddclient" s'occupe de mettre à jour la correspondance de ton nom de domaine avec ton IP (sur les serveurs DNS). Et du coup, tu peux accéder à ton serveur en utilisant par exemple l'url : mon-nom-de-domaine.fr:1234 (1324 c'est le port utilisé).

-
Edité par CeBiM 13 août 2018 à 20:03:04

Merci pour cette réponse 

Sur Qt en C++ j avais une fonction qui me permettait d avoir mon ip, ça m étonne que Java ne gère pas ce genre de demande. La méthode de Qt passe par un site aussi ? 

De rien. Oui, pour pour obtenir l'IP publique, ça passe très probablement par un  site (Ce qui n'est pas le cas pour les IP local, dans ce cas le code natif existe).

En toute rigueur, une machine possède plusieurs adresses IP (par exemple toutes les adresses ipv4 de loopback 128.*.*.*)  dont éventuellement plusieurs adresses publiques.

Quand on sait ça, "une fonction qui retourne l'adresse IP", c'est forcément bancal comme concept.

Pas d'accord. Tu peux éventuellement "binder " plusieurs IP sur une même interface réseau, mais par défaut, il y a une adresse par interface réseau (par exemple : une adresse pour ton interface ethernet et une adresse pour ton interface wifi) . Et à ce que j'en sais, une box n'a qu'une seule interface réseau vers le monde extérieur (sauf peut-être en cas exceptionnel, par exemple en entreprise avec des modems/routeurs disposant de plusieurs IP publiques), donc qu'une seule adresse publique qui t'est réservée par ton FAI. Elle a également une interface sur le réseau local (192.168.1.1 par exemple) mais c'est une adresse privée et non publique.

Le loopback, ce sont juste des adresses de rebouclage qui permettent de faire des tests de la pile réseau de ton PC. Elles font toujours référence au PC sur lequel tu te trouves.

Mais il est vrai que dans le rare cas de plusieurs IP publiques directement relié à des serveurs/PC (pas conseillé), la fonction retournera l'IP qui a été utilisée pour envoyer la requête au site utilisé (monip.org par exemple), et ce n'est peut-être pas l'IP que l'on souhaite utiliser (Sauf avec des règles NAT/PAT, n'importe quelle IP fait l'affaire)...Mais c'est un cas complexe qu'on n'aura pas chez un particuler avec une simple Livebox ou Bbox ou autre.

EDIT : Comme le souligne michelbillau, ce que j'ai dit n'est pas valable en considérant IPv6.

-
Edité par CeBiM 14 août 2018 à 12:05:01

CeBiM a écrit:

Pas d'accord. Tu peux éventuellement "binder " plusieurs IP sur une même interface réseau, mais par défaut, tu as une adresse par interface réseau (par exemple : une adresse pour ton interface ethernet et une adresse pour ton interface wifi) . Et à ce que j'en sais, une box n'a qu'une seule interface réseau vers le monde extérieur (sauf peut-être en cas exceptionnel que je ne connais pas), donc qu'une seule adresse publique qui t'est réservée par ton FAI. Elle a également une interface sur le réseau local (192.168.1.1 par exemple) mais c'est une adresse privée et non publique.

1) On peut très bien définir plusieurs adresses IP sur la même interface physique.

2) si tu as une freebox, elle a probablement une adresse IPv4 ET une adresse IPv6 publiques Ca fait déjà deux sur la même interface publique :-)

3) si il y a un fonction qui retourne "_l_'adresse IP", elle ne fonctionne que dans le cas _particulier_ où il n'y a une adresse. Pas dans le cas général.

4) si ton PC est derriere une box, il ne "possède" pas une adresse IP publique IPV4.  C'est la box qui fait la "translation d'adresses"

5) par contre il peut avoir plusieurs adresses IPv6 "publiques" (ex : mon PC avec sa carte réseau ethernet et son wifi).

-
Edité par michelbillaud 14 août 2018 à 11:27:43

1) Entièrement d'accord, c'est ma première phrase.

2) Mouahahahaha (Piégé...) ! Tu as entièrement raison...mais qui utilise IPv6 ??? Chez les particuliers...pas grand monde...et c'est transparent avec des règles PAT/NAT...

3) Elle fonctionne dans les deux cas...mais tu recevras l'IP source contenu dans la requête faite au site web. Donc potentiellement pas la bonne.

4) C'est ce que je dis également. On est d'accord =D

5) Ah bon ? Si tu es derrière une box ? Tes adresses IPv6 sont des adresses privés non ? Est-ce différent du fonctionnement réseau avec IPv4 ?

-
Edité par CeBiM 14 août 2018 à 11:48:44

Si une fonction retourne une des adresses publiques qui permet de faire quelque chose mais pas tout, ce n'est pas fiable. On veut quelque chose de fiable ou pas ?

IPv6 _n'EST PAS_ une transposition de IPv4 avec des adresses plus longues.  Il est la en particulier pour assurer la connectivité de bout en bout, avec des adresses globales (pas de NAT) ainsi que des adresses "link-local". C'est un autre monde que ipv4. https://fr.wikipedia.org/wiki/Adresse_IPv6#Cat%C3%A9gories_d%27adresses

-
Edité par michelbillaud 14 août 2018 à 11:58:00

D'accord sur la fiabilité, d'où ma préférence d'utiliser DNS.

Exact :

• End-to-end Connectivity

  Every system now has unique IP address and can traverse through the Internet without using NAT or other translating components. After IPv6 is fully implemented, every host can directly reach other hosts on the Internet, with some limitations involved like Firewall, organization policies, etc.

C'est trop puissant ! Je vais m'y mettre ! Je me coucherai moins con ce soir... Merci !

Ça me rend curieux maintenant, y-a-t-il un système de type DHCP pour obtenir une adresse IPv6 ? DHCPv6 ? Je vais voir tout ça au plus vite

Dommage qu'on en ait pas parler dans mes cours de réseaux :/

Merci encore !

-
Edité par CeBiM 14 août 2018 à 12:14:30

CeBiM a écrit:

[IPv6]

Dommage qu'on en ait pas parler dans mes cours de réseaux :/

Faut savoir comment les profs fonctionnent :

• ils font des cours sur Ipv4 depuis des décennies, qu'ils ne retouchent pas
• ils n'ont pas de taches d'administration réseau, donc ils n'ont pas de contact avec la "réalité". Les trucs auxquels il faut s'interesser parce que sinon, ça marche pas.
• un certain nombre ont quand même réussi à intégrer le fait que les classes A,B,C n'existent plus vraiment (depuis 1993). Mais bon, dans les cours sur internet, on en parle encore.
• ils ont entendu parler de IPv6 bien sur. Il y a longtemps. Pour le vendre, on leur a dit que c'était avec des adresses plus longues que IPv4. Ils en ont conclu, comme tout le monde, que ça fonctionnait certainement pareil
• a partir de là, le prétexte pour ne pas enseigner IPv6, c'est que si on connait Ipv4, "c'est pareil", alors IPv4 c'est "la base" : pourquoi s'emmerder à regarder autre chose ? 
• surtout que tout le monde n'utilise pas encore IPv6, dont IPv4 est toujours là, et on n'a pas le temps de parler de tout.
• ah mince on n'aura plus les exercices sur les calculs de masques de sous-réseau, ça n'existe plus.

-
Edité par michelbillaud 14 août 2018 à 14:44:44

(Ça sent le prof de réseau tout ça).

Je comprends très bien, ayant moi-même été enseignant vacataire pendant quelques temps.

Je me suis aussi laissé emporter dans cette mauvaise conclusion du fonctionnement de IPv6.

Merci de la correction

-
Edité par CeBiM 14 août 2018 à 13:36:51

Je vois que c est parti en débat depuis mon dernier post

J aurai une dernière question sur le propos, étant donné que je ne comprends pas exactement les fonctions utilisées dans le code exemple, j ai fait ma propre fonction qui fait un readLine() jusqu a la ligne contenant l ip, je récupère cette ligne en me plaçant au 40e char de la chaîne (character ou commence l ip), et je récupère dans une autre chaîne chaque caractère jusqu à ce que je tombe sur du html (donc tant que le char n est pas un '<')

Mis à part si le site change de présentation, est-ce que cette façon de procéder peut poser problème ? 

C'est pour ça que l'utilisation des expressions régulières est pratique dans ce cas...peu importe où se situe l'IP dans le contenu HTML, il sera trouvé grâce à ses lignes :

public String getIp() {
        String ip = null;
        String content = getHtmlContentOf("http://www.monip.org/");
        Matcher matcher = Pattern.compile("(\\d{1,3}\\.){3}\\d{1,3}").matcher(content);
        if (matcher.find()) {
            ip = matcher.group();
        }
        if (ip != null) {
            logger.info("My IP is " + ip);
            return ip;
        } else {
            logger.info("Unknown IP :(");
        }
        return null;
    }

Le pattern " (\\d{1,3}\\.){3}\\d{1,3} " signifie : je cherche un nombre entier qui va de 1 à 3 digits suivis d'un point, et que ça se répète trois fois de suite et finalement un dernier nombre entier lui aussi entre 1 et 3 digits. C'est le format d'une adresse IP. Il trouve ce qui correspond et on récupère le premier résultat.

Tu trouveras des infos ici : https://cyberzoide.developpez.com/tutoriels/java/regex/

-
Edité par CeBiM 15 août 2018 à 15:09:50

D accord mais si je comprends bien ça ne marchera pas pour une ipv6 si ?

Nop...le format n'étant pas le même, il faut adapter l'expression régulière. Je pense qu'il y a moyen de combiner les deux versions (v4 et v6) dans une seule expression pour pouvoir trouver l'IP quelque soit son format.

-
Edité par CeBiM 16 août 2018 à 10:14:42

Une adresse pour voir

https://test-ipv6.com/

Un exemple qui fonctionne pour les deux versions d'IP (à adapter à ton besoin, pour récupérer une liste d'IP par exemple) :

	public static String getIp() {
		String ip = null;
		String content = "2001:0db8:0000:85a3:0000:0000:ac1f:8001 and 2001:0db8:0000:85a3:0000:0000:ac1f:8001 and 192.168.1.2";
		// Matcher matcher =
		// Pattern.compile("(\\d{1,3}\\.){3}\\d{1,3}").matcher(content);
		// Matcher matcher =
		// Pattern.compile("([0-9A-F]{1,4}\\.){7}[0-9A-F]").matcher(content.toUpperCase());
		Matcher matcher = Pattern.compile("([0-9A-F]{1,4}\\:){7}[0-9A-F]{1,4}|(\\d{1,3}\\.){3}\\d{1,3}").matcher(content.toUpperCase());
		while (matcher.find()) {
			ip = matcher.group();
			System.out.println("My IP is " + ip);
		}
		if (ip != null) {
			return ip;
		} else {
			System.out.println("Unknown IP :(");
		}
		return null;
	}

Ca donne ça en sortie console :

My IP is 2001:0DB8:0000:85A3:0000:0000:AC1F:8001
My IP is 2001:0DB8:0000:85A3:0000:0000:AC1F:8001
My IP is 192.168.1.2

-
Edité par CeBiM 16 août 2018 à 10:59:07

oui mais bon, pour compliquer les choses (*) il y a les adresses compressées aussi...

Topo pour ne pas mourir idiot :

1. Une adresse IPv6 est composé de 128 bits.

2. on la présente généralement comme une suite de 8 groupes de 16 bits, 4 chiffres hexa chacun, séparés par des ":"

Exemple 2001:0DB8:0000:85A3:0000:0000:AC1F:8001

3. on peut raccourcir en supprimant les 0 non significatifs en tête de chaque groupe

Exemple 2001:DB8:0:85A3:0:0:AC1F:8001

3. Il y a souvent des suites de groupes nuls qui apparaissent. Par exemple dans l'adresse de loopback "0:0:0:0:0:0:0:1"

On peut compresser l'adresse en remplaçant une des suites de zeros par "::"

- l'adresse de loopback peut donc s'écrire "::1"

- pour l'autre : 2001:DB8:0:85A3::AC1F:8001 , on a évidemment choisi la suite de zéros la plus longue.

On ne peut le faire qu'une fois au plus par adresse, sinon on ne saurait pas dans quel "trou" ajouter les groupes manquants.

Voila qui pimentera un peu les regexps.

(*) et fournir une mine d'exercices bourrins et faciles à corriger pour les profs de réseau, tout n'est pas perdu.

-
Edité par michelbillaud 16 août 2018 à 12:10:22

Ce serait trop simple...Merci pour le complément d'infos.

Bon du coup, je considère que l'IPv6 aura au moins 2 (à méditer) groupes hexadécimaux de présent, et le cas particulier du loopback :

	public static String getIp() {
		String ip = null;
		String content = "::1 and 2001:0db8:0000:85a3:0000:0000:ac1f:8001 and 2001:DB8:0:85A3:0:0:AC1F:8001 and 2001:DB8:0:85A3::AC1F:8001 and 192.168.1.2";
		// Matcher matcher =
		// Pattern.compile("(\\d{1,3}\\.){3}\\d{1,3}").matcher(content);
		// Matcher matcher =
		// Pattern.compile("([0-9A-F]{1,4}\\.){7}[0-9A-F]").matcher(content.toUpperCase());
		Matcher matcher = Pattern.compile("::1|([0-9A-F]{1,4}\\:{1,2}){2,7}[0-9A-F]{1,4}|(\\d{1,3}\\.){3}\\d{1,3}").matcher(content.toUpperCase());
		while (matcher.find()) {
			ip = matcher.group();
			System.out.println("My IP is " + ip);
		}
		if (ip != null) {
			return ip;
		} else {
			System.out.println("Unknown IP :(");
		}
		return null;
	}

Renvoie en console :

My IP is ::1
My IP is 2001:0DB8:0000:85A3:0000:0000:AC1F:8001
My IP is 2001:DB8:0:85A3:0:0:AC1F:8001
My IP is 2001:DB8:0:85A3::AC1F:8001
My IP is 192.168.1.2

-
Edité par CeBiM 16 août 2018 à 12:26:31

Merci pour vos précisions et vos compléments d information (même si j avoue que certaines notions m échappent ^^)

Pour que la fonction fonctionne pour les ipv4/6, je pourrai rajouter un else qui traiterai avec un regex correspondant à une ipv4 si jamais l ipv6 n est pas trouvée