LICENCE INFORMATIQUE  3 ANNÉE e

Programmation Réseau avec Java

Chapitre 4
Adresses Internet et DNS

Basé sur Java Network Programming, E. R. Harold  mis à jour 2025

Objectifs pédagogiques
ˆ Comprendre la structure des adresses IPv4 et IPv6
ˆ Maîtriser la classe InetAddress et ses méthodes principales
ˆ Savoir eectuer des résolutions DNS directes et inverses en Java
ˆ Identier les types spéciaux d'adresses IP (loopback, multicast, lien lo-
cal...)
ˆ Utiliser NetworkInterface pour découvrir les interfaces réseau locales
ˆ Appréhender les enjeux de sécurité liés aux requêtes DNS

Plan du chapitre : 1. Adresses IP 2. DNS 3. Classe InetAddress 4.

Types d'adresses 5. NetworkInterface 6. Applications pratiques
Programmation Réseau  Licence Informatique Chapitre 4  Adresses Internet

Contents
1 Adresses IP : rappels et structure 3
1.1 Adresses IPv4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Adresses IPv6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2 Le DNS  Système de Noms de Domaine 4
2.1 Fonctionnement hiérarchique du DNS . . . . . . . . . . . . . . . . . . . 4
2.2 Cache DNS et TTL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
3 La classe InetAddress 5
3.1 Création d'objets InetAddress . . . . . . . . . . . . . . . . . . . . . 5
3.2 Méthodes getters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3.3 Vérication d'accessibilité . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.4 Méthodes héritées d'Object . . . . . . . . . . . . . . . . . . . . . . . . 7
4 Types d'adresses IP 7
4.1 Sous-classes Inet4Address et Inet6Address . . . . . . . . . . . . 8
5 La classe NetworkInterface 9
5.1 Méthodes factory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
6 Sécurité et DNS 10
6.1 Contrôles de sécurité . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
6.2 Le DNS comme canal caché . . . . . . . . . . . . . . . . . . . . . . . . 11
7 Applications pratiques 11
7.1 Vérication anti-spam via DNS (DNS Blackhole List) . . . . . . . . . . 11
7.2 Traitement multithreade de logs web . . . . . . . . . . . . . . . . . . . 12
8 Synthèse 13

2
Programmation Réseau  Licence Informatique Chapitre 4  Adresses Internet

1. Adresses IP : rappels et structure

Tout n÷ud connecté à Internet possède au moins une adresse IP unique, qui sert
d'identiant au niveau de la couche réseau (couche 3). On distingue deux versions du
protocole.
1.1. Adresses IPv4
Dénition  Adresse IPv4
Une adresse IPv4 est un identiant de 32 bits (4 octets), noté en décimal pointé
(notation ). Chaque octet est compris entre 0 et 255.
dotted quad
Exemple : [Link]
32 bits = 4 octets
8 bits 8 bits 8 bits 8 bits
152 . 19 . 134 . 132
octet 0 octet 1 octet 2 octet 3

Plages d'adresses spéciales (RFC 1918) :

Plage Utilisation Nb d'adresses
[Link]/8 Réseau privé (entreprise) 2 ≈ 16 millions
24

[Link]/12 Réseau privé 2 ≈ 1 million

20

[Link]/16 Réseau privé (domestique) 2 = 65 536

16

[Link]/8 Loopback (localhost) 

[Link] Adresse joker (wildcard) 
[Link]/4 Multicast 2 28

1.2. Adresses IPv6

Dénition  Adresse IPv6
Une adresse IPv6 est un identiant de 128 bits (16 octets), noté en hexadécimal
avec des blocs de 4 chires séparés par des :.
Exemple complet : 2001:0db8:85a3:0000:0000:8a2e:0370:7334
Exemple contracté : 2001:db8:85a3::8a2e:370:7334
Règles d'écriture contractée :
ˆ Les zéros initiaux d'un bloc peuvent être omis (0001 devient 1)
ˆ Une suite de blocs nuls peut être remplacée par :: (une seule fois par adresse)
ˆ L'adresse de loopback est ::1 (quivalent d'[Link] en IPv4)
ˆ L'adresse joker est :: (quivalent de [Link])
3
Programmation Réseau  Licence Informatique Chapitre 4  Adresses Internet
IPv6 ore 2 ≈ 3,4 × 10 adresses  susant pour adresser chaque grain de sable
128 38

sur Terre des milliers de fois.

