Validación de direcciones IPv4 con expresiones regulares

90

He estado tratando de obtener una expresión regular eficiente para la validación de IPv4, pero sin mucha suerte. Parecía que en un momento lo había tenido (25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?(\.|$)){4}, pero produce algunos resultados extraños:

$ 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

Hice una búsqueda para ver si esto ya se había preguntado y respondido, pero otras respuestas parecen simplemente mostrar cómo determinar 4 grupos de 1-3 números, o no funcionan para mí.

Matthieu Cartier
fuente
12
No olvide que A, AB y ABC son formas válidas de dirección IP, así como ABCD En serio. Prueba ping 2130706433y ping 127.1por una risita.
dty
1
Mi variante en línea regexr.com/39hqf
Sllouyssgort

Respuestas:

97

Ya tiene una respuesta que funciona, pero en caso de que sienta curiosidad por saber qué estaba mal con su enfoque original, la respuesta es que necesita paréntesis alrededor de su alternancia; de lo contrario, (\.|$)solo se requiere si el número es menor que 200.

'\b((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\.|$)){4}\b'
    ^                                    ^
Mark Byers
fuente
25
esto parece también validar cosas como192.168.1.1.1
cwd
2
Debería ser \b((?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(?:(?<!\.)\b|\.)){4}:; es decir, ¿termina con un límite de palabra en lugar de con el final de la línea? Además, aquí he marcado los grupos que no capturan para evitar subpartidas no deseadas. NB: Esto todavía no tiene en cuenta el comentario de @ dty ya que no estoy familiarizado con esa forma de IP; aunque tiene razón en que parece válido.
JohnLBevan
Quizás quieras probar esto en su lugar: ((1? \ D \ d? | 2 [0-4] \ d | 25 [0-5]) \.) {3} (1? \ D \ d? | 2 [0-4] \ d | 25 [0-5])
Morg.
Esto funciona bien para no capturar\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
¿Se 09.09.09.09considera una IP válida? También se empareja con esta expresión regular. Pero ping arroja un mensaje de error como ping: cannot resolve 09.09.09.09: Unknown host. Creo que sería prudente reducir la coincidencia solo a la coincidencia de notación decimal con puntos. Esta entrada analiza los errores principales en las direcciones 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]?)$

Aceptar :

127.0.0.1
192.168.1.1
192.168.1.255
255.255.255.255
0.0.0.0
1.1.1.01

Rechazar :

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

Pruebe en línea con pruebas unitarias: https://www.debuggex.com/r/-EDZOqxTxhiTncN6/1

Sllouyssgort
fuente
¿Qué pasa con la dirección IP "3 ... 3"? 3 ... 3 se acepta usando esta expresión regular
Ankur Loriya
7
¿Qué pasa con 1.1.1.01? ¿Se considera una dirección IPv4 válida? Gracias.
odieatla
esta expresión regular 1.1.1.01 se considera una dirección IPv4 VÁLIDA. Pruebas de unidad en línea debuggex.com/r/-EDZOqxTxhiTncN6/1
Sllouyssgort
por cierto, ^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\.|$)){4}$obtenga el mismo resultado debuggex.com/r/mz_-0dEm3wseIKqK , bastante similar con la respuesta de @Mark Byers
Sllouyssgort
@PriteshAcharya Funciona bien aquí.
Kid Diamond
34

Versión más nueva, más corta y menos legible ( 55 caracteres )

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

Esta versión busca el estuche 250-5, después de eso, inteligentemente OR todos los casos posibles para los 200-249 100-199 10-99casos. Tenga en cuenta que la |)pieza no es un error, sino que en realidad representa el último caso para el rango 0-9. También he omitido el?: parte del grupo que no captura, ya que realmente no nos importan los elementos capturados, no serían capturados de ninguna manera si no tuviéramos una coincidencia completa en primer lugar.

Versión antigua y más corta (menos legible) ( 63 caracteres )

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

