Validation des adresses IPv4 avec regexp

90

J'ai essayé d'obtenir une regex efficace pour la validation IPv4, mais sans beaucoup de chance. Il semblait à un moment donné que je l'avais eu avec (25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?(\.|$)){4}, mais cela produit des résultats étranges:

$ grep --version
grep (GNU grep) 2.7
$ grep -E '\b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?(\.|$)){4}\b' <<< 192.168.1.1
192.168.1.1
$ grep -E '\b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?(\.|$)){4}\b' <<< 192.168.1.255
192.168.1.255
$ grep -E '\b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?(\.|$)){4}\b' <<< 192.168.255.255
$ grep -E '\b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?(\.|$)){4}\b' <<< 192.168.1.2555
192.168.1.2555

J'ai fait une recherche pour voir si cela avait déjà été demandé et répondu, mais d'autres réponses semblent simplement montrer comment déterminer 4 groupes de 1 à 3 numéros, ou ne fonctionnent pas pour moi.

Matthieu Cartier
la source
12
N'oubliez pas que A, AB et ABC sont des formes valides d'adresse IP ainsi que ABCD Serously. Essayez ping 2130706433et ping 127.1pour un rire.
dty
1
Ma variante en ligne regexr.com/39hqf
Sllouyssgort

Réponses:

97

Vous avez déjà une réponse de travail, mais juste au cas où vous seriez curieux de savoir ce qui n'allait pas avec votre approche d'origine, la réponse est que vous avez besoin de parenthèses autour de votre alternance, sinon cela (\.|$)n'est nécessaire que si le nombre est inférieur à 200.

'\b((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\.|$)){4}\b'
    ^                                    ^
Mark Byers
la source
25
cela semble également valider des choses comme192.168.1.1.1
cwd
2
Devrait-il être \b((?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(?:(?<!\.)\b|\.)){4}:; c'est-à-dire qu'il se termine par une limite de mot plutôt que par la fin de la ligne? De plus, ici, j'ai marqué les groupes non capturants pour éviter les sous-correspondances indésirables. NB: Cela ne prend toujours pas en compte le commentaire de @ dty car je ne suis pas familier avec cette forme d'IP; bien qu'il ait raison de dire que cela semble valable.
JohnLBevan
Essayez plutôt ceci: ((1? \ D \ d? | 2 [0-4] \ d | 25 [0-5]) \.) {3} (1? \ D \ d? | 2 [0-4] \ d | 25 [0-5])
Morg.
Cela fonctionne bien pour la non-capture -\b(?:(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.){3}(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\b
Appy
3
Est-ce 09.09.09.09considéré comme une adresse IP valide? Il est également associé à cette expression régulière. Mais ping jette un message d'erreur comme ping: cannot resolve 09.09.09.09: Unknown host. Je pense qu'il pourrait être judicieux de réduire la correspondance à la correspondance en notation décimale à point uniquement. Cette entrée traite des principales erreurs dans les adresses IP.
Ruifeng Ma
79
^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$

Accepter :

127.0.0.1
192.168.1.1
192.168.1.255
255.255.255.255
0.0.0.0
1.1.1.01

Rejeter :

30.168.1.255.1
127.1
192.168.1.256
-1.2.3.4
1.1.1.1.
3...3

Essayez en ligne avec des tests unitaires: https://www.debuggex.com/r/-EDZOqxTxhiTncN6/1

Sllouyssgort
la source
qu'en est-il de l'adresse IP "3 ... 3"? 3 ... 3 est accepté en utilisant cette expression
régulière
7
Qu'en est-il du 1.1.1.01? Est-ce considéré comme une adresse IPv4 valide? Merci.
odieatla
cette expression rationnelle 1.1.1.01 est considérée comme une adresse IPv4 VALIDE. Tests unitaires en ligne debuggex.com/r/-EDZOqxTxhiTncN6/1
Sllouyssgort
en passant, ^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\.|$)){4}$obtenez le même résultat debuggex.com/r/mz_-0dEm3wseIKqK , assez similaire avec la réponse @Mark Byers
Sllouyssgort
@PriteshAcharya fonctionne bien ici.
Kid Diamond
34

Version la plus récente, la plus courte et la moins lisible ( 55 caractères )

^((25[0-5]|(2[0-4]|1[0-9]|[1-9]|)[0-9])(\.(?!$)|$)){4}$

Cette version recherche le boîtier 250-5, après quoi il OUs intelligemment tous les cas possibles pour les 200-249 100-199 10-99cas. Notez que la |)pièce n'est pas une erreur, mais en fait le dernier cas pour la plage 0-9. J'ai également omis la ?:partie du groupe non capturant car nous ne nous soucions pas vraiment des éléments capturés, ils ne seraient pas capturés de toute façon si nous n'avions pas de correspondance complète en premier lieu.

Ancienne version plus courte (moins lisible) ( 63 caractères )

^(?:(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(?!$)|$)){4}$

Ancienne version (lisible) ( 70 caractères )

^(?:(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])(\.(?!$)|$)){4}$