Mise à jour 2025
En 2025, près de 45% du trac mondial (dont Google) transite en IPv6. La
coexistence IPv4/IPv6  appelée  est aujourd'hui standard. En Java,
dual-stack
InetAddress gère les deux versions de manière transparente.

2. Le DNS  Système de Noms de Domaine

Dénition  DNS (Domain Name System)
Le DNS est un système distribué qui traduit les noms de domaine lisibles par les
humains (ex. [Link]) en adresses IP (ex. [Link]).
2.1. Fonctionnement hiérarchique du DNS
Le DNS est organisé en arbre : serveurs racine → serveurs TLD (.com, .fr...)
→ serveurs autoritaires du domaine.

requête Résolveur localadresse du TLDServeur racine

Application Java
réponse en cache (avec cache) (.)

adresse autoritaire
Serveur TLD
(.org)

IP !

Serveur autoritaire
([Link])

2.2. Cache DNS et TTL

Le résolveur local met en cache les réponses DNS pour éviter des requêtes répétées.
Chaque enregistrement DNS possède un (Time To Live) en secondes qui indique
TTL
la durée de validité du cache.
Java possède son propre cache DNS interne, contrôlable via des propriétés système :
Propriété Description
Durée (en s) du cache pour les résolu-
tions réussies. -1 = inni
[Link]

Durée (en s) du cache pour les échecs

(défaut : 10 s)
[Link]

4
Programmation Réseau  Licence Informatique Chapitre 4  Adresses Internet
Remarque
Les échecs DNS sont mis en cache pendant seulement 10 secondes par défaut,
car une première tentative peut échouer par timeout alors que la seconde réussit
immédiatement.
3. La classe InetAddress
est la représentation Java d'une adresse IP (IPv4 ou IPv6). Elle est
utilisée par presque toutes les autres classes réseau : Socket, ServerSocket, URL,
InetAddress

DatagramSocket...

3.1. Création d'objets InetAddress

Attention
n'a pas de constructeur public. On utilise des méthodes factory
statiques, qui peuvent déclencher une requête DNS réseau.
InetAddress

Méthode factory Description

Résout un nom ou une IP. Lance
UnknownHostException si in-
getByName(String host)

trouvable
Retourne toutes les adresses asso-
ciées à un nom
getAllByName(String host)

Retourne l'adresse de la machine

courante
getLocalHost()

Crée une adresse à partir d'un

tableau de bytes (sans DNS)
getByAddress(byte[] addr)

getByAddress(String host, byte[]) Idem, avec un nom en plus (pas de

vérif DNS)
Listing 1: Création d'objets InetAddress
1 import [Link].*;
2

