Identificador de dirección IP privada en expresión regular

Me pregunto si esta es la mejor manera de hacer coincidir una cadena que comience con una dirección IP privada (Perl-style Regex):

(^127\.0\.0\.1)|(^192\.168)|(^10\.)|(^172\.1[6-9])|(^172\.2[0-9])|(^172\.3[0-1]) 

¡Muchas gracias!

Supongo que quieres hacer coincidir estos rangos:

 127. 0.0.0 - 127.255.255.255 127.0.0.0 / 8
  10. 0.0.0 - 10.255.255.255 10.0.0.0 / 8
 172. 16.0.0 - 172. 31.255.255 172.16.0.0 / 12
 192.168.0.0 - 192.168.255.255 192.168.0.0 / 16

Le faltan algunos puntos que podrían provocar que acepte, por ejemplo, 172.169.0.0 , aunque esto no debería aceptarse. Lo he arreglado a continuación. Elimina las nuevas líneas, solo para facilitar la lectura.

 (^127\.)| (^10\.)| (^172\.1[6-9]\.)|(^172\.2[0-9]\.)|(^172\.3[0-1]\.)| (^192\.168\.) 

También tenga en cuenta que esto supone que las direcciones IP ya han sido validadas; acepta cosas como 10.foobar .

Esto es lo mismo que la respuesta correcta de Mark, pero ahora incluye direcciones privadas de IPv6.

 /(^127\.)|(^192\.168\.)|(^10\.)|(^172\.1[6-9]\.)|(^172\.2[0-9]\.)|(^172\.3[0-1]\.)|(^::1$)|(^[fF][cCdD])/ 

He generado esto

REGEXP PARA REDES DE CLASE A:

(10)(\.([2]([0-5][0-5]|[01234][6-9])|[1][0-9][0-9]|[1-9][0-9]|[0-9])){3}

REGEXP PARA REDES DE CLASE B:

(172)\.(1[6-9]|2[0-9]|3[0-1])(\.([2][0-5][0-5]|[1][0-9][0-9]|[1-9][0-9]|[0-9])){2}

REGEXP PARA REDES DE CLASE C:

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

Avísame si encuentras algún error

Si está seguro de su resultado (digamos por ejemplo netstat) y no necesita verificar la validez de la dirección IP porque ya está hecha, entonces puede capturar direcciones IP privadas con esta fórmula

grep -P “(10. | 192.168 | 172.1 [6-9]. | 172.2 [0-9]. | 172.3 [01].) * *”

Esto es en caso de que decida ir con mi comentario, sugiriendo que no use expresiones regulares. No probado (pero probablemente funciona, o al menos cerca), en Perl:

 @private = ( {network => inet_aton('127.0.0.0'), mask => inet_aton('255.0.0.0') }, {network => inet_aton('192.168.0.0'), mask => inet_aton('255.255.0.0') }, # ... ); $ip = inet_aton($ip_text); if (grep $ip & $_->{mask} == $_->{network}, @private) { # ip address is private } else { # ip address is not private } 

Tenga en cuenta ahora cómo @private solo es información, que puede cambiar fácilmente. O descargue sobre la marcha de la referencia de Cymru Bogon .

editar: Se me ocurre que pedir una expresión regular de Perl no significa que conozca Perl, por lo que la línea clave es que allí está el ‘grep’, que simplemente pasa por encima de cada rango de direcciones privadas. Usted toma su IP, a nivel de bit y con la máscara de red, y la compara con la dirección de red. Si es igual, es parte de esa red privada.

Se ve bien Personalmente, cambiaría el primero a:

 ^127\.0 

Con esto: (^127\.0\.0\.1) estás buscando cualquier cosa que comience con 127.0.0.1 y se perderá en 127.0.0.2* , 127.0.2.* , 127.0.* Etc.

Si está buscando system.net defaultProxy y proxy bypasslist config que usa un proxy para externo pero usa conexiones directas para hosts internos (podría hacerlo con algún soporte de ipv6) …

                   

aquí es lo que uso en Python:

 rfc1918 = re.compile('^(10(\.(25[0-5]|2[0-4][0-9]|1[0-9]{1,2}|[0-9]{1,2})){3}|((172\.(1[6-9]|2[0-9]|3[01]))|192\.168)(\.(25[0-5]|2[0-4][0-9]|1[0-9]{1,2}|[0-9]{1,2})){2})$') 

Puede eliminar los anclajes ^ y / o $ si lo desea.

Prefiero la expresión regular anterior porque elimina los octetos inválidos (cualquier cosa superior a 255).

uso de ejemplo:

 if rfc1918.match(ip): print "ip is private" 
  //RegEx to check for the following ranges. IPv4 only //172.16-31.xxx.xxx //10.xxx.xxx.xxx //169.254.xxx.xxx //192.168.xxx.xxx var regex = /(^127\.)|(^(0)?10\.)|(^172\.(0)?1[6-9]\.)|(^172\.(0)?2[0-9]\.)|(^172\.(0)?3[0-1]\.)|(^169\.254\.)|(^192\.168\.)/; 

FWIW este patrón fue más de 10% más rápido usando pattern.matcher :

 ^1((0)|(92\\.168)|(72\\.((1[6-9])|(2[0-9])|(3[0-1])))|(27))\\.