Adresse IP privée identifier, dans l'Expression Régulière

Je me demande si c'est la meilleure façon de faire correspondre une chaîne qui commence avec une adresse IP privée (Perl-style Regex):

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

Merci beaucoup!

Tout d'abord, vous devez examiner RFC1918 pour obtenir la bonne liste. Deuxièmement, je suggère qu'une solution n'impliquant pas les expressions régulières seront plus faciles à entretenir. Une fois que vous convertir une adresse IP numérique, il est assez facile pour le match contre le une liste de plages d'adresses IP. Cela vous permettra aussi d'utiliser facilement à la disposition du public bogon listes, qui contiennent beaucoup plus que RFC1918.
vrai, mais pour des utilisations comme l'un Tomcat à Distance Filtre d'Adresse vous avez besoin d'une expression régulière.
C'est une erreur de débutant à penser ^ signifie "non" dans ce contexte, il faut aussi souligner: Chaque ^ dans votre expression simplement ancres le match au début de la ligne. Traditionnelle de la regex, il n'y a pas de moyen simple de dire "non, pas cette chaîne" bien que Perl-compatible / PCRE expressions négatives lookaheads avec (?!...)

InformationsquelleAutor caseyamcl | 2010-05-11

51

Je suis en supposant que vous voulez faire correspondre ces plages:
```
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 
```
Il vous manque quelques points qui serait la cause de l'accepter par exemple 172.169.0.0 même si cela ne devrait pas être accepté. J'ai corrigé ci-dessous. Retirez les nouvelles lignes, c'est juste pour des raisons de lisibilité.
```
(^127\.)|
(^10\.)|
(^172\.1[6-9]\.)|(^172\.2[0-9]\.)|(^172\.3[0-1]\.)|
(^192\.168\.)
```
Également noter que cela suppose que les adresses IP ont déjà été validés, il accepte les choses comme 10.foobar.
- Si vous souhaitez exclure des adresses ip privées de suivi google analytics, utilisez ceci: gist.github.com/1000402
- La première ligne doit être (^127\.)|
- Il ne valide pas sur nos réseaux ip interne: Par exemple: 10.131.43.84 Votre 10 bloc est brisé
- Java version: '(^127\\.0\\.0\\.1)|(^10\\.)|(^172\\.1[6-9]\\.)|(^172\\.2[0-9]\\.)|(^172\\.3[0-1]\\.)|(^192\\.168\\.)'
- plus complexe mais plus précis: (^127\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$)|(^10\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$)|(^172\.1[6-9]{1}[0-9]{0,1}\.[0-9]{1,3}\.[0-9]{1,3}$)|(^172\.2[0-9]{1}[0-9]{0,1}\.[0-9]{1,3}\.[0-9]{1,3}$)|(^172\.3[0-1]{1}[0-9]{0,1}\.[0-9]{1,3}\.[0-9]{1,3}$)|(^192\.168\.[0-9]{1,3}\.[0-9]{1,3}$)
- L'auto link-local adresses privées 169.254.*.* devrait également être dans cet ensemble. Écrit de manière concise: ^(10|127|169\.254|172\.1[6-9]|172\.2[0-9]|172\.3[0-1]|192\.168)\.
InformationsquelleAutor Mark Byers
17

C'est la même que la réponse correcte par la Marque, mais maintenant, y compris le protocole IPv6 les adresses privées.
```
/(^127\.)|(^192\.168\.)|(^10\.)|(^172\.1[6-9]\.)|(^172\.2[0-9]\.)|(^172\.3[0-1]\.)|(^::1$)|(^[fF][cCdD])/
```
- Pas bonne Selon Wikipedia, (en.wikipedia.org/wiki/Unique_local_address), le bloc (fc00::/7) est réservée à des Adresses Locales Uniques. Cette Regex ajoute l'adresse localhost (::1) à la solution retenue.
- Selon github.com/rails/rails/pull/12651/files la regexp pour ce serait ^[fF][cCdD] - je suis l'édition la réponse en conséquence.
- Le / personnage au début et à la fin du script de me suggérer que vous êtes à l'aide de l'expression dans un langage comme Javascript, mais ce n'est pas valable dans les autres langues. Malgré cela, une version plus courte (et sans les barres obliques) est ^(127\.)|(192\.168\.)|(10\.)|(172\.1[6-9]\.)|(172\.2[0-9]\.)|(172\.3[0-1]\.)|(::1$)|([fF][cCdD])
InformationsquelleAutor Edward
10

J'ai généré ce