3 public class ExemplesInetAddress {

4 public static void main(String[] args) throws
UnknownHostException {
5

6 // 1. Resolution directe : nom -> adresse IP

7 InetAddress addr = [Link]("[Link].
com");
8 [Link](addr); // [Link]
/[Link]
9

5
Programmation Réseau  Licence Informatique Chapitre 4  Adresses Internet
10 // 2. Toutes les adresses d’un hote (load balancing)
11 InetAddress[] all = [Link]("www.
[Link]");
12 for (InetAddress a : all) {
13 [Link]([Link]()); // IPv4 et
IPv6
14 }
15

16 // 3. Adresse de la machine locale

17 InetAddress me = [Link]();
18 [Link]([Link]()); // ex: [Link].
[Link]
19

20 // 4. A partir d’octets bruts (pas de DNS)

21 byte[] octets = {(byte)142, (byte)250, (byte)74, (byte)
46};
22 InetAddress fromBytes = [Link](octets
);
23 [Link]([Link]()); //
[Link]
24 }
25 }

3.2. Méthodes getters

Méthode Retour
getHostName() Nom d'hôte (utilise le cache DNS si disponible)
getCanonicalHostName() Nom d'hôte canonique (force la consultation DNS)
Adresse IP sous forme de chaîne (dotted quad ou
hex IPv6)
getHostAddress()

getAddress() Adresse IP sous forme de tableau de byte[]

Listing 2: Utilisation des getters
1 InetAddress ia = [Link]("[Link]");
2

3 // Nom canonique (resolution inverse)

4 [Link]([Link]()); // [Link]
5

6 // Adresse IP en chaine
7 [Link]([Link]()); // [Link]
8

9 // Adresse en bytes bruts

10 byte[] raw = [Link]();
11 [Link]("Version IPv" + ([Link] == 4 ? "4" : "6"
));
12

13 // Attention : les bytes Java sont signes !

14 // Pour afficher l’octet correctement :

6
Programmation Réseau  Licence Informatique Chapitre 4  Adresses Internet
15 for (byte b : raw) {
16 int unsigned = b < 0 ? b + 256 : b;
17 [Link](unsigned + " ");
18 }

Remarque
Java ne possède pas de type byte non signé. Un octet de valeur 192 sera stocké
comme -64 (= 192 - 256). Pour le convertir : int u = b < 0 ? b + 256
: b.

3.3. Vérication d'accessibilité

Listing 3: Test d'accessibilité d'un hôte
1 InetAddress host = [Link]("[Link]");
2

3 // Test simple avec timeout de 5 secondes

4 boolean reachable = [Link](5000);
5 [Link]("Accessible : " + reachable);
6

7 // Test avec interface specifique et TTL

8 NetworkInterface ni = [Link]("eth0");
9 boolean reachableViaEth = [Link](ni, 32, 3000);

Remarque
utilise en pratique des requêtes ICMP echo (ping). Sur certains
systèmes sans privilèges root, Java peut tenter une connexion TCP sur le port 7
isReachable()

(echo) à la place, ce qui peut donner des faux négatifs.

3.4. Méthodes héritées d'Object
InetAddress surcharge trois méthodes de Object :
ˆ equals(Object o) : deux adresses sont égales si elles ont la même IP (le nom
d'hôte n'est pas pris en compte)
ˆ hashCode() : calculé uniquement depuis l'adresse IP
ˆ toString() : renvoie hostname/adresse-ip
InetAddress est immuable (aucun setter public) et donc thread-safe.

4. Types d'adresses IP
Java fournit 10 méthodes booléennes pour tester la nature d'une adresse.

7
Programmation Réseau  Licence Informatique Chapitre 4  Adresses Internet

Unicast Multicast
isLoopbackAddress() isMCNodeLocal()
[Link] / ::1 FF01::/16

isLinkLocalAddress() isMCLinkLocal()
FE80::/10 FF02::/16

isSiteLocalAddress() isMCSiteLocal()
192.168.x.x, 10.x.x.x FF05::/16

Adresse globale isMCOrgLocal()

isAnyLocalAddress() FF08::/16
routeable sur Internet

[Link] / ::
isMCGlobal()
FF0E::/16

Listing 4: Test du type d'une adresse

1 InetAddress addr = [Link](args[0]);
2

3 if ([Link]()) {
4 [Link]("Adresse de loopback (localhost)");
5 } else if ([Link]()) {
6 [Link]("Adresse privee (RFC 1918)");
7 } else if ([Link]()) {
8 [Link]("Adresse lien-local (APIPA / DHCPv6)");
9 } else if ([Link]()) {
10 if ([Link]()) [Link]("
Multicast global");
11 else if ([Link]()) [Link]("
Multicast site");
12 else if ([Link]()) [Link]("
Multicast lien");
13 else if ([Link]()) [Link]("
Multicast noeud");
14 } else {
15 [Link]("Adresse globale unicast");
16 }

4.1. Sous-classes Inet4Address et Inet6Address

Java fournit deux sous-classes spécialisées :
Listing 5: Hérarchie InetAddress
1 InetAddress addr = [Link]("[Link]");
2

3 // Facon 1 : tester via instanceof (deconseille)

4 if (addr instanceof Inet6Address) { /* IPv6 */ }
5

6 // Facon 2 : tester la taille du tableau (recommande)

7 byte[] raw = [Link]();

8
Programmation Réseau  Licence Informatique Chapitre 4  Adresses Internet
8 if ([Link] == 4) [Link]("IPv4");
9 else if ([Link] == 16) [Link]("IPv6");
10

11 // Cas special : adresse IPv4 encodee en IPv6

12 if (addr instanceof Inet6Address) {
13 Inet6Address v6 = (Inet6Address) addr;
14 if (v6.isIPv4CompatibleAddress()) {
15 [Link]("IPv4 encapsule dans IPv6");
16 }
17 }

5. La classe NetworkInterface
représente une interface réseau locale (carte Ethernet, Wi-Fi,
loopback, ou interface virtuelle).
NetworkInterface

5.1. Méthodes factory

Méthode Description
Interface par nom (eth0, lo,
wlan0...)
getByName(String name)

getByInetAddress(InetAddress) Interface liée à une adresse IP donnée

Toutes les interfaces disponibles sur la
machine
getNetworkInterfaces()

Listing 6: Lister toutes les interfaces réseau

1 import [Link].*;
2 import [Link].*;
3

4 public class ListeInterfaces {

5 public static void main(String[] args) throws
SocketException {
6 Enumeration<NetworkInterface> interfaces =
7 [Link]();
8

9 while ([Link]()) {
10 NetworkInterface ni = [Link]();
11 [Link]("Interface : " + [Link]()
12 + " (" + [Link]() + ")");
13

14 // Toutes les adresses IP de cette interface

15 Enumeration<InetAddress> addrs = ni.
getInetAddresses();
16 while ([Link]()) {
17 InetAddress addr = [Link]();

9
Programmation Réseau  Licence Informatique Chapitre 4  Adresses Internet
18 [Link](" -> " + addr.
getHostAddress()
19 + (addr instanceof Inet6Address ? " [IPv6]"
: " [IPv4]"));
20 }
21 }
22 }
23 }

Exemple  Sortie typique sur un poste Linux

Interface : lo (lo)
-> [Link] [IPv4]
-> ::1 [IPv6]
Interface : eth0 (Ethernet)
-> [Link] [IPv4]
-> fe80::1a2b:3c4d:5e6f:7a8b [IPv6]
Interface : wlan0 (Wi-Fi)
-> [Link] [IPv4]

Mise à jour 2025

Depuis Java 16, expose de nouvelles méthodes
: isTunnel(), , ainsi qu'un accès aux adresses en
NetworkInterface

via au lieu de Enumeration.

isVirtual()
Stream<InetAddress> inetAddresses()

6. Sécurité et DNS
6.1. Contrôles de sécurité
La création d'un objet InetAddress à partir d'un nom d'hôte implique une requête
DNS, considérée comme une opération potentiellement dangereuse.
Attention
Le SecurityManager Java peut interdire les résolutions DNS pour
du code non de conance. getLocalHost() renvoie alors forcément
localhost/[Link].

La méthode checkConnect(String host, int port) du SecurityManager

est appelée avec port = -1 pour vérier si une résolution DNS est autorisée.

10
Programmation Réseau  Licence Informatique Chapitre 4  Adresses Internet
6.2. Le DNS comme canal caché
Exemple  Attaque par canal DNS (exltration)
Un code malveillant peut exltrer des données en eectuant des résolutions DNS :
Même sans réponse, le serveur attaquant voit la requête DNS dans ses logs. C'est
[Link]("[Link]");

pourquoi le code non de conance ne doit pas pouvoir eectuer des résolutions
DNS arbitraires.
Mise à jour 2025
DNS over HTTPS (DoH) et DNS over TLS (DoT) chirent les requêtes
DNS pour éviter l'écoute passive. Ces protocoles sont intégrés dans les systèmes
d'exploitation modernes et les navigateurs depuis 2020. Java n'a pas encore de
support natif en 2025  un proxy DNS local (ex. systemd-resolved) est la
solution courante.
7. Applications pratiques
7.1. Vérication anti-spam via DNS (DNS Blackhole List)
Les listes noires anti-spam (RBL / DNSBL) utilisent un protocole astucieux basé sur
DNS : pour vérier si [Link] est un spammeur, on inverse les octets et
on consulte [Link].[Link]. Si la réponse est [Link],
c'est un spammeur connu.
Listing 7: Vérication anti-spam via DNSBL
1 public class SpamCheck {
2 private static final String BLACKHOLE = "[Link]";
3

4 public static boolean isSpammer(String ipAddress)

5 throws UnknownHostException {
6 InetAddress address = [Link](ipAddress);
7 byte[] quad = [Link]();
8

9 // Construire la requete DNS inversee

10 StringBuilder query = new StringBuilder(BLACKHOLE);
11 for (byte octet : quad) {
12 int unsigned = octet < 0 ? octet + 256 : octet;
13 [Link](0, unsigned + ".");
14 }
15 // ex: "[Link].[Link]"
16

17 try {
18 [Link]([Link]());
19 return true; // La requete a reussi -> spammeur
connu
20 } catch (UnknownHostException e) {

11
Programmation Réseau  Licence Informatique Chapitre 4  Adresses Internet
21 return false; // Hote inconnu -> pas dans la liste
noire
22 }
23 }
24 }

7.2. Traitement multithreade de logs web

Les logs de serveurs web contiennent des adresses IP. Convertir chaque IP en nom
d'hôte nécessite des requêtes DNS  opérations lentes idéales pour la parallelisation.
Listing 8: Traitement parallèle des logs (version moderne Java 21)
1 import [Link].*;
2 import [Link].*;
3 import [Link].*;
4 import [Link].*;
5

6 public class WeblogParallel {

7 public static void main(String[] args) throws Exception {
8 // Java 21 : virtual threads via Executors.
newVirtualThreadPerTaskExecutor()
9 try (var executor = Executors.
newVirtualThreadPerTaskExecutor();
10 var reader = new BufferedReader(new FileReader(
args[0]))) {
11

12 List<Future<String>> futures = [Link]()

13 .map(line -> [Link](() -> resolveEntry
(line)))
14 .toList();
15

16 for (Future<String> f : futures) {

17 [Link]([Link]());
18 }
19 }
20 }
21

22 static String resolveEntry(String entry) {

23 int idx = [Link](’ ’);
24 String ip = [Link](0, idx);
25 try {
26 String host = [Link](ip).getHostName
();
27 return host + [Link](idx);
28 } catch (UnknownHostException e) {
29 return entry; // garder l’IP si resolution echoue
30 }
31 }
32 }

12
Programmation Réseau  Licence Informatique Chapitre 4  Adresses Internet
Mise à jour 2025
La version moderne (Java 21) utilise virtual threads via
[Link]() : les threads virtuels
sont extrêmement légers (quelques Ko chacun contre 1 Mo pour un thread clas-
sique), ce qui permet d'en créer des millions sans saturer la mémoire. C'est la
stratégie recommandée pour les applications I/O-bound comme le traitement de
logs DNS.
8. Synthèse
Application : utilise InetAddress  transparence IPv4/IPv6
Java API : InetAddress, Inet4Address, Inet6Address, NetworkInterface
DNS : résolution noms ↔ adresses (cache, TTL, sécurité)
Réseau : IPv4 (32 bits) | IPv6 (128 bits) | Adresses spéciales
À retenir
1. InetAddress représente une adresse IPv4 ou IPv6  pas de constructeur
public, utiliser les méthodes factory.
2. getByName() eectue une requête DNS réseau; elle peut lever
UnknownHostException.
3. getByAddress(byte[]) crée une adresse sans DNS  utile si le DNS est
indisponible.
4. Les réponses DNS sont mises en cache dans la JVM ; les paramètres
[Link] et .[Link] contrôlent cette durée.
5. Les bytes retournés par getAddress() sont signés en Java  conversion
nécessaire pour acher correctement.
6. InetAddress est immuable et donc thread-safe.
7. NetworkInterface permet de découvrir et manipuler les interfaces réseau
locales.
8. IPv6 est omniprésent en 2025  toujours tester son code en environnement
dual-stack.

13
Programmation Réseau  Licence Informatique Chapitre 4  Adresses Internet
Exercices de révision
1. Quelle est la diérence entre getHostName() et
getCanonicalHostName() ? Dans quel cas la distinction est-elle
importante ?
2. Pourquoi InetAddress n'a-t-il pas de constructeur public ? Quels avan-
tages ore le pattern factory dans ce contexte ?
3. Expliquez pourquoi les bytes retournés par getAddress() peuvent être
négatifs. Écrivez une méthode toUnsignedString(InetAddress) qui
ache les octets correctement.
4. Que se passe-t-il si vous appelez getByName("[Link]")
sur une adresse IPv4 privée sans connexion Internet ? Et
getByName("[Link]") ?
5. Écrivez un programme Java qui liste toutes les interfaces réseau de la machine
et ache pour chacune son nom, son type (IPv4/IPv6) et son adresse.
6. Qu'est-ce qu'un DNS Blackhole List (DNSBL) ? Expliquez le principe de
requête inversée utilisé pour vérier si une IP est liste noire.
7. Comparez les performances de résolution DNS séquentielle vs parallèle pour
1000 entrées de log. Quel gain attendez-vous ? Pourquoi les virtual threads
Java 21 sont-ils particulièrement adaptés à ce cas d'usage ?
Références : E. R. Harold, Java Network Programming, 4e éd., O'Reilly, 2014, Chapitre 4
 RFC 1918 (Adresses privées)  RFC 4291 (Architecture adressage IPv6)  Oracle, JEP
444 : Virtual Threads, Java 21, 2023  Oracle, [Link] Javadoc, Java 21.

14