Outils populaires

Thème

Convertisseur IP vers décimal

Convertissez une adresse IP en décimal, hexadécimal, binaire et octal, ou saisissez l'un de ces nombres pour retrouver l'IP. Chaque octet est dessiné en 8 bits avec leur poids, pour que vous puissiez suivre le calcul.

Analyse selon le standard URL du WHATWG et inet_aton · arithmétique exacte sur 128 bits pour l'IPv6 · fonctionne dans votre navigateur

Lu comme notation pointée

Les 8 bits de chaque octet, avec leur poids198.51.100.77 = 3 325 256 781
Octet1286432168421HexaSomme× poids= valeur
19811000110C6128+64+4+2 = 198× 256³16 777 2163 321 888 768
128+64+4+2 × 256³ = 3 321 888 768
51001100113332+16+2+1 = 51× 256²65 5363 342 336
32+16+2+1 × 256² = 3 342 336
100011001006464+32+4 = 100× 25625625 600
64+32+4 × 256 = 25 600
77010011014D64+8+4+1 = 77× 1177
64+8+4+1 × 1 = 77
Total3 325 256 781
= 3 325 256 781
Essayez

Une IP, ou son nombre décimal, hexa, binaire ou octal pour retrouver l'IP. Conversion dans votre navigateur ; rien n'est envoyé.

IPv4 · 32 bits

3325256781

198.51.100.77 en un seul nombre de 32 bits · Adresse de documentation (RFC 5737)

Le même nombre dans le code

SELECT INET_ATON('198.51.100.77');3325256781
SELECT '198.51.100.77'::inet - '0.0.0.0'::inet;3325256781
int(ipaddress.ip_address('198.51.100.77'))3325256781
ip2long('198.51.100.77')3325256781
Décimale pointée
Décimal
Hexa
Octets en binaire
Octal
Octets en hexa
Octets en octal
Dans un navigateur (chacune ouvre 198.51.100.77)
Nom DNS inverse
En IPv6 (mappée)
IPv4 → IPv6

Comment convertir une adresse IP en décimal ?

Multipliez les quatre nombres par 256³, 256², 256 et 1, puis additionnez : 192.168.1.1 vaut 192 × 16 777 216 + 168 × 65 536 + 1 × 256 + 1 = 3 232 235 777.

Une adresse IPv4 est un seul nombre de 32 bits écrit en quatre morceaux de 8 bits, donc la forme pointée et la forme décimale sont la même valeur. La documentation de MySQL prend 10.0.5.9 = 167773449 comme exemple.

192× 256³ 16 777 2163 221 225 472
168× 256² 65 53611 010 048
1× 256 256256
1× 1 11
=3 232 235 777
192.168.1.1 en un seul nombre : chaque partie multipliée par son poids, puis la somme.
Convertisseur IP vers décimal montrant les bits et les poids de chaque octet jusqu'au nombre finalConvertisseur IP vers décimal montrant les bits et les poids de chaque octet jusqu'au nombre finalN'importe quelle forme en entréePointée, décimale, hexa, binaire, octale ou URL : le champ les lit toutes.Bits et poidsChaque 1 ajoute son poids : 128 + 64 + 4 + 2 = 198.× 256³, 256², 256, 1Chaque octet multiplié par son poids, puis le total.Toutes les formes en sortieHexa, binaire, octal et les URL qu'acceptent les navigateurs, chacune à copier.Le nombreL'adresse entière en un seul nombre de 32 bits, prête à copier, avec le type d'adresse.
198.51.100.77 bit par bit : les poids de chaque octet, puis × 256³, 256², 256 et 1, pour un total de 3 325 256 781.

Comment convertir un nombre décimal en adresse IP ?

Divisez par 16 777 216, puis divisez le reste par 65 536, puis par 256 : les trois quotients et le dernier reste sont les quatre nombres, donc 3232235777 correspond à 192.168.1.1.

Saisissez le nombre dans le convertisseur et il fait de même, avec en plus l'hexa, le binaire, l'octal et les formes qu'acceptent les navigateurs. Les nombres au-delà de 4 294 967 295 ne sont pas des adresses IPv4 ; le convertisseur les lit comme des nombres IPv6 et le signale.

