Convertisseur d'adresse IP en binaire

Convertisseur d'adresse IP en binaire

Leader AI Skill PRO

Entrez le calcul

Formule

Décimal=Octet 1·224+Octet 2·216+Octet 3·28+Octet 4\text{Décimal} = \text{Octet 1} \cdot 2^{24} + \text{Octet 2} \cdot 2^{16} + \text{Octet 3} \cdot 2^{8} + \text{Octet 4}
Afficher les étapes du calcul (1)
  1. Représentation binaire

    Binaire=bin8(Octet 1).bin8(Octet 2).bin8(Octet 3).bin8(Octet 4)\text{Binaire} = \text{bin}_8\!\left(\text{Octet 1}\right).\,\text{bin}_8\!\left(\text{Octet 2}\right).\,\text{bin}_8\!\left(\text{Octet 3}\right).\,\text{bin}_8\!\left(\text{Octet 4}\right)

    Chaque octet est converti en une chaîne binaire de 8 bits, séparée par des points.

Statistiques d'utilisation

Publicité

Résultats

Binaire (pointé)
11000000.10101000.00000001.00000001
8 bits par octet
Binaire continu 11000000101010000000000100000001
Entier décimal 3 232 235 777
Hexadécimal C0.A8.01.01

Signaler une erreur sur cette page

Qu'est-ce que le convertisseur d'adresse IP en binaire ?

Une adresse IPv4 comme 192.168.1.1 n'est en réalité qu'un nombre de 32 bits, écrit sous une forme plus lisible pour l'humain : quatre nombres décimaux (les octets) séparés par des points. Ce convertisseur transforme ces quatre octets en leur représentation binaire, en un seul entier décimal sur 32 bits et en hexadécimal — les trois formes que les ingénieurs réseau, les développeurs et les étudiants manipulent le plus souvent.

Comment l'utiliser

Saisissez chacun des quatre octets, chacun étant un nombre entier compris entre 0 et 255. Cliquez sur calculer et vous obtenez aussitôt la forme binaire pointée (huit bits par octet), la chaîne binaire continue de 32 bits, l'entier décimal équivalent ainsi que la forme hexadécimale pointée.

La formule expliquée

Chaque octet est converti en binaire puis complété à gauche par des zéros pour obtenir exactement 8 bits : ainsi 1 devient 00000001 et 255 devient 11111111. En réunissant les quatre octets, on obtient une valeur de 32 bits. L'entier décimal s'obtient en pondérant chaque octet selon sa position :

$$\text{Decimal} = \text{Octet 1} \cdot 2^{24} + \text{Octet 2} \cdot 2^{16} + \text{Octet 3} \cdot 2^{8} + \text{Octet 4}$$

Comme chaque octet occupe 8 bits, le décalage vers la gauche de 24, 16 et 8 bits permet de les placer à la bonne position dans le mot de 32 bits.

Publicité
Adresse IPv4 divisée en quatre octets de 8 bits formant une valeur binaire de 32 bits
Chacun des quatre octets devient 8 bits binaires, formant ensemble une adresse de 32 bits.

Exemple concret

Prenons 192.168.1.1. En binaire : 192 = 11000000, 168 = 10101000, 1 = 00000001, 1 = 00000001, ce qui donne 11000000.10101000.00000001.00000001. L'entier décimal vaut

$$192 \times 16\,777\,216 + 168 \times 65\,536 + 1 \times 256 + 1 = 3\,221\,225\,472 + 11\,010\,048 + 256 + 1 = \mathbf{3\,232\,235\,777}$$

En hexadécimal : C0.A8.01.01.

Tableau des valeurs de position sur 8 bits convertissant le binaire en octet décimal
Les valeurs de position de 128 à 1 montrent comment 8 bits correspondent à un octet décimal.

Plages d'adresses IPv4 courantes en binaire

Ces blocs IPv4 à usage spécial sont définis par les normes IETF et s'appliquent aux réseaux IPv4 du monde entier. La colonne « bits fixes » indique les bits de préfixe que partagent toutes les adresses du bloc.

