Identifiant d'adresse IP privée dans L'Expression régulière

C'est la même chose que la bonne réponse par Mark, mais maintenant y compris les adresses privées IPv6.

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

J'ai généré ceci

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-5][0-5]|[1][0-9][0-9]|[1-9][0-9]|[0-9])){2}

REGEXP POUR LES RÉSEAUX DE CLASSE C:

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

Faites-moi savoir si vous rencontrez une erreur

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

Grep-P "(10.|192.168|172.1[6-9].|172.2[0-9].|172.3[01].).* "

C'est dans le cas où vous décidez d'aller avec mon commentaire, suggérant que vous n'utilisez pas les expressions rationnelles. Non testé (mais fonctionne probablement, 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 téléchargez à la volée à partir de la référence Cymru Bogon .

Edit: il me semble que Demander une expression rationnelle Perl ne signifie pas que vous connaissez Perl, donc la ligne de clé est là est le 'grep', qui boucle juste sur chaque plage d'adresses privées. Vous prenez votre IP, bit à bit et avec le masque de réseau, et comparer à l'adresse réseau. Si égale, sa partie de ce réseau privé.

Ça a l'air bien. Personnellement, je changerais le premier en:

^127\.0 

Avec ceci: (^127\.0\.0\.1) vous cherchez tout ce qui commence par 127.0.0.1 et va manquer 127.0.0.2*, 127.0.2.*, 127.0.* etc.

Si vous cherchez system.net defaultProxy et proxy bypasslist config qui utilise un proxy pour externe mais utilise des connexions directes pour les hôtes internes(pourrait faire avec un support 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>

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 ancres ^ et/ou $ si vous le souhaitez.

Je préfère l'expression rationnelle ci-dessus car elle élimine les octets invalides (tout ce qui dépasse 255).

Exemple d'utilisation:

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 Ce modèle était plus de 10% plus rapide en utilisant pattern.matcher:

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