Il utilise la recherche négative (?!)pour supprimer le cas où l'IP pourrait se terminer par un.

Réponse la plus ancienne ( 115 caractères )

^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}
    (?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$

Je pense que c'est l'expression régulière la plus précise et la plus stricte, elle n'accepte pas les choses comme 000.021.01.0.il semble que la plupart des autres réponses ici le font et nécessitent une expression régulière supplémentaire pour rejeter les cas similaires à celui-ci - c'est- 0à- dire les numéros de départ et une adresse IP qui se termine par un.

Danail Gabenski
la source
C'est la seule réponse correcte dans ce fil à ce jour. Les autres manquent des adresses telles que 0.0.0.0ou acceptent la notation mixte octale / décimale comme 033.033.33.033ou même autorisent 999.999.999.999. Que diriez-vous de cette expression régulière qui est 10 caractères plus courte que cette réponse:(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])
anneb
1
@tinmarino J'ai annulé votre modification car elle autorisait des choses comme 192.168.000.1 qui n'est pas une adresse valide. Quiconque souhaite modifier cette réponse, veuillez d'abord commenter ici afin d'éviter de tels problèmes - je réponds généralement assez rapidement. Toujours à la recherche d'une solution plus courte / meilleure bien sûr.
Danail Gabenski
1
@DanailGabenski (et autres) pour la mémoire, vous l'avez résolu en remplaçant le dernier [01]?[0-9][0-9]?par 1[0-9]{2}|[1-9]?[0-9]parce que vous n'aimez pas diriger 0 . Merci encore ! Je garderai votre solution dans mon bagage maître regex.
Tinmarino
1
@tinmarino oui, le format point-décimal qui est devenu la norme pour ipv4, bien qu'il ne soit pas officiellement accepté, veuillez regarder ce qui suit . Plus précisément au point 3, où un projet a été suggéré mais a expiré. Une raison secondaire pour être si stricte avec la validation est que lorsqu'ils sont présentés dans l'interface utilisateur, les ip avec des nombres non décimaux comme 023 au lieu de 23 font que les utilisateurs pensent que c'est une erreur / un bogue. Cela entraîne également des difficultés de vérification / sécurité car 023 doit être converti en 23 pour éviter les doublons, etc. Merci d'essayer d'améliorer les choses!
Danail Gabenski
1
Vous pouvez le faire plus court par l' affacturage la [0-9]pour les 2[0-4], 1et les cas plus courts. ^(?:(25[0-5]|(?:2[0-4]|1[0-9]|[1-9]|)[0-9])(\.(?!$)|$)){4}$
Clayton Singh le
12

Adresse IPv4 (capture précise) Correspond à 0.0.0.0 à 255.255.255.255 Utilisez cette expression régulière pour faire correspondre les numéros IP avec précision. Chacun des 4 numéros est stocké dans un groupe de capture, vous pouvez donc y accéder pour un traitement ultérieur.

\b
(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.
(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.
(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.
(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)
\b

extrait de la bibliothèque JGsoft RegexBuddy

Edit: cette (\.|$)partie semble bizarre

Valerij
la source
2
Agréable! J'ai fait une modification plus efficace de ce qui semble fonctionner: "\b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\.|$){4}\b- merci!
Matthieu Cartier
2
@MatthieuCartier Votre modèle regex efficace n'a pas fonctionné pour moi,
R__raki__
255.255.255.000 n'est pas une IP valide
Stéphane GRILLON
6

J'étais à la recherche de quelque chose de similaire pour les adresses IPv4 - une expression régulière qui empêchait également la validation des adresses IP privées couramment utilisées (192.168.xy, 10.xyz, 172.16.xy), donc utilisé des perspectives négatives pour accomplir cela:

(?!(10\.|172\.(1[6-9]|2\d|3[01])\.|192\.168\.).*)
(?!255\.255\.255\.255)(25[0-5]|2[0-4]\d|[1]\d\d|[1-9]\d|[1-9])
(\.(25[0-5]|2[0-4]\d|[1]\d\d|[1-9]\d|\d)){3}

(Ceux-ci doivent être sur une seule ligne bien sûr, formatés à des fins de lisibilité sur 3 lignes distinctes) Visualisation des expressions régulières

Démo Debuggex

Il n'est peut-être pas optimisé pour la vitesse, mais fonctionne bien lorsque vous recherchez uniquement de «vraies» adresses Internet.

Les choses qui vont (et devraient) échouer:

0.1.2.3         (0.0.0.0/8 is reserved for some broadcasts)
10.1.2.3        (10.0.0.0/8 is considered private)
172.16.1.2      (172.16.0.0/12 is considered private)
172.31.1.2      (same as previous, but near the end of that range)
192.168.1.2     (192.168.0.0/16 is considered private)
255.255.255.255 (reserved broadcast is not an IP)
.2.3.4
1.2.3.
1.2.3.256
1.2.256.4
1.256.3.4
256.2.3.4
1.2.3.4.5
1..3.4

IP qui fonctionneront (et devraient):

1.0.1.0         (China)
8.8.8.8         (Google DNS in USA)
100.1.2.3       (USA)
172.15.1.2      (USA)
172.32.1.2      (USA)
192.167.1.2     (Italy)

Fourni au cas où quelqu'un d'autre chercherait à valider les `` adresses IP Internet sans les adresses privées communes ''

PhillipHolmes
la source
5

Je pense que de nombreuses personnes qui liront cet article rechercheront des expressions régulières plus simples, même si elles correspondent à des adresses IP techniquement invalides. (Et, comme indiqué ailleurs, regex n'est probablement pas le bon outil pour valider correctement une adresse IP de toute façon.)

Supprimez ^et, le cas échéant, remplacez $par \b, si vous ne souhaitez pas faire correspondre le début / la fin de la ligne.

Expression régulière de base (BRE) (testée sur GNU grep, GNU sed et vim):

/^[0-9]\+\.[0-9]\+\.[0-9]\+\.[0-9]\+$/

Expression régulière étendue (ERE):

/^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$/

ou:

/^([0-9]+(\.|$)){4}/

Expression régulière compatible Perl (PCRE) (testé sur Perl 5.18):

/^\d+\.\d+\.\d+\.\d+$/

ou:

/^(\d+(\.|$)){4}/

Ruby (testé sur Ruby 2.1):

Bien que censé être PCRE, Ruby pour quelque raison que ce soit a autorisé cette expression régulière non autorisée par Perl 5.18:

/^(\d+[\.$]){4}/

Mes tests pour tous ceux-ci sont en ligne ici .

Alex Harvey
la source
3

C'est un peu plus long que certains mais c'est ce que j'utilise pour faire correspondre les adresses IPv4. Simple sans compromis.

^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])$
Mickstar
la source
3

Les réponses ci-dessus sont valides mais que se passe-t-il si l'adresse IP n'est pas à la fin de la ligne et se trouve entre le texte ... Cette expression régulière fonctionnera même là-dessus.

code: '\b((([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])(\.)){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5]))\b'

fichier texte d'entrée:

ip address 0.0.0.0 asfasf
 sad sa 255.255.255.255 cvjnzx
zxckjzbxk  999.999.999.999 jshbczxcbx
sjaasbfj 192.168.0.1 asdkjaksb
oyo 123241.24121.1234.3423 yo
yo 0000.0000.0000.0000 y
aw1a.21asd2.21ad.21d2
yo 254.254.254.254 y0
172.24.1.210 asfjas
200.200.200.200
000.000.000.000
007.08.09.210
010.10.30.110

texte de sortie:

0.0.0.0
255.255.255.255
192.168.0.1
254.254.254.254
172.24.1.210
200.200.200.200
Kushagra Gupta
la source
1
Cela a été marqué négativement, jusqu'à ce que je lui donne un vote. J'essaie de faire exactement cela depuis (plus d'heures que je ne veux l'admettre). Il ne capturera pas une ligne qui a plus d'un quadruple point sur une ligne, mais pour mon cas d'utilisation, je peux vivre avec cela. C'est une excellente réponse, il faut plus de votes!
anastrophe
3

'' 'Ce code fonctionne pour moi, et est aussi simple que cela.

Ici, j'ai pris la valeur de ip et j'essaye de la faire correspondre avec regex.

ip="25.255.45.67"    

op=re.match('(\d+).(\d+).(\d+).(\d+)',ip)

if ((int(op.group(1))<=255) and (int(op.group(2))<=255) and int(op.group(3))<=255) and (int(op.group(4))<=255)):

print("valid ip")

else:

print("Not valid")

La condition ci-dessus vérifie si la valeur dépasse 255 pour les 4 octets, alors ce n'est pas valide. Mais avant d'appliquer la condition, nous devons les convertir en entier puisque la valeur est dans une chaîne.

group (0) imprime la sortie correspondante, tandis que group (1) imprime la première valeur correspondante et ici c'est "25" et ainsi de suite. '' '

Shruti Lakkihal
la source
Bienvenue dans StackOverflow. Si vous pouviez expliquer pourquoi votre réponse devrait résoudre le problème du PO, ce serait formidable. Les réponses à code unique sont généralement de mauvaises réponses car elles n'aident pas les codeurs à comprendre ce qu'ils ont mal fait.
Davide Vitali
Utilisez une indentation appropriée dans votre code pour le rendre lisible pour les utilisateurs
Syed Mehtab Hassan
2

J'ai réussi à construire une regex à partir de toutes les autres réponses.

(25[0-5]|2[0-4][0-9]|[1][0-9][0-9]|[1-9][0-9]|[0-9]?)(\.(25[0-5]|2[0-4][0-9]|[1][0-9][0-9]|[1-9][0-9]|[0-9]?)){3}
Vicky
la source
Conformément à la norme Ethernet IEEE 802.x, la validation IP est la plage IP 0.xxx >>> ne doit pas être autorisée - IP invalide. # 1.La plage IP commence de 1.xxx à 126.xxx >>>> peut être autorisée à configurer. # 2.IP range 127.xxx >>>> ne doit pas être autorisé - IP invalide. La plage IP de 128.xxx à 223.xxx >> peut être autorisée à être configurée. la meilleure façon de gérer est suggérée comme suit: ^ (22 [0-3] | 2 [0-1] [0-9] | [1] [0-9] [0-9]? | [1-9 ] [0-9] | [1-9]) \. (25 [0-5] | 2 [0-4] [0-9] | [01]? [0-9] [0-9]? ) \. (25 [0-5] | 2 [0-4] [0-9] | [01]? [0-9] [0-9]?) \. (25 [0-4] | 2 [0-4] [0-9] | [01]? [0-9] [0-9]?) $
Yogesh Aggarwal
2
/^(?:(25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)\.){3}(?1)$/m
Etienne Gautier
la source
2

Pour le nombre de 0 à 255, j'utilise cette regex:

(([0-9])|([1-9][0-9])|(1([0-9]{2}))|(2[0-4][0-9])|(25[0-5]))

Au-dessus de regex correspondra un nombre entier de 0 à 255, mais pas 256.

Donc, pour IPv4, j'utilise cette regex:

^(([0-9])|([1-9][0-9])|(1([0-9]{2}))|(2[0-4][0-9])|(25[0-5]))((\.(([0-9])|([1-9][0-9])|(1([0-9]{2}))|(2[0-4][0-9])|(25[0-5]))){3})$

C'est dans cette structure: ^(N)((\.(N)){3})$où N est l'expression régulière utilisée pour faire correspondre le nombre de 0 à 255.
Cette expression régulière correspondra à IP comme ci-dessous:

0.0.0.0
192.168.1.2

mais pas ceux ci-dessous:

10.1.0.256
1.2.3.
127.0.1-2.3

Pour IPv4 CIDR (Classless Inter-Domain Routing), j'utilise cette expression régulière:

^(([0-9])|([1-9][0-9])|(1([0-9]{2}))|(2[0-4][0-9])|(25[0-5]))((\.(([0-9])|([1-9][0-9])|(1([0-9]{2}))|(2[0-4][0-9])|(25[0-5]))){3})\/(([0-9])|([12][0-9])|(3[0-2]))$

C'est dans cette structure: ^(N)((\.(N)){3})\/M$où N est l'expression régulière utilisée pour faire correspondre le nombre de 0 à 255, et M est l'expression régulière utilisée pour faire correspondre le nombre de 0 à 32.
Cette expression régulière correspondra au CIDR comme ci-dessous:

0.0.0.0/0
192.168.1.2/32

mais pas ceux ci-dessous:

10.1.0.256/16
1.2.3./24
127.0.0.1/33

Et pour la liste des adresses IPv4 CIDR comme "10.0.0.0/16", "192.168.1.1/32"j'utilise ce regex:

^("(([0-9])|([1-9][0-9])|(1([0-9]{2}))|(2[0-4][0-9])|(25[0-5]))((\.(([0-9])|([1-9][0-9])|(1([0-9]{2}))|(2[0-4][0-9])|(25[0-5]))){3})\/(([0-9])|([12][0-9])|(3[0-2]))")((,([ ]*)("(([0-9])|([1-9][0-9])|(1([0-9]{2}))|(2[0-4][0-9])|(25[0-5]))((\.(([0-9])|([1-9][0-9])|(1([0-9]{2}))|(2[0-4][0-9])|(25[0-5]))){3})\/(([0-9])|([12][0-9])|(3[0-2]))"))*)$

C'est dans cette structure: ^(“C”)((,([ ]*)(“C”))*)$où C est l'expression régulière utilisée pour correspondre au CIDR (comme 0.0.0.0/0).
Cette regex correspondra à la liste des CIDR comme ci-dessous:

“10.0.0.0/16”,”192.168.1.2/32”, “1.2.3.4/32”

mais pas ceux ci-dessous:

“10.0.0.0/16” 192.168.1.2/32 “1.2.3.4/32”

Peut-être que cela pourrait devenir plus court mais pour moi, c'est facile à comprendre si bien pour moi.

J'espère que cela aide!

congacon
la source
Bienvenue à SO, nous apprécions votre contribution! Pourriez-vous s'il vous plaît élaborer un peu sur ce que font les différentes expressions régulières (en particulier la dernière)?
B - rian
1

Avec masque de sous-réseau:

^$|([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\
.([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\
.([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\
.([01]?\\d\\d?|2[0-4]\\d|25[0-5])
((/([01]?\\d\\d?|2[0-4]\\d|25[0-5]))?)$
hsuk
la source
1
(((25[0-5])|(2[0-4]\d)|(1\d{2})|(\d{1,2}))\.){3}(((25[0-5])|(2[0-4]\d)|(1\d{2})|(\d{1,2})))

Test pour trouver des correspondances dans le texte, https://regex101.com/r/9CcMEN/2

Voici les règles définissant les combinaisons valides dans chaque numéro d'une adresse IP:

  • Tout numéro à un ou deux chiffres.
  • Tout numéro à trois chiffres commençant par 1.

  • Tout début de numéro à trois chiffres avec 2si le deuxième chiffre est 0 par 4.

  • Tout début de numéro à trois chiffres avec 25si le troisième chiffre est 0 par 5.

Commençons par (((25[0-5])|(2[0-4]\d)|(1\d{2})|(\d{1,2}))\.), un ensemble de quatre sous-expressions imbriquées, et nous les examinerons dans l'ordre inverse. (\d{1,2})correspond à tout nombre à un ou deux chiffres ou à des nombres à 0travers 99. (1\d{2})correspond à tout nombre à trois chiffres commençant par 1( 1suivi de deux chiffres quelconques), ou à des nombres allant 100jusqu'à 199. (2[0-4]\d)fait correspondre les nombres à 200travers 249. (25[0-5])fait correspondre les nombres à 250travers 255. Chacune de ces sous-expressions est enfermée dans une autre sous-expression avec un |entre chacune (de sorte que l'une des quatre sous-expressions doit correspondre, pas toutes). Une fois que la plage de nombres \.correspond ., puis la série entière (toutes les options numériques plus\.) est inclus dans une autre sous-expression et répété trois fois en utilisant {3}. Enfin, la plage de nombres est répétée (cette fois sans la fin \.) pour correspondre au numéro d'adresse IP final. En limitant chacun des quatre nombres à des valeurs comprises entre 0et 255, ce modèle peut en effet correspondre à des adresses IP valides et rejeter des adresses invalides.

Extrait de: Ben Forta. "Apprendre les expressions régulières."


Si ni un caractère voulu au début de l' adresse IP , ni à la fin, ^et $métacaractères doit être utilisé, respectivement.

^(((25[0-5])|(2[0-4]\d)|(1\d{2})|(\d{1,2}))\.){3}(((25[0-5])|(2[0-4]\d)|(1\d{2})|(\d{1,2})))$

Test pour trouver des correspondances dans le texte, https://regex101.com/r/uAP31A/1

snr
la source
1

J'ai essayé de le rendre un peu plus simple et plus court.

^(([01]?\d{1,2}|2[0-4]\d|25[0-5])\.){3}([01]?\d{1,2}|2[0-4]\d|25[0-5])$

Si vous recherchez java / kotlin:

^(([01]?\\d{1,2}|2[0-4]\\d|25[0-5])\\.){3}([01]?\\d{1,2}|2[0-4]\\d|25[0-5])$

Si quelqu'un veut savoir comment cela fonctionne, voici l'explication. C'est vraiment si simple. Essayez-le simplement: p:

 1. ^.....$: '^' is the starting and '$' is the ending.

 2. (): These are called a group. You can think of like "if" condition groups.

 3. |: 'Or' condition - as same as most of the programming languages.

 4. [01]?\d{1,2}: '[01]' indicates one of the number between 0 and 1. '?' means '[01]' is optional. '\d' is for any digit between 0-9 and '{1,2}' indicates the length can be between 1 and 2. So here the number can be 0-199.

 5. 2[0-4]\d: '2' is just plain 2. '[0-4]' means a number between 0 to 4. '\d' is for any digit between 0-9. So here the number can be 200-249.

 6. 25[0-5]: '25' is just plain 25. '[0-5]' means a number between 0 to 5. So here the number can be 250-255.

 7. \.: It's just plan '.'(dot) for separating the numbers.

 8. {3}: It means the exact 3 repetition of the previous group inside '()'.

 9. ([01]?\d{1,2}|2[0-4]\d|25[0-5]): Totally same as point 2-6

Mathématiquement, c'est comme:

(0-199 OR 200-249 OR 250-255).{Repeat exactly 3 times}(0-199 OR 200-249 OR 250-255)

Donc, comme vous pouvez le voir normalement, c'est le modèle pour les adresses IP. J'espère que cela aide à comprendre un peu l'expression régulière. : p

Arhan Ashik
la source
1

J'ai essayé de le rendre un peu plus simple et plus court.

^ (([01]? \ D {1,2} | 2 [0-4] \ d | 25 [0-5]).) {3} ([01]? \ D {1,2} | 2 [0-4] \ d | 25 [0-5]) $

Si vous recherchez java / kotlin:

^ (([01]? \ D {1,2} | 2 [0-4] \ d | 25 [0-5]) \.) {3} ([01]? \ D {1,2} | 2 [0-4] \ d | 25 [0-5]) $

Si quelqu'un veut savoir comment cela fonctionne, voici l'explication. C'est vraiment si simple. Essayez-le simplement: p:

 1. ^.....$: '^' is the starting and '$' is the ending.

 2. (): These are called a group. You can think of like "if" condition groups.

 3. |: 'Or' condition - as same as most of the programming languages.

 4. [01]?\d{1,2}: '[01]' indicates one of the number between 0 and 1. '?' means '[01]' is optional. '\d' is for any digit between 0-9 and '{1,2}' indicates the length can be between 1 and 2. So here the number can be 0-199.

 5. 2[0-4]\d: '2' is just plain 2. '[0-4]' means a number between 0 to 4. '\d' is for any digit between 0-9. So here the number can be 200-249.

 6. 25[0-5]: '25' is just plain 25. '[0-5]' means a number between 0 to 5. So here the number can be 250-255.

 7. \.: It's just plan '.'(dot) for separating the numbers.

 8. {3}: It means the exact 3 repetition of the previous group inside '()'.

 9. ([01]?\d{1,2}|2[0-4]\d|25[0-5]): Totally same as point 2-6

Mathématiquement, c'est comme:

(0-199 OR 200-249 OR 250-255).{Repeat exactly 3 times}(0-199 OR 200-249 OR 250-255)

Donc, comme vous pouvez le voir normalement, c'est le modèle pour les adresses IP. J'espère que cela aide à comprendre un peu l'expression régulière. : p

Arhan Ashik
la source
0
    const char*ipv4_regexp = "\\b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\."
    "(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\."
    "(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\."
    "(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\b";

J'ai adapté l'expression régulière tirée de la bibliothèque JGsoft RegexBuddy au langage C (regcomp / regexec) et j'ai découvert que cela fonctionne mais il y a un petit problème dans certains systèmes d'exploitation comme Linux. Cette expression régulière accepte une adresse ipv4 comme 192.168.100.009 où 009 sous Linux est considéré comme une valeur octale, donc l'adresse n'est pas celle que vous pensiez. J'ai changé cette expression régulière comme suit:

    const char* ipv4_regex = "\\b(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\."
           "(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\."
           "(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\."
           "(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\b";

utiliser cette expression régulière maintenant 192.168.100.009 n'est pas une adresse ipv4 valide alors que 192.168.100.9 est ok.

J'ai également modifié une expression régulière pour l'adresse multicast et c'est la suivante:

    const char* mcast_ipv4_regex = "\\b(22[4-9]|23[0-9])\\."
                        "(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\."
                        "(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9]?)\\."
                        "(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\b";

Je pense que vous devez adapter l'expression régulière au langage que vous utilisez pour développer votre application

J'ai mis un exemple en java:

    package utility;

    import java.util.regex.Matcher;
    import java.util.regex.Pattern;

    public class NetworkUtility {

        private static String ipv4RegExp = "\\b(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d?)\\b";

        private static String ipv4MulticastRegExp = "2(?:2[4-9]|3\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d?|0)){3}";

        public NetworkUtility() {

        }

        public static boolean isIpv4Address(String address) {
            Pattern pattern = Pattern.compile(ipv4RegExp);
            Matcher matcher = pattern.matcher(address);

            return matcher.matches();
        }

        public static boolean isIpv4MulticastAddress(String address) {
             Pattern pattern = Pattern.compile(ipv4MulticastRegExp);
             Matcher matcher = pattern.matcher(address);

             return matcher.matches();
        }
    }
Fabio Stafforte
la source
0
-bash-3.2$ echo "191.191.191.39" | egrep 
  '(^|[^0-9])((2([6-9]|5[0-5]?|[0-4][0-9]?)?|1([0-9][0-9]?)?|[3-9][0-9]?|0)\.{3}
     (2([6-9]|5[0-5]?|[0-4][0-9]?)?|1([0-9][0-9]?)?|[3-9][0-9]?|0)($|[^0-9])'

>> 191.191.191.39

(Ceci est un DFA qui correspond à tout l'espace d'adr (y compris les diffusions, etc.) et rien d'autre.

Jonathzen
la source
0

Je pense que celui-ci est le plus court.

^(([01]?\d\d?|2[0-4]\d|25[0-5]).){3}([01]?\d\d?|2[0-4]\d|25[0-5])$
Altan Gokcek
la source
0

J'ai trouvé cet exemple très utile, en plus il permet différentes notations ipv4.

exemple de code utilisant python:

    def is_valid_ipv4(ip4):
    """Validates IPv4 addresses.
    """
    import re
    pattern = re.compile(r"""
        ^
        (?:
          # Dotted variants:
          (?:
            # Decimal 1-255 (no leading 0's)
            [3-9]\d?|2(?:5[0-5]|[0-4]?\d)?|1\d{0,2}
          |
            0x0*[0-9a-f]{1,2}  # Hexadecimal 0x0 - 0xFF (possible leading 0's)
          |
            0+[1-3]?[0-7]{0,2} # Octal 0 - 0377 (possible leading 0's)
          )
          (?:                  # Repeat 0-3 times, separated by a dot
            \.
            (?:
              [3-9]\d?|2(?:5[0-5]|[0-4]?\d)?|1\d{0,2}
            |
              0x0*[0-9a-f]{1,2}
            |
              0+[1-3]?[0-7]{0,2}
            )
          ){0,3}
        |
          0x0*[0-9a-f]{1,8}    # Hexadecimal notation, 0x0 - 0xffffffff
        |
          0+[0-3]?[0-7]{0,10}  # Octal notation, 0 - 037777777777
        |
          # Decimal notation, 1-4294967295:
          429496729[0-5]|42949672[0-8]\d|4294967[01]\d\d|429496[0-6]\d{3}|
          42949[0-5]\d{4}|4294[0-8]\d{5}|429[0-3]\d{6}|42[0-8]\d{7}|
          4[01]\d{8}|[1-3]\d{0,9}|[4-9]\d{0,8}
        )
        $
    """, re.VERBOSE | re.IGNORECASE)
    return pattern.match(ip4) <> None
interné
la source
0
((\.|^)(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]?|0$)){4}

Cette regex n'acceptera pas 08.8.8.8 ou 8.08.8.8 ou 8.8.08.8 ou 8.8.8.08

sudistack
la source
celui-ci manque par exemple 127.0.0.1 et 0.0.0.0
anneb
^ ((\. | ^) (25 [0-5] | 2 [0-4] [0-9] | 1 [0-9] [0-9] | [1-9] [0-9] ? | [0-9]? | 0)) ((\. | ^) (25 [0-5] | 2 [0-4] [0-9] | 1 [0-9] [0-9] | [1-9] [0-9]? | 0)) {2}. ((25 [0-5] | 2 [0-4] [0-9] | 1 [0-9] [0- 9] | [1-9] [0-9]? | 0) $)
sudistack
1
Il est correct de rejeter les zéros non significatifs, selon la spécification.
John Haugeland
0

Recherche une adresse IP valide tant que l'adresse IP est enroulée autour de tout caractère autre que des chiffres (derrière ou devant l'IP). 4 références inverses créées: $ + {first}. $ + {Second}. $ + {Third}. $ + {Ahead}

Find String:
#any valid IP address
(?<IP>(?<![\d])(?<first>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?<second>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?<third>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?<forth>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))(?![\d]))
#only valid private IP address RFC1918
(?<IP>(?<![\d])(:?(:?(?<first>10)[\.](?<second>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5])))|(:?(?<first>172)[\.](?<second>(:?1[6-9])|(:?2[0-9])|(:?3[0-1])))|(:?(?<first>192)[\.](?<second>168)))[\.](?<third>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?<forth>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))(?![\d]))

Notepad++ Replace String Option 1: Replaces the whole IP (NO Change):
$+{IP}

Notepad++ Replace String Option 2: Replaces the whole IP octect by octect (NO Change)
$+{first}.$+{second}.$+{third}.$+{forth}

Notepad++ Replace String Option 3: Replaces the whole IP octect by octect (replace 3rd octect value with 0)
$+{first}.$+{second}.0.$+{forth}
NOTE: The above will match any valid IP including 255.255.255.255 for example and change it to 255.255.0.255 which is wrong and not very useful of course.

En remplaçant une partie de chaque octect par une valeur réelle, vous pouvez cependant créer votre propre recherche et remplacement, ce qui est réellement utile pour modifier les adresses IP dans les fichiers texte:

for example replace the first octect group of the original Find regex above:
(?<first>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))
with
(?<first>10)

and
(?<second>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))
with
(?<second>216)
and you are now matching addresses starting with first octect 192 only

Find on notepad++:
(?<IP>(?<![\d])(?<first>10)[\.](?<second>216)[\.](?<third>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?<forth>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))(?![\d]))

Vous pouvez toujours effectuer un remplacement en utilisant des groupes de référence arrière exactement de la même manière qu'auparavant.

Vous pouvez avoir une idée de la correspondance ci-dessus:

cat ipv4_validation_test.txt
Full Match:
0.0.0.1
12.108.1.34
192.168.1.1
10.249.24.212
10.216.1.212
192.168.1.255
255.255.255.255
0.0.0.0


Partial Match (IP Extraction from line)
30.168.1.0.1
-1.2.3.4
sfds10.216.24.23kgfd
da11.15.112.255adfdsfds
sfds10.216.24.23kgfd


NO Match
1.1.1.01
3...3
127.1.
192.168.1..
192.168.1.256
da11.15.112.2554adfdsfds
da311.15.112.255adfdsfds

En utilisant grep, vous pouvez voir les résultats ci-dessous:

From grep:
grep -oP '(?<IP>(?<![\d])(?<first>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?<second>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?<third>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?<forth>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))(?![\d]))' ipv4_validation_test.txt
0.0.0.1
12.108.1.34
192.168.1.1
10.249.24.212
10.216.1.212
192.168.1.255
255.255.255.255
0.0.0.0
30.168.1.0
1.2.3.4
10.216.24.23
11.15.112.255
10.216.24.23


grep -P '(?<IP>(?<![\d])(?<first>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?<second>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?<third>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?<forth>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))(?![\d]))' ipv4_validation_test.txt
0.0.0.1
12.108.1.34
192.168.1.1
10.249.24.212
10.216.1.212
192.168.1.255
255.255.255.255
0.0.0.0
30.168.1.0.1
-1.2.3.4
sfds10.216.24.23kgfd
da11.15.112.255adfdsfds
sfds10.216.24.23kgfd


#matching ip addresses starting with 10.216
grep -oP '(?<IP>(?<![\d])(?<first>10)[\.](?<second>216)[\.](?<third>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?<forth>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))(?![\d]))' ipv4_validation_test.txt
10.216.1.212
10.216.24.23
10.216.24.23
rda
la source
0

L'adresse IPv4 est une chose très compliquée.

Remarque : l'indentation et la doublure sont uniquement à des fins d'illustration et n'existent pas dans le vrai RegEx.

\b(
  ((
    (2(5[0-5]|[0-4][0-9])|1[0-9]{2}|[1-9]?[0-9])
  |
    0[Xx]0*[0-9A-Fa-f]{1,2}
  |
    0+[1-3]?[0-9]{1,2}
  )\.){1,3}
  (
    (2(5[0-5]|[0-4][0-9])|1[0-9]{2}|[1-9]?[0-9])
  |
    0[Xx]0*[0-9A-Fa-f]{1,2}
  |
    0+[1-3]?[0-9]{1,2}
  )
|
  (
    [1-3][0-9]{1,9}
  |
    [1-9][0-9]{,8}
  |
    (4([0-1][0-9]{8}
      |2([0-8][0-9]{7}
        |9([0-3][0-9]{6}
          |4([0-8][0-9]{5}
            |9([0-5][0-9]{4}
              |6([0-6][0-9]{3}
                |7([0-1][0-9]{2}
                  |2([0-8][0-9]{1}
                    |9([0-5]
    ))))))))))
  )
|
  0[Xx]0*[0-9A-Fa-f]{1,8}
|
  0+[1-3]?[0-7]{,10}
)\b

Ces adresses IPv4 sont validées par le RegEx ci-dessus.

127.0.0.1
2130706433
0x7F000001
017700000001
0x7F.0.0.01 # Mixed hex/dec/oct
000000000017700000001 # Have as many leading zeros as you want
0x0000000000007F000001 # Same as above
127.1
127.0.1

Ceux-ci sont rejetés.

256.0.0.1
192.168.1.099 # 099 is not a valid number
4294967296 # UINT32_MAX + 1
0x100000000
020000000000
iBug
la source
0

^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\\.)){3}+((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?))$