Versión anterior (legible) ( 70 caracteres )

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

Utiliza la búsqueda anticipada negativa (?!)para eliminar el caso en el que la ip podría terminar con un.

Respuesta más antigua ( 115 caracteres )

^(?:(?: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])$

Creo que esta es la expresión regular más precisa y estricta, no acepta cosas como 000.021.01.0.parece que la mayoría de las otras respuestas aquí lo hacen y requieren expresiones regulares adicionales para rechazar casos similares a ese, es decir, 0números iniciales y una dirección IP que termina con una.

Danail Gabenski
fuente
Esta es la única respuesta correcta en este hilo hasta la fecha. Los otros pierden direcciones como 0.0.0.0o aceptan notación mixta octal / decimal como 033.033.33.033o incluso permiten 999.999.999.999. ¿Qué tal esta expresión regular que es 10 caracteres más corta que esta respuesta:(([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 Revertí tu edición porque permitía cosas como 192.168.000.1, que no es una dirección válida. Cualquiera que desee editar esta respuesta, comente primero aquí para evitar problemas como estos; por lo general, respondo bastante rápido. Siempre buscando una solución mejor / más corta, por supuesto.
Danail Gabenski
1
@DanailGabenski (y otros) para la memoria, lo resolvió reemplazando el último [01]?[0-9][0-9]?por 1[0-9]{2}|[1-9]?[0-9]porque no le gusta llevar 0 . Gracias de nuevo ! Guardaré tu solución en mi equipaje maestro de expresiones regulares.
Tinmarino
1
@tinmarino sí, el formato decimal de punto que se ha convertido en estándar para ipv4, aunque no se acepta oficialmente, mire lo siguiente . Concretamente el punto 3, donde se sugirió un borrador pero caducó. Una razón secundaria para ser tan estricto con la validación es que cuando se presentan en la interfaz de usuario, las direcciones IP con números no decimales como 023 en lugar de 23 hacen que los usuarios piensen que esto es un error / error. También genera dificultades con la verificación / seguridad, ya que el 023 debe convertirse en 23 para evitar duplicados, etc. ¡Gracias por intentar mejorar las cosas!
Danail Gabenski
1
Puede que sea más corto por factorización la [0-9]de los 2[0-4], 1y más cortos los casos. ^(?:(25[0-5]|(?:2[0-4]|1[0-9]|[1-9]|)[0-9])(\.(?!$)|$)){4}$
Clayton Singh
12

Dirección IPv4 (captura precisa) Coincide con 0.0.0.0 a 255.255.255.255 Utilice esta expresión regular para hacer coincidir los números de IP con precisión. Cada uno de los 4 números se almacena en un grupo de captura, por lo que puede acceder a ellos para su posterior procesamiento.

\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

tomado de la biblioteca JGsoft RegexBuddy

Editar: esta (\.|$)parte parece extraña

Valerij
fuente
2
¡Agradable! Hice una modificación más eficiente de lo que parece funcionar: "\b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\.|$){4}\b- ¡gracias!
Matthieu Cartier
2
@MatthieuCartier Tu patrón de expresiones regulares eficiente no funcionó para mí,
R__raki__
255.255.255.000 no es una IP válida
Stéphane GRILLON
6

Estaba buscando algo similar para las direcciones IPv4: una expresión regular que también impidiera la validación de las direcciones IP privadas de uso común (192.168.xy, 10.xyz, 172.16.xy), por lo que usé una mirada negativa para lograr esto:

(?!(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}

(Por supuesto, estos deben estar en una línea, formateados para facilitar la lectura en 3 líneas separadas) Visualización de expresiones regulares

Demostración de Debuggex

Puede que no esté optimizado para la velocidad, pero funciona bien cuando solo busca direcciones de Internet "reales".

Cosas que fallarán (y deberían):

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 que funcionarán (y deberían):

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)

Se proporciona en caso de que alguien más esté buscando validar 'direcciones IP de Internet sin incluir las direcciones privadas comunes'

PhillipHolmes
fuente
5

Creo que mucha gente que lea esta publicación buscará expresiones regulares más simples, incluso si coinciden con algunas direcciones IP técnicamente inválidas. (Y, como se señaló en otra parte, la expresión regular probablemente no sea la herramienta adecuada para validar correctamente una dirección IP de todos modos).

Elimine ^y, cuando corresponda, reemplace $con \b, si no desea que coincida con el principio / final de la línea.

Expresión regular básica (BRE) (probado en GNU grep, GNU sed y vim):

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

Expresión regular extendida (ERE):

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

o:

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

Expresión regular compatible con Perl (PCRE) (probado en Perl 5.18):

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

o:

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

Ruby (probado en Ruby 2.1):

Aunque se supone que es PCRE, Ruby, por cualquier razón, permitió esta expresión regular no permitida por Perl 5.18:

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

Mis pruebas para todos estos están en línea aquí .

Alex Harvey
fuente
3

Esto es un poco más largo que algunos, pero esto es lo que uso para hacer coincidir las direcciones IPv4. Sencillo sin concesiones.

^((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
fuente
3

Las respuestas anteriores son válidas, pero ¿qué pasa si la dirección IP no está al final de la línea y está entre el texto? Esta expresión regular incluso funcionará en eso.

código: '\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'

archivo de texto de entrada:

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

texto de salida:

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
fuente
1
Esto se marcó negativamente, hasta que lo voté. He intentado hacer exactamente esto durante (más horas de las que quiero admitir). No capturará una línea que tenga más de un punto-cuádruple en una línea, pero para mi caso de uso, puedo vivir con eso. Esta es una excelente respuesta, ¡necesita más votos!
anastrophe
3

'' 'Este código funciona para mí y es tan simple como eso.

Aquí he tomado el valor de ip y estoy tratando de emparejarlo con 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 condición anterior verifica si el valor excede 255 para los 4 octetos, entonces no es válido. Pero antes de aplicar la condición tenemos que convertirlos en enteros ya que el valor está en una cadena.

el grupo (0) imprime la salida coincidente, mientras que el grupo (1) imprime el primer valor coincidente y aquí es "25" y así sucesivamente. '' '

Shruti Lakkihal
fuente
Bienvenido a StackOverflow. Si pudiera dedicar algunas palabras a por qué su respuesta debería resolver el problema de OP, sería genial. Las respuestas de código único son generalmente malas respuestas, ya que no ayudan a los otros programadores a comprender qué habían hecho mal.
Davide Vitali
Use la sangría adecuada en su código para que sea legible para los usuarios
Syed Mehtab Hassan
2

Me las arreglé para construir una expresión regular a partir de todas las demás respuestas.

(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
fuente
Según el estándar ethernet IEEE 802.x, la validación de IP es el rango de IP 0.xxx >>> no debe permitirse: IP no válida. # 1.El rango de IP comienza desde 1.xxx hasta 126.xxx >>>> se puede configurar. # 2.No se debe permitir el rango de IP 127.xxx >>>> - IP no válida. # 3.Se puede configurar el rango IP 128.xxx a 223.xxx >>. la mejor manera de manejar se sugiere a continuación: ^ (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
fuente
2

Para el número de 0 a 255 utilizo esta expresión regular:

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

La expresión regular anterior coincidirá con el número entero de 0 a 255, pero no coincidirá con 256.

Entonces, para IPv4 utilizo esta expresión regular:

^(([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})$

Está en esta estructura: ^(N)((\.(N)){3})$donde N es la expresión regular utilizada para hacer coincidir el número de 0 a 255.
Esta expresión regular coincidirá con la IP como se muestra a continuación:

0.0.0.0
192.168.1.2

pero no los de abajo:

10.1.0.256
1.2.3.
127.0.1-2.3

Para IPv4 CIDR (enrutamiento entre dominios sin clase) utilizo esta expresión regular:

^(([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]))$

Está en esta estructura: ^(N)((\.(N)){3})\/M$donde N es la expresión regular utilizada para hacer coincidir el número de 0 a 255, y M es la expresión regular utilizada para hacer coincidir el número de 0 a 32.
Esta expresión regular coincidirá con CIDR como se muestra a continuación:

0.0.0.0/0
192.168.1.2/32

pero no los de abajo:

10.1.0.256/16
1.2.3./24
127.0.0.1/33

Y para la lista de IPv4 CIDR como "10.0.0.0/16", "192.168.1.1/32"yo uso esta expresión regular:

^("(([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]))"))*)$

Está en esta estructura: ^(“C”)((,([ ]*)(“C”))*)$donde C es la expresión regular utilizada para coincidir con CIDR (como 0.0.0.0/0).
Esta expresión regular coincidirá con la lista de CIDR como se muestra a continuación:

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

pero no los de abajo:

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

Tal vez pueda ser más corto, pero para mí es fácil de entender tan bien para mí.

¡Espero eso ayude!

congacón
fuente
¡Bienvenido a SO, agradecemos sus comentarios! ¿Podrías explicar un poco más qué están haciendo las diferentes expresiones regulares (en particular, la última)?
B - rian
1

Con máscara de subred:

^$|([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
fuente
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})))

Prueba para encontrar coincidencias en el texto, https://regex101.com/r/9CcMEN/2

Las siguientes son las reglas que definen las combinaciones válidas en cada número de una dirección IP:

  • Cualquier número de uno o dos dígitos.
  • Cualquier número de tres dígitos que comience con 1.

  • Cualquier número de tres dígitos que comience con 2si el segundo dígito es 0 intermedio 4.

  • Cualquier número de tres dígitos que comience con 25si el tercer dígito es 0 intermedio 5.

Comencemos con (((25[0-5])|(2[0-4]\d)|(1\d{2})|(\d{1,2}))\.)un conjunto de cuatro subexpresiones anidadas, y las veremos en orden inverso. (\d{1,2})coincide con cualquier número de uno o dos dígitos o números 0hasta 99. (1\d{2})coincide con cualquier número de tres dígitos que comience con 1( 1seguido de dos dígitos), o números 100hasta 199. (2[0-4]\d)partidos números 200través 249. (25[0-5])partidos números 250través 255. Cada una de estas subexpresiones se incluye dentro de otra subexpresión con un |entre cada una (de modo que una de las cuatro subexpresiones debe coincidir, no todas). Después de que el rango de números \.coincida ) se incluye en otra subexpresión y se repite tres veces usando. , y luego toda la serie (todas las opciones de números más\.{3} . Finalmente, se repite el rango de números (esta vez sin el final\. ) para que coincida con el número de dirección IP final. Al restringir cada uno de los cuatro números a valores entre 0y 255, este patrón puede de hecho coincidir con direcciones IP válidas y rechazar direcciones no válidas.

Extracto de: Ben Forta. "Aprendiendo expresiones regulares".


Si ni un personaje es buscado en el comienzo de la dirección IP ni al final, ^y $metacaracteres deben ser utilizados, respectivamente.

^(((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})))$

Prueba para encontrar coincidencias en el texto, https://regex101.com/r/uAP31A/1

snr
fuente
1

Traté de hacerlo un poco más simple y más corto.

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

Si está buscando 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 alguien quiere saber cómo funciona aquí está la explicación. Realmente es tan simple. Pruébalo: 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

Matemáticamente es como:

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

Entonces, como puede ver normalmente, este es el patrón para las direcciones IP. Espero que te ayude a entender un poco la expresión regular. :pag

Arhan Ashik
fuente
1

Traté de hacerlo un poco más simple y más corto.

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

Si está buscando 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 alguien quiere saber cómo funciona aquí está la explicación. Realmente es tan simple. Pruébalo: 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

Matemáticamente es como:

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

Entonces, como puede ver normalmente, este es el patrón para las direcciones IP. Espero que te ayude a entender un poco la expresión regular. :pag

Arhan Ashik
fuente
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";

Adapté la expresión regular tomada de la biblioteca JGsoft RegexBuddy al lenguaje C (regcomp / regexec) y descubrí que funciona, pero hay un pequeño problema en algunos sistemas operativos como Linux. Esa expresión regular acepta direcciones ipv4 como 192.168.100.009, donde 009 en Linux se considera un valor octal, por lo que la dirección no es la que pensaba. Cambié esa expresión regular de la siguiente manera:

    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";

usando esa expresión regular ahora 192.168.100.009 no es una dirección ipv4 válida mientras que 192.168.100.9 está bien.

También modifiqué una expresión regular para la dirección de multidifusión y es la siguiente:

    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";

Creo que debes adaptar la expresión regular al lenguaje que estás usando para desarrollar tu aplicación.

Pongo un ejemplo 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
fuente
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

(Este es un DFA que coincide con todo el espacio de direcciones (incluidas las transmisiones, etc.) y nada más.

Jonathzen
fuente
0

Creo que este es el más corto.

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

Encontré esta muestra muy útil, además permite diferentes notaciones ipv4.

código de muestra usando 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
internety
fuente
0
((\.|^)(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]?|0$)){4}

Esta expresión regular no aceptará 08.8.8.8 o 8.08.8.8 o 8.8.08.8 o 8.8.8.08

sudistack
fuente
este pierde, por ejemplo, 127.0.0.1 y 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
Es correcto rechazar los ceros iniciales, de acuerdo con la especificación.
John Haugeland
0

Encuentra una dirección IP válida siempre que la IP esté envuelta alrededor de cualquier carácter que no sean dígitos (detrás o delante de la IP). 4 backreferences creadas: $ + {primero}. $ + {Segundo}. $ + {Tercero}. $ + {Cuarto}

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.

Reemplazando parte de cada octecto con un valor real, sin embargo, puede crear su propia búsqueda y reemplazo, lo cual es realmente útil para modificar IP en archivos de texto:

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]))