3 232 235 777÷ 16 777 216=192reste 11 010 305
11 010 305÷ 65 536=168reste 257
257÷ 256=1reste 1
1÷ 1=1reste 0

192.168.1.1

3 232 235 777 ramené à 192.168.1.1 par divisions.

Comment convertir une adresse IP en binaire ?

Écrivez chacun des quatre nombres sur 8 bits avec les poids 128, 64, 32, 16, 8, 4, 2 et 1 : 192 vaut 128 + 64, donc 11000000, et 192.168.1.1 s'écrit 11000000.10101000.00000001.00000001.

Parcourez les poids depuis la gauche : écrivez 1 et soustrayez quand le poids tient, sinon écrivez 0. Pour 168 : 128 tient (reste 40), 64 non, 32 tient (reste 8), 16 non, 8 tient, donc 10101000. Pour revenir du binaire, additionnez les poids des 1.

1286432168421
19211000000128 + 64
16810101000128 + 32 + 8
1000000011
1000000011

11000000.10101000.00000001.00000001

Chaque octet de 192.168.1.1 face aux poids de 128 à 1.

Comment convertir une adresse IP en hexadécimal ?

Coupez les 8 bits de chaque octet en deux moitiés de 4 et écrivez chaque moitié en un chiffre hexa : 192 vaut 1100 0000, soit C0, donc 192.168.1.1 s'écrit 0xC0A80101.

L'hexa est aussi la façon dont l'IPv6 écrit une adresse IPv4 intégrée : ::ffff:c0a8:101 correspond à 192.168.1.1. Les navigateurs acceptent le nombre hexa comme hôte : http://0xC0A80101/ ouvre 192.168.1.1.

19211000000C0
16810101000A8
10000000101
10000000101

0xC0A80101

4 bits = 1 chiffre hexa

Quatre bits par chiffre hexa : 192.168.1.1 s'écrit C0 A8 01 01.

Pourquoi http://3232235777 ouvre-t-il 192.168.1.1 ?

Parce que les navigateurs lisent un hôte composé uniquement de nombres comme une adresse IPv4 sous l'une des anciennes formes d'inet_aton, un seul nombre décimal compris, puis chargent l'adresse pointée.

Chaque partie peut être décimale (le standard URL), hexa avec 0x ou octale avec un 0 de tête, et avec moins de quatre parties la dernière remplit les octets restants. Ainsi http://192.168.1/ ouvre 192.168.0.1, pas 192.168.1.1. ping et curl acceptent les mêmes formes.

Les nombres au-delà de 32 bits, un 8 ou un 9 dans une partie qui commence par 0, et une cinquième partie sont refusés.

Saisi dans la barre d'adresseOuvre
http://3232235777/192.168.1.1
http://0xC0A80101/192.168.1.1
http://0300.0250.1.1/192.168.1.1
http://127.1/127.0.0.1
http://192.168.1/192.168.0.1
http://4294967296/Refusé
http://09/Refusé
http://192.0.2.1.5/Refusé
Ce que l'analyseur d'URL du WHATWG fait de chaque hôte.

Pourquoi les autres écritures d'une adresse IP comptent-elles pour la sécurité ?

Parce qu'un filtre qui compare les adresses comme du texte peut être trompé : 2130706433, 0x7f.1, 127.1 et ::ffff:127.0.0.1 valent tous 127.0.0.1, donc les filtres doivent comparer la valeur numérique, pas la chaîne.

L'OWASP cite ces encodages parmi les moyens de contourner les défenses contre le SSRF. Des bibliothèques ont eu ce bogue : les paquets npm netmask et ip, ipaddress de Python et le paquet net de Go ont tous, à un moment, mal lu des zéros de tête ou d'autres formes, et ont été corrigés depuis.

Analysez avec un lecteur strict, convertissez en nombre, puis comparez des plages. Bloquez aussi les adresses IPv4 mappées des plages bloquées.

deny 127.0.0.1

Comparé comme texte

127.0.0.1bloqué

2130706433passe

0x7f.1passe