Ci-dessus sera regex pour l'adresse IP comme: 221.234.000.112 également pour 221.234.0.112, 221.24.03.112, 221.234.0.1


Vous pouvez imaginer toutes sortes d'adresses comme ci-dessus

Ram Sharma
la source
0

J'utiliserais PCRE et le definemot - clé:

/^
 ((?&byte))\.((?&byte))\.((?&byte))\.((?&byte))$
 (?(DEFINE)
     (?<byte>25[0-5]|2[0-4]\d|[01]?\d\d?))
/gmx

Démo: https://regex101.com/r/IB7j48/2

La raison en est d'éviter de répéter le (25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)motif quatre fois. D'autres solutions telles que celle ci-dessous fonctionnent bien, mais elles ne capturent pas chaque groupe comme cela serait demandé par beaucoup.

/^((\d+?)(\.|$)){4}/ 

La seule autre façon d'avoir 4 groupes de capture est de répéter le motif quatre fois:

/^(?<one>\d+)\.(?<two>\d+)\.(?<three>\d+)\.(?<four>\d+)$/

Capturer un ipv4 en perl est donc très simple

$ echo "Hey this is my IP address 138.131.254.8, bye!" | \
  perl -ne 'print "[$1, $2, $3, $4]" if \
    /\b((?&byte))\.((?&byte))\.((?&byte))\.((?&byte))
     (?(DEFINE)
        \b(?<byte>25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?))
    /x'