REGEXP POUR LES RÉSEAUX DE CLASSE A :

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

REGEXP POUR LES RÉSEAUX DE CLASSE B :

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

REGEXP POUR LES RÉSEAUX DE CLASSE C :

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

Laissez-moi savoir si vous rencontrez des erreurs

Si vous êtes sûr de votre sortie (disons, par exemple, la commande netstat) et vous n'avez pas besoin de vérifier l'adresse IP de validité parce que c'est déjà fait, alors vous pouvez l'attraper adresses ip privées avec cette formule

grep -P "(10.|192.168|172.1[6-9].|172.2[0-9].|172.3[01].).* "
- En utilisant simplement [2][0-5][0-5] pour les 200 à 255 gamme, comme les numéros de 206 à 209 et 216 à 219, etc. ne correspondra pas. Vous aurez à le remplacer par ([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5]).
- Quelle langue est-ce utilisé? Je ne peux pas le faire fonctionner, regex101.com/r/jdVmny/1
InformationsquelleAutor user3177026
3

C'est dans le cas où vous décidez d'aller avec mon commentaire, ce qui suggère de ne pas utiliser les expressions régulières. Non testé (mais probablement œuvres, ou au moins proche), 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
}
```
Remarque maintenant comment @private est juste des données, que vous pouvez facilement changer. Ou le télécharger à la volée à partir de la Cymru Bogon De Référence.

edit: Il me semble que le fait de poser pour un de Perl ne signifie pas que vous connaissez Perl, donc, la clé est la ligne il y a le "grep', qui vient de boucles sur chaque plage d'adresses privées. Vous prenez votre IP, au niveau du bit et avec le masque de réseau, et de les comparer à l'adresse réseau. En cas d'égalité, c'est une partie de ce réseau privé.

InformationsquelleAutor derobert
3

Ressemble à droite. Personnellement, je changerais le premier à:
```
^127\.0 
```
Avec ceci: (^127\.0\.0\.1) vous à la recherche de tout ce qui commence par 127.0.0.1 et manquer de 127.0.0.2*, 127.0.2.*, 127.0.* etc.
- Je sais que c'est vieux, mais cette question est de première ou de seconde sur mon moteur de recherche google. Je crois que l'ensemble de la 127.0.0.0/8 bloc est réservé pour le bouclage, de sorte que 0 ne devrait même pas être là.
InformationsquelleAutor KM.

Si vous êtes à la recherche pour system.net defaultProxy et proxy bypasslist config qui utilise un proxy pour l'extérieur, mais utilise des connexions directes pour les hôtes internes (pouvait faire avec une certaine prise en charge d'ipv6)...

<system.net>
  <defaultProxy enabled="true">
    <proxy proxyaddress="http://proxycluster.privatedomain.net:8080" bypassonlocal="True"  />
    <bypasslist>
      <!-- exclude local host -->
      <add address="^(http|https)://localhost$" />
      <!-- excludes *.privatedomain.net -->
      <add address="^(http|https)://.*\.privatedomain\.net$" />
      <!-- excludes simple host names -->
      <add address="^(http|https)://[a-z][a-z0-9\-_]*$" />
      <!-- exclude private network addresses 192.168, 172.16..31 through 31, 127.* etc. -->
      <add address="^(http|https)://((((127)|(10))\.[0-9]+\.[0-9]+\.[0-9]+)|(((172\.(1[6-9]|2[0-9]|3[0-1]))|(192\.168))\.[0-9]+\.[0-9]+))$"/>
    </bypasslist>
  </defaultProxy>
  <connectionManagement>
    <add address="*" maxconnection="10" />
  </connectionManagement>
</system.net>

InformationsquelleAutor Mhano

1

voici ce que j'utilise 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})$')
```
Vous pouvez supprimer les ^ et/ou $ ancres si vous le souhaitez.

Je préfère le au-dessus de regex, car il élimine les invalides octets (rien au-dessus de 255).

exemple d'utilisation:
```
if rfc1918.match(ip):
    print "ip is private"
```
InformationsquelleAutor Josh Worley

     //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\.)/;

InformationsquelleAutor HellKnight Hicks

-1

FWIW cette tendance a été de plus de 10% plus rapide en utilisant pattern.matcher:
```
^1((0)|(92\\.168)|(72\\.((1[6-9])|(2[0-9])|(3[0-1])))|(27))\\.
```
- J'ai fait quelques tests, mais il semble être sur à 100% plus lent. Pouvez-vous fournir quelques tests pour?
InformationsquelleAutor scott

Vous devez vous connecter pour publier un commentaire.