Plage Étendue des adresses Premier octet (décimal / binaire) Bits initiaux fixes Usage
10.0.0.0/8 10.0.0.0 – 10.255.255.255 10 / 00001010 00001010 (8 bits) Usage privé (RFC 1918)
172.16.0.0/12 172.16.0.0 – 172.31.255.255 172 / 10101100 10101100.0001 (12 bits) Usage privé (RFC 1918)
192.168.0.0/16 192.168.0.0 – 192.168.255.255 192 / 11000000 11000000.10101000 (16 bits) Usage privé (RFC 1918), réseaux locaux domestiques et de bureau typiques
127.0.0.0/8 127.0.0.0 – 127.255.255.255 127 / 01111111 01111111 (8 bits) Bouclage (l'hôte local, par ex. 127.0.0.1)
169.254.0.0/16 169.254.0.0 – 169.254.255.255 169 / 10101001 10101001.11111110 (16 bits) Lien local, adresses auto-attribuées (RFC 3927)
224.0.0.0/4 224.0.0.0 – 239.255.255.255 224 / 11100000 1110 (4 bits) Multidiffusion
0.0.0.0 adresse unique 0 / 00000000 les 32 bits valent 0 « Cet hôte » / adresse non spécifiée ; utilisée aussi comme route par défaut 0.0.0.0/0
255.255.255.255 adresse unique 255 / 11111111 les 32 bits valent 1 Diffusion limitée sur le réseau local

Formes binaires pointées complètes : 10.0.0.0 = 00001010.00000000.00000000.00000000, et 192.168.0.0 = 11000000.10101000.00000000.00000000.

Valeurs de position binaires et puissances de deux des octets

Chaque octet IPv4 compte 8 bits. Le bit 7 (le plus à gauche) vaut 128 et le bit 0 (le plus à droite) vaut 1.

Position du bit 7 6 5 4 3 2 1 0
Puissance de deux 27 26 25 24 23 22 21 20
Valeur de position 128 64 32 16 8 4 2 1

Pour obtenir l'entier de 32 bits, chaque octet est multiplié par un poids de position :

Octet Multiplicateur Valeur
Octet 1 224 16 777 216
Octet 2 216 65 536
Octet 3 28 256
Octet 4 20 1

Valeurs d'octets fréquentes dans les masques de sous-réseau et les adresses :

Décimal Binaire Hexadécimal
128 10000000 80
192 11000000 C0
224 11100000 E0
240 11110000 F0
248 11111000 F8
252 11111100 FC
254 11111110 FE
255 11111111 FF
Publicité

Comment convertir une adresse IP en binaire à la main

Exemple d'adresse : 10.0.0.5.

  1. Découper en quatre octets. 10.0.0.5 donne 10, 0, 0 et 5. Chacun doit être compris entre 0 et 255.
  2. Trouver les bits de chaque octet. Parcourez les valeurs de position 128, 64, 32, 16, 8, 4, 2, 1. Écrivez 1 si la valeur tient dans le reste (et soustrayez-la), sinon écrivez 0. Pour 10 : 128 non, 64 non, 32 non, 16 non, 8 oui (reste 2), 4 non, 2 oui (reste 0), 1 non, donc 00001010. Pour 5 : 4 + 1 donne 00000101. (Autrement, divisez successivement par 2 et lisez les restes de bas en haut.)
  3. Compléter chaque octet à 8 bits. Ajoutez des zéros à gauche pour que chaque octet ait exactement 8 chiffres : 0 devient 00000000.
  4. Joindre avec des points. 10.0.0.5 = 00001010.00000000.00000000.00000101.
  5. Convertir en hexadécimal. Découpez chaque octet en deux quartets de 4 bits et convertissez chacun en chiffre hexadécimal. 00001010 = 0000 1010 = 0A, et 00000101 = 0101 = 05, donc 10.0.0.5 = 0A.00.00.05, soit 0x0A000005. Pour un autre octet : 168 = 128 + 32 + 8 = 10101000 = 1010 1000 = A8.
  6. Calculer l'entier de 32 bits. Multipliez chaque octet par son poids de position et additionnez :

$$\text{Décimal} = o_1 \cdot 2^{24} + o_2 \cdot 2^{16} + o_3 \cdot 2^{8} + o_4$$

$$10 \cdot 16777216 + 0 \cdot 65536 + 0 \cdot 256 + 5 = 167772160 + 5$$

L'entier de 32 bits pour 10.0.0.5 est 167772165, ce qui correspond à 0x0A000005 en hexadécimal.

FAQ

Pourquoi chaque octet doit-il être compris entre 0 et 255 ? Chaque octet compte 8 bits, et 8 bits permettent de représenter des valeurs allant de 0 à 255 (\(2^{8} = 256\) valeurs possibles).

À quoi sert l'entier décimal ? Les bases de données, les tables de géolocalisation et le code de routage stockent souvent les adresses IP sous forme d'un seul entier, car les comparaisons et les vérifications de plages sont plus rapides que l'analyse de chaînes pointées.

Cela fonctionne-t-il pour l'IPv6 ? Non — les adresses IPv6 font 128 bits et s'écrivent sous forme de groupes hexadécimaux. Cet outil ne traite que les adresses IPv4 (32 bits).

Dernière mise à jour:

Les plus populaires dans Vie numérique

Voir toutes les calculatrices de Vie numérique