Aún puede realizar Reemplazar usando grupos de referencia inversa exactamente de la misma manera que antes.

Puede hacerse una idea de cómo coincidía lo anterior a continuación:

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

Usando grep puede ver los resultados a continuación:

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
fuente
0

La dirección IPv4 es algo muy complicado.

Nota : La sangría y el revestimiento son solo para fines ilustrativos y no existen en la expresión regular real.

\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

Estas direcciones IPv4 están validadas por la expresión regular anterior.

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

Estos son rechazados.

256.0.0.1
192.168.1.099 # 099 is not a valid number
4294967296 # UINT32_MAX + 1
0x100000000
020000000000
iBug
fuente
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]?))$


Arriba estará regex para la dirección IP como: 221.234.000.112 también para 221.234.0.112, 221.24.03.112, 221.234.0.1


Puedes imaginar todo tipo de dirección como arriba

Ram Sharma
fuente
0

Usaría PCRE y la definepalabra clave:

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

Demostración: https://regex101.com/r/IB7j48/2

La razón de esto es evitar repetir el (25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)patrón cuatro veces. Otras soluciones, como la que se muestra a continuación, funcionan bien, pero no captan a cada grupo como muchos lo solicitarían.

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

La única otra forma de tener 4 grupos de captura es repetir el patrón cuatro veces:

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

Por lo tanto, capturar un ipv4 en perl es muy fácil

$ 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
fuente
0

La expresión regular IPv4 más precisa, sencilla y compacta que puedo imaginar es

^(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)$

Pero ¿qué pasa con el rendimiento / eficiencia de ... Lo siento, no sé, a quién le importa?

fuweichin
fuente
0

Prueba esto:

\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
fuente
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
fuente
0

A continuación se muestra la expresión regular para validar la dirección 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
fuente
0

Manera fácil

((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})

Manifestación

BabiBN
fuente