127.1passe

::ffff:127.0.0.1passe

Comparé comme nombre

127.0.0.12130706433 · bloqué

21307064332130706433 · bloqué

0x7f.12130706433 · bloqué

127.12130706433 · bloqué

::ffff:127.0.0.12130706433 · bloqué

CVE-2021-28918netmask (npm)CVE-2021-29418netmask (npm)CVE-2021-29424Net::Netmask (Perl)CVE-2021-29921Python ipaddressCVE-2021-29923Go netCVE-2024-29415ip (npm)
Une règle, cinq écritures de l'adresse de bouclage ; puis les avis de sécurité.

Comment convertir une adresse IPv6 en décimal ?

De la même façon, avec huit groupes de 16 bits : 2001:db8::1 vaut 42540766411282592856903984951653826561, un nombre de 39 chiffres au plus qui exige BigInt en JavaScript.

Il existe 2^128 adresses IPv6. Les nombres JavaScript ne représentent exactement les entiers que jusqu'à 2^53 − 1, donc l'arithmétique ordinaire arrondit les valeurs IPv6 sans prévenir. int(ipaddress.ip_address(…)) en Python est exact.

2001:db8::1

42540766411282592856903984951653826561

exact (BigInt)

42540766411282592856903984951653826560

Number() : arrondi après 2^53

2001:db8::1 en un seul nombre, et ce qu'en fait un nombre JavaScript ordinaire.

Comment convertir des adresses IP en nombres dans le code et les bases de données ?

Utilisez les fonctions propres à la plateforme avec un type non signé : INET_ATON() de MySQL dans un INT UNSIGNED, la soustraction de inet dans PostgreSQL, int(ipaddress.ip_address(…)) en Python, et >>> 0 après les décalages en JavaScript.

Un entier signé de 32 bits ne peut pas contenir les adresses à partir de 128.0.0.0 : << en JavaScript donne -1062731519 pour 192.168.1.1, et ip2long() de PHP devient négatif sur les versions 32 bits. Pour l'IPv6, MySQL utilise INET6_ATON() et VARBINARY(16).

› SELECT INET_ATON('192.168.1.1'), INET_NTOA(3232235777);
3232235777 | 192.168.1.1

MySQL 8.4

› SELECT '192.168.1.1'::inet - '0.0.0.0'::inet,
       '0.0.0.0'::inet + 3232235777;
3232235777 | 192.168.1.1

PostgreSQL 16

› import ipaddress
int(ipaddress.ip_address('192.168.1.1')), ipaddress.IPv4Address(3232235777)
(3232235777, IPv4Address('192.168.1.1'))

Python ipaddress

› '192.168.1.1'.split('.').reduce((n, o) => (n << 8) | +o, 0) >>> 0
3232235777

JavaScript

› echo ip2long('192.168.1.1'), ' ', long2ip(3232235777);
3232235777 192.168.1.1

PHP 8

192.168.1.1 en nombre et retour, dans deux bases de données et trois langages.

Questions fréquentes

Que vaut 192.168.1.1 en décimal ?

3232235777. Multipliez chaque partie par son poids et additionnez : 192 × 16 777 216 + 168 × 65 536 + 1 × 256 + 1 = 3 232 235 777. Le même nombre s'écrit 0xC0A80101 en hexa et 11000000.10101000.00000001.00000001 en binaire. Les navigateurs l'acceptent aussi comme hôte, donc http://3232235777/ ouvre la même adresse que http://192.168.1.1/.

Quelle est la plus grande valeur décimale d'une adresse IPv4 ?

4 294 967 295, soit 255.255.255.255. Une adresse IPv4 est un nombre de 32 bits, il en existe donc 2^32 = 4 294 967 296, de 0 (0.0.0.0) à 4 294 967 295. Les nombres plus grands ne sont pas des adresses IPv4 : les navigateurs refusent http://4294967296/, et ce convertisseur lit ces nombres comme des valeurs IPv6 de 128 bits et vous le signale.

Comment reconvertir 3232235777 en adresse IP ?