[138, 131, 254, 8]
nowox
la source
0

L'expression rationnelle IPv4 la plus précise, la plus simple et la plus compacte que je puisse imaginer est

^(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$

Mais qu'en est-il de la performance / efficacité de ... Désolé, je ne sais pas, qui s'en soucie?

Fuweichin
la source
0

Essaye ça:

\b(([1-9]|[1-9][0-9]|1[0-9][0-9]|2[0-5][0-5])\.([1-9]|[1-9][0-9]|1[0-9][0-9]|2[0-5][0-5])\.([1-9]|[1-9][0-9]|1[0-9][0-9]|2[0-5][0-5])\.(2[0-5][0-5]|1[0-9][0-9]|[1-9][0-9]|[1-9]))\b
AAP
la source
0
ip address can be from 0.0.0.0 to 255.255.255.255

(((0|1)?[0-9][0-9]?|2[0-4][0-9]|25[0-5])[.]){3}((0|1)?[0-9][0-9]?|2[0-4][0-9]|25[0-5])$

(0|1)?[0-9][0-9]? - checking value from 0 to 199
2[0-4][0-9]- checking value from 200 to 249
25[0-5]- checking value from 250 to 255
[.] --> represent verify . character 
{3} --> will match exactly 3
$ --> end of string
Deepak_Mahalingam
la source
0

Voici l'expression regex pour valider l'adresse IP.

^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$
Dilip Paudel
la source
0

Moyen facile

((25[0-5]|2[0-4][0-9]|[1][0-9][0-9]|[1-9][0-9]{0,1})\.){3}(25[0-5]|2[0-4][0-9]|[1][0-9][0-9]|[1-9][0-9]{0,1})

Démo

BabiBN
la source