Divisez par 16 777 216 pour la première partie : 192, reste 11 010 305. Divisez ce reste par 65 536 pour la deuxième partie : 168, reste 257. Divisez 257 par 256 pour la troisième partie : 1, reste 1, qui est la quatrième partie. Le résultat est 192.168.1.1. Saisissez le nombre dans le convertisseur et il montre aussi les bits de chaque octet.

Que signifie un zéro de tête comme 010 dans une adresse IP ?

Cela dépend du programme. Les navigateurs et inet_aton lisent une partie avec un zéro de tête en octal, donc 192.0.2.010 vaut 192.0.2.8, alors que les outils qui ignorent le zéro lisent 192.0.2.10. Python et Go rejettent désormais ces adresses, après des bogues où les deux lectures laissaient des requêtes passer à travers les filtres IP. N'écrivez jamais de zéros de tête dans une adresse IPv4.

Pourquoi 192.168.1 ouvre-t-il 192.168.0.1 ?

Parce qu'une adresse en trois parties remplit les 16 derniers bits avec sa dernière partie. Dans 192.168.1, le 1 final devient le nombre de 16 bits 1, soit 0.1, donc l'adresse est 192.168.0.1. C'est ainsi qu'inet_aton et les navigateurs lisent les formes courtes, et 192.168.257 donnerait 192.168.1.1. Le type cidr de PostgreSQL lit 192.168.1 autrement, comme le réseau 192.168.1.0/24.

Comment convertir une adresse IP en binaire à la main ?

Pour chacun des quatre nombres, parcourez les poids 128, 64, 32, 16, 8, 4, 2 et 1 : écrivez 1 et soustrayez quand le poids tient, sinon écrivez 0. Pour 168 : 128 tient (reste 40), 64 non, 32 tient (reste 8), 16 non, 8 tient (reste 0), donc 10101000. Reliez les quatre groupes de 8 bits par des points.

Comment stocker des adresses IP sous forme de nombres dans MySQL ?

Convertissez avec INET_ATON('10.0.5.9'), qui renvoie 167773449, et stockez le résultat dans une colonne INT UNSIGNED : un INT signé ne peut pas contenir les adresses au-delà de 127.255.255.255. INET_NTOA retransforme le nombre en texte. Pour l'IPv6, utilisez INET6_ATON et une colonne VARBINARY(16), car les valeurs de 128 bits ne tiennent dans aucun type entier. Ne comptez pas sur INET_ATON pour les formes courtes comme 127.1.

Pourquoi mon nombre IP est-il négatif en JavaScript ou en PHP ?

Parce qu'il a été traité comme un entier signé de 32 bits. L'opérateur << de JavaScript renvoie des résultats signés, donc 192.168.1.1 construit par décalages donne -1062731519 ; ajoutez >>> 0 pour obtenir 3232235777. ip2long de PHP se comporte de même sur les versions 32 bits, où sprintf('%u', …) affiche la valeur non signée. Seules les adresses à partir de 128.0.0.0 sont touchées, c'est pourquoi le bogue passe souvent inaperçu.

Un convertisseur IP peut-il convertir une adresse IPv6 en décimal ?

Oui. Une adresse IPv6 est un nombre de 128 bits, donc 2001:db8::1 vaut 42540766411282592856903984951653826561, et la plus grande valeur compte 39 chiffres. Les nombres JavaScript ordinaires perdent en précision au-delà de 2^53, donc les outils doivent utiliser BigInt, et certains convertisseurs en ligne se trompent sur les derniers chiffres. int(ipaddress.ip_address('2001:db8::1')) en Python donne la valeur exacte.

L'adresse http://0x7f000001/ équivaut-elle à 127.0.0.1 ?

Oui. Les navigateurs et de nombreux outils en ligne de commande lisent un hôte en chiffres hexa après 0x comme un seul nombre de 32 bits, donc 0x7f000001, 2130706433, 0x7f.1 et 127.1 désignent tous 127.0.0.1, l'adresse de bouclage. C'est pourquoi les filtres de sécurité doivent comparer la valeur numérique plutôt que le texte, comme le conseillent la RFC 3986 et l'aide-mémoire SSRF de l'OWASP.

Outils associés