Expression régulière qui correspond aux adresses IPv6 valides

j'ai de la difficulté à écrire une expression régulière qui correspond aux adresses IPv6 valides, y compris celles sous leur forme compressée (avec :: ou des zéros en tête omis de chaque paire d'octets).

Quelqu'un peut-il Suggérer une expression régulière qui satisferait à l'exigence?

j'envisage d'étendre chaque paire d'octets et de faire correspondre le résultat avec un regex plus simple.

112
demandé sur Stefan Lasiewski 2008-09-10 09:57:24

30 réponses

si je peux esquiver votre question, envisagez d'utiliser la notion d'adresse de votre bibliothèque réseau pour analyser et vérifier les erreurs.

j'imagine qu'à un moment donné vous voudrez faire quelque chose avec ces adresses, alors pourquoi ne pas aller directement à la source et s'assurer que votre bibliothèque réseau comprendra l'adresse? C'est mieux que d'espérer que tout ce que regex est sur le point d'être posté ici correspondra au concept de votre implémentation de l'adresse.

en Java nous avons InetAddress . Dans .NET nous avons IPAddress . Dans .NET, vous avez même TryParse sur la IPAddress classe pour faire ce test pour vous! 

bool IsIP6(string addr) {
    IPAddress ip;
    if (IPAddress.TryParse(addr, out ip)) {
        return ip.AddressFamily == AddressFamily.InterNetworkV6;
    }
    else {
        return false;
    }
}
-1
répondu Frank Krueger 2008-09-10 06:10:46

Je n'ai pas pu obtenir la réponse de @Factor Mystic pour travailler avec des expressions régulières POSIX, donc j'en ai écrit une qui fonctionne avec des expressions régulières POSIX et des expressions régulières PERL.

Il faut le match:

IPv6 Expression Régulière: 

(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))

Pour en faciliter la lecture, voici la normale l'expression de split à de grands OU de points sur des lignes distinctes: 

# IPv6 RegEx
(
([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|          # 1:2:3:4:5:6:7:8
([0-9a-fA-F]{1,4}:){1,7}:|                         # 1::                              1:2:3:4:5:6:7::
([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|         # 1::8             1:2:3:4:5:6::8  1:2:3:4:5:6::8
([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|  # 1::7:8           1:2:3:4:5::7:8  1:2:3:4:5::8
([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|  # 1::6:7:8         1:2:3:4::6:7:8  1:2:3:4::8
([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|  # 1::5:6:7:8       1:2:3::5:6:7:8  1:2:3::8
([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|  # 1::4:5:6:7:8     1:2::4:5:6:7:8  1:2::8
[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|       # 1::3:4:5:6:7:8   1::3:4:5:6:7:8  1::8  
:((:[0-9a-fA-F]{1,4}){1,7}|:)|                     # ::2:3:4:5:6:7:8  ::2:3:4:5:6:7:8 ::8       ::     
fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|     # fe80::7:8%eth0   fe80::7:8%1     (link-local IPv6 addresses with zone index)
::(ffff(:0{1,4}){0,1}:){0,1}
((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}
(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|          # ::255.255.255.255   ::ffff:255.255.255.255  ::ffff:0:255.255.255.255  (IPv4-mapped IPv6 addresses and IPv4-translated addresses)
([0-9a-fA-F]{1,4}:){1,4}:
((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}
(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])           # 2001:db8:3:4::192.0.2.33  64:ff9b::192.0.2.33 (IPv4-Embedded IPv6 Address)
)

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

pour faciliter la compréhension de ce qui précède, le" pseudo "code suivant reproduit ce qui précède: 

IPV4SEG  = (25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])
IPV4ADDR = (IPV4SEG\.){3,3}IPV4SEG
IPV6SEG  = [0-9a-fA-F]{1,4}
IPV6ADDR = (
           (IPV6SEG:){7,7}IPV6SEG|                # 1:2:3:4:5:6:7:8
           (IPV6SEG:){1,7}:|                      # 1::                                 1:2:3:4:5:6:7::
           (IPV6SEG:){1,6}:IPV6SEG|               # 1::8               1:2:3:4:5:6::8   1:2:3:4:5:6::8
           (IPV6SEG:){1,5}(:IPV6SEG){1,2}|        # 1::7:8             1:2:3:4:5::7:8   1:2:3:4:5::8
           (IPV6SEG:){1,4}(:IPV6SEG){1,3}|        # 1::6:7:8           1:2:3:4::6:7:8   1:2:3:4::8
           (IPV6SEG:){1,3}(:IPV6SEG){1,4}|        # 1::5:6:7:8         1:2:3::5:6:7:8   1:2:3::8
           (IPV6SEG:){1,2}(:IPV6SEG){1,5}|        # 1::4:5:6:7:8       1:2::4:5:6:7:8   1:2::8
           IPV6SEG:((:IPV6SEG){1,6})|             # 1::3:4:5:6:7:8     1::3:4:5:6:7:8   1::8
           :((:IPV6SEG){1,7}|:)|                  # ::2:3:4:5:6:7:8    ::2:3:4:5:6:7:8  ::8       ::       
           fe80:(:IPV6SEG){0,4}%[0-9a-zA-Z]{1,}|  # fe80::7:8%eth0     fe80::7:8%1  (link-local IPv6 addresses with zone index)
           ::(ffff(:0{1,4}){0,1}:){0,1}IPV4ADDR|  # ::255.255.255.255  ::ffff:255.255.255.255  ::ffff:0:255.255.255.255 (IPv4-mapped IPv6 addresses and IPv4-translated addresses)
           (IPV6SEG:){1,4}:IPV4ADDR               # 2001:db8:3:4::192.0.2.33  64:ff9b::192.0.2.33 (IPv4-Embedded IPv6 Address)
           )

j'ai posté un script sur GitHub qui teste l'expression régulière: https://gist.github.com/syzdek/6086792

201
répondu David M. Syzdek 2017-11-19 13:18:03

ce qui suit validera les adresses IPv4, IPv6 (pleine et comprimée) et IPv6v4 (pleine et comprimée): 

'/^(?>(?>([a-f0-9]{1,4})(?>:(?1)){7}|(?!(?:.*[a-f0-9](?>:|$)){8,})((?1)(?>:(?1)){0,6})?::(?2)?)|(?>(?>(?1)(?>:(?1)){5}:|(?!(?:.*[a-f0-9]:){6,})(?3)?::(?>((?1)(?>:(?1)){0,4}):)?)?(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(?>\.(?4)){3}))$/iD'
47
répondu MichaelRushton 2012-12-04 16:19:51

From IPv6 regex ": 

(\A([0-9a-f]{1,4}:){1,1}(:[0-9a-f]{1,4}){1,6}\Z)|
(\A([0-9a-f]{1,4}:){1,2}(:[0-9a-f]{1,4}){1,5}\Z)|
(\A([0-9a-f]{1,4}:){1,3}(:[0-9a-f]{1,4}){1,4}\Z)|
(\A([0-9a-f]{1,4}:){1,4}(:[0-9a-f]{1,4}){1,3}\Z)|
(\A([0-9a-f]{1,4}:){1,5}(:[0-9a-f]{1,4}){1,2}\Z)|
(\A([0-9a-f]{1,4}:){1,6}(:[0-9a-f]{1,4}){1,1}\Z)|
(\A(([0-9a-f]{1,4}:){1,7}|:):\Z)|
(\A:(:[0-9a-f]{1,4}){1,7}\Z)|
(\A((([0-9a-f]{1,4}:){6})(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3})\Z)|
(\A(([0-9a-f]{1,4}:){5}[0-9a-f]{1,4}:(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3})\Z)|
(\A([0-9a-f]{1,4}:){5}:[0-9a-f]{1,4}:(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}\Z)|
(\A([0-9a-f]{1,4}:){1,1}(:[0-9a-f]{1,4}){1,4}:(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}\Z)|
(\A([0-9a-f]{1,4}:){1,2}(:[0-9a-f]{1,4}){1,3}:(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}\Z)|
(\A([0-9a-f]{1,4}:){1,3}(:[0-9a-f]{1,4}){1,2}:(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}\Z)|
(\A([0-9a-f]{1,4}:){1,4}(:[0-9a-f]{1,4}){1,1}:(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}\Z)|
(\A(([0-9a-f]{1,4}:){1,5}|:):(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}\Z)|
(\A:(:[0-9a-f]{1,4}){1,5}:(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}\Z)
23
répondu Factor Mystic 2016-03-07 17:10:25

on dirait que vous utilisez Python. Si c'est le cas, vous pouvez utiliser quelque chose comme ceci: 

import socket

def check_ipv6(n):
    try:
        socket.inet_pton(socket.AF_INET6, n)
        return True
    except socket.error:
        return False

print check_ipv6('::1') # True
print check_ipv6('foo') # False
print check_ipv6(5)     # TypeError exception
print check_ipv6(None)  # TypeError exception

Je ne pense pas que vous devez avoir IPv6 compilé en Python pour obtenir inet_pton , qui peut aussi analyser les adresses IPv4 si vous passez socket.AF_INET comme premier paramètre. Note: Ceci peut ne pas fonctionner sur les systèmes non-Unix.

19
répondu Joe Hildebrand 2016-03-07 17:06:48

je devrais appuyer fortement la réponse de Frank Krueger .

alors que vous dites que vous avez besoin d'une expression régulière pour correspondre à une adresse IPv6, je suppose que ce dont vous avez vraiment besoin est de pouvoir vérifier si une chaîne de caractères donnée est une adresse IPv6 valide. Il y a ici une distinction subtile mais importante.

Il y a plus d'une façon de vérifier si une chaîne donnée est une adresse IPv6 valide et d'expression régulière correspondant n'est qu'un solution.

utilisez une bibliothèque existante si vous le pouvez. La bibliothèque aura moins de bogues et son utilisation se traduira par moins de code à maintenir.

l'expression régulière suggérée par Factor Mystic est longue et complexe. Cela fonctionne très probablement, mais vous devriez également considérer comment vous feriez face si elle échoue de façon inattendue. Le point que j'essaie de faire ici est que si vous ne pouvez pas former une expression régulière nécessaire vous-même, vous ne serez pas en mesure pour résoudre facilement.

si vous n'avez pas de bibliothèque appropriée, il peut être préférable d'écrire votre propre routine de validation IPv6 qui ne dépend pas d'expressions régulières. Si vous écrivez que vous le comprenez et si vous le comprenez, vous pouvez ajouter des commentaires à l'expliquer pour que d'autres puissent aussi comprendre et à maintenir par la suite.

agir avec prudence lorsque vous utilisez une expression régulière dont vous ne pouvez pas expliquer les fonctionnalités à quelqu'un d'autre.

8
répondu Jon Cram 2008-09-10 07:55:04

cette expression régulière correspondra aux adresses IPv6 et IPv4 valides conformément à L'implémentation GNU C++ de regex avec le mode étendu régulier utilisé: 

"^\s*((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])){3}))|:))|(([0-9A-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])){3}))|:)))(%.+)?\s*$"
7
répondu janCoffee 2013-04-09 10:30:54

Je ne suis pas un expert Ipv6 mais je pense que vous pouvez obtenir un assez bon résultat plus facilement avec celui-ci: 

^([0-9A-Fa-f]{0,4}:){2,7}([0-9A-Fa-f]{1,4}$|((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\.|$)){4})$

répondre "est une ipv6 valide" ça ressemble ok pour moi. Pour le décomposer en parties... l'oublier. J'ai omis le non spécifié (::) puisqu'il n'y a aucune utilité d'avoir "une adresse non spécifiée" dans ma base de données.

le début: ^([0-9A-Fa-f]{0,4}:){2,7} <-- correspondre à la partie compressible, on peut traduire aussi: entre 2 et 7 du côlon qui peut avoir heaxadecimal nombre d'entre eux.

suivi de: [0-9A-Fa-f]{1,4}$ <-- un nombre hexadécimal (0 omis) OU ((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\.|$)){4} < -- an Ipv4 adresse

5
répondu Remi Morin 2013-02-19 15:18:27

attention! en Java, L'utilisation D'InetAddress et de classes associées (Inet4Address, INET6ADDRESS, URL) peut impliquer un trafic réseau! E. G. DNS resolving (URL.d'égal à égal, InetAddress de chaîne!). Cet appel peut être long et bloque!

pour IPv6 j'ai quelque chose comme ça. Bien sûr, cela ne gère pas les détails très subtils D'IPv6 comme le fait que les indices de zone ne sont autorisés que sur certaines classes D'adresses IPv6. Et cette expression n'est pas écrit pour capture de groupe, ce n'est qu'une sorte de regexp "correspond".

S - segment IPv6 = [0-9a-f]{1,4}

I - IPv4 = (?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9]{1,2})\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9]{1,2})

Schématique (première partie correspond à des adresses IPv6 en IPv4 suffixe, deuxième partie correspond à des adresses IPv6, dernier patrt la zone d'index): 

(
(
::(S:){0,5}|
S::(S:){0,4}|
(S:){2}:(S:){0,3}|
(S:){3}:(S:){0,2}|
(S:){4}:(S:)?|
(S:){5}:|
(S:){6}
)
I

|

:(:|(:S){1,7})|
S:(:|(:S){1,6})|
(S:){2}(:|(:S){1,5})|
(S:){3}(:|(:S){1,4})|
(S:){4}(:|(:S){1,3})|
(S:){5}(:|(:S){1,2})|
(S:){6}(:|(:S))|
(S:){7}:|
(S:){7}S
)

(?:%[0-9a-z]+)?

et ici le Regex de puissance (cas insensible, entourer de ce qui jamais nécessaire comme début / fin de ligne, etc.): 

(?:
(?:
::(?:[0-9a-f]{1,4}:){0,5}|
[0-9a-f]{1,4}::(?:[0-9a-f]{1,4}:){0,4}|
(?:[0-9a-f]{1,4}:){2}:(?:[0-9a-f]{1,4}:){0,3}|
(?:[0-9a-f]{1,4}:){3}:(?:[0-9a-f]{1,4}:){0,2}|
(?:[0-9a-f]{1,4}:){4}:(?:[0-9a-f]{1,4}:)?|
(?:[0-9a-f]{1,4}:){5}:|
(?:[0-9a-f]{1,4}:){6}
)
(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9]{1,2})\.){3}
(?:25[0-5]|2[0-4][0-9]|[01]?[0-9]{1,2})|

:(?::|(?::[0-9a-f]{1,4}){1,7})|
[0-9a-f]{1,4}:(?::|(?::[0-9a-f]{1,4}){1,6})|
(?:[0-9a-f]{1,4}:){2}(?::|(?::[0-9a-f]{1,4}){1,5})|
(?:[0-9a-f]{1,4}:){3}(?::|(?::[0-9a-f]{1,4}){1,4})|
(?:[0-9a-f]{1,4}:){4}(?::|(?::[0-9a-f]{1,4}){1,3})|
(?:[0-9a-f]{1,4}:){5}(?::|(?::[0-9a-f]{1,4}){1,2})|
(?:[0-9a-f]{1,4}:){6}(?::|(?::[0-9a-f]{1,4}))|
(?:[0-9a-f]{1,4}:){7}:|
(?:[0-9a-f]{1,4}:){7}[0-9a-f]{1,4}
)

(?:%[0-9a-z]+)?
4
répondu user2623580 2013-07-27 07:57:01

si vous utilisez Perl try Net:: IPv6Addr 

use Net::IPv6Addr;

if( defined Net::IPv6Addr::is_ipv6($ip_address) ){
  print "Looks like an ipv6 address\n";
}

NetAddr:: IP 

use NetAddr::IP;

my $obj = NetAddr::IP->new6($ip_address);

Valider::IP 

use Validate::IP qw'is_ipv6';

if( is_ipv6($ip_address) ){
  print "Looks like an ipv6 address\n";
}
3
répondu Brad Gilbert 2013-09-24 23:32:20

cela capte le loopback (: 1) ainsi que les adresses ipv6. changé {} à + et mis: à l'intérieur du premier crochet. 

([A-f0-9:]+:+)+[A-f0-9]+

testé avec la sortie ifconfig-a http://regexr.com /

L'option

Unix ou Mac OSX terminal o renvoie uniquement la sortie correspondante(ipv6) incluant:: 1 

ifconfig -a | egrep -o '([A-f0-9:]+:+)+[A-f0-9]+'

Obtenir Toutes les adresses IP (IPv4 OU IPv6) et l'impression match sur unix OSx terme 

ifconfig -a | egrep -o '([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}) | (([A-f0-9:]+:+)+[A-f0-9]+)'
3
répondu Rohit Malgaonkar 2016-05-20 21:01:46

dans Scala utilisez les validateurs Apache Commons bien connus.

http://mvnrepository.com/artifact/commons-validator/commons-validator/1.4.1 

libraryDependencies += "commons-validator" % "commons-validator" % "1.4.1"


import org.apache.commons.validator.routines._

/**
 * Validates if the passed ip is a valid IPv4 or IPv6 address.
 *
 * @param ip The IP address to validate.
 * @return True if the passed IP address is valid, false otherwise.
 */  
 def ip(ip: String) = InetAddressValidator.getInstance().isValid(ip)

suivant les essais de la méthode ip(ip: String) : 

"The `ip` validator" should {
  "return false if the IPv4 is invalid" in {
    ip("123") must beFalse
    ip("255.255.255.256") must beFalse
    ip("127.1") must beFalse
    ip("30.168.1.255.1") must beFalse
    ip("-1.2.3.4") must beFalse
  }

  "return true if the IPv4 is valid" in {
    ip("255.255.255.255") must beTrue
    ip("127.0.0.1") must beTrue
    ip("0.0.0.0") must beTrue
  }

  //IPv6
  //@see: http://www.ronnutter.com/ipv6-cheatsheet-on-identifying-valid-ipv6-addresses/
  "return false if the IPv6 is invalid" in {
    ip("1200::AB00:1234::2552:7777:1313") must beFalse
  }

  "return true if the IPv6 is valid" in {
    ip("1200:0000:AB00:1234:0000:2552:7777:1313") must beTrue
    ip("21DA:D3:0:2F3B:2AA:FF:FE28:9C5A") must beTrue
  }
}
2
répondu OliverKK 2016-03-07 17:01:00

un regex simple qui va correspondre, mais je ne recommanderais pas pour la validation de n'importe quelle sorte est ceci: 

([A-Fa-f0-9]{1,4}::?){1,7}[A-Fa-f0-9]{1,4}

notez que cela correspond à une compression n'importe où dans l'adresse, bien qu'elle ne corresponde pas à l'adresse de boucle ::1. Je trouve que c'est un compromis raisonnable afin de garder l'expression régulière simple.

Je l'utilise avec succès dans itérm2 règles de sélection intelligentes Pour quad-click adresses IPv6.

1
répondu JinnKo 2013-07-26 08:21:33

il est difficile de trouver une expression régulière qui fonctionne pour tous les cas IPv6. Ils sont généralement difficiles à entretenir, difficilement lisibles et peuvent causer des problèmes de performance. Par conséquent, je veux partager une solution alternative que j'ai développé: Expression régulière (RegEx) pour IPv6 séparé de IPv4

Maintenant vous pouvez demander que "cette méthode ne trouve IPv6, Comment puis-je trouver IPv6 dans un texte ou un fichier?"Voici des méthodes pour cette question aussi.

Note : si vous ne voulez pas utiliser la classe IPAddress dans .NET, vous pouvez également la remplacer par ma méthode . Il couvre également IPv4 cartographié et les cas spéciaux aussi, tandis que IPAddress ne couvre pas. 

class IPv6
{
    public List<string> FindIPv6InFile(string filePath)
    {
        Char ch;
        StringBuilder sbIPv6 = new StringBuilder();
        List<string> listIPv6 = new List<string>();
        StreamReader reader = new StreamReader(filePath);
        do
        {
            bool hasColon = false;
            int length = 0;

            do
            {
                ch = (char)reader.Read();

                if (IsEscapeChar(ch))
                    break;

                //Check the first 5 chars, if it has colon, then continue appending to stringbuilder
                if (!hasColon && length < 5)
                {
                    if (ch == ':')
                    {
                        hasColon = true;
                    }
                    sbIPv6.Append(ch.ToString());
                }
                else if (hasColon) //if no colon in first 5 chars, then dont append to stringbuilder
                {
                    sbIPv6.Append(ch.ToString());
                }

                length++;

            } while (!reader.EndOfStream);

            if (hasColon && !listIPv6.Contains(sbIPv6.ToString()) && IsIPv6(sbIPv6.ToString()))
            {
                listIPv6.Add(sbIPv6.ToString());
            }

            sbIPv6.Clear();

        } while (!reader.EndOfStream);
        reader.Close();
        reader.Dispose();

        return listIPv6;
    }

    public List<string> FindIPv6InText(string text)
    {
        StringBuilder sbIPv6 = new StringBuilder();
        List<string> listIPv6 = new List<string>();

        for (int i = 0; i < text.Length; i++)
        {
            bool hasColon = false;
            int length = 0;

            do
            {
                if (IsEscapeChar(text[length + i]))
                    break;

                //Check the first 5 chars, if it has colon, then continue appending to stringbuilder
                if (!hasColon && length < 5)
                {
                    if (text[length + i] == ':')
                    {
                        hasColon = true;
                    }
                    sbIPv6.Append(text[length + i].ToString());
                }
                else if (hasColon) //if no colon in first 5 chars, then dont append to stringbuilder
                {
                    sbIPv6.Append(text[length + i].ToString());
                }

                length++;

            } while (i + length != text.Length);

            if (hasColon && !listIPv6.Contains(sbIPv6.ToString()) && IsIPv6(sbIPv6.ToString()))
            {
                listIPv6.Add(sbIPv6.ToString());
            }

            i += length;
            sbIPv6.Clear();
        }

        return listIPv6;
    }

    bool IsEscapeChar(char ch)
    {
        if (ch != ' ' && ch != '\r' && ch != '\n' && ch!='\t')
        {
            return false;
        }

        return true;
    }

    bool IsIPv6(string maybeIPv6)
    {
        IPAddress ip;
        if (IPAddress.TryParse(maybeIPv6, out ip))
        {
            return ip.AddressFamily == AddressFamily.InterNetworkV6;
        }
        else
        {
            return false;
        }
    }

}
1
répondu Nuh Metin Güler 2017-05-23 12:26:33

en regardant les modèles inclus dans les autres réponses il y a un certain nombre de bons modèles qui peuvent être améliorés en référençant des groupes et en utilisant des têtes de recherche. Voici un exemple d'un modèle qui est auto-référencement que j'utiliserais en PHP si je devais: 

^(?<hgroup>(?<hex>[[:xdigit:]]{0,4}) # grab a sequence of up to 4 hex digits
                                     # and name this pattern for usage later
     (?<!:::):{1,2})                 # match 1 or 2 ':' characters
                                     # as long as we can't match 3
 (?&hgroup){1,6} # match our hex group 1 to 6 more times
 (?:(?:
    # match an ipv4 address or
    (?<dgroup>2[0-5]|(?:2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3}(?&dgroup)
    # match our hex group one last time
    |(?&hex))$

Note: PHP a un filtre intégré pour cela qui serait une meilleure solution que celle-ci modèle.

Analyse Regex101

1
répondu Steve Buzonas 2016-03-07 17:04:37

Avec Ruby? Essayez ceci: 

/^(((?=.*(::))(?!.*.+))?|[\dA-F]{1,4}:)([\dA-F]{1,4}(|:\b)|){5}(([\dA-F]{1,4}(|:\b|$)|){2}|(((2[0-4]|1\d|[1-9])?\d|25[0-5])\.?\b){4})\z/i
1
répondu Ahamx 2016-03-07 17:09:05

selon vos besoins, une approximation comme: 

[0-9a-f:]+

peut suffire (comme dans le cas d'un simple grapping de fichier journal, par exemple).)

1
répondu Bill Lipa 2016-08-30 21:42:54

suivant regex est pour IPv6 seulement. Le groupe 1 correspond à L'IP. 

(([0-9a-fA-F]{0,4}:){1,7}[0-9a-fA-F]{0,4})
1
répondu Jitendra Gosavi 2018-05-17 07:12:18

en Java, vous pouvez utiliser la classe de bibliothèque sun.net.util.IPAddressUtil : 

IPAddressUtil.isIPv6LiteralAddress(iPaddress);
0
répondu user463639 2012-06-05 20:47:47

Pour PHP 5.2+ utilisateurs filter_var fonctionne à merveille.

je sais que cela ne répond pas à la question originale (spécifiquement une solution regex), mais je poste ceci dans l'espoir qu'il puisse aider quelqu'un d'autre dans le futur. 

$is_ip4address = (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4) !== FALSE);
$is_ip6address = (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6) !== FALSE);
0
répondu Wireblue 2013-11-18 22:50:47

cela fonctionnera pour IPv4 et IPv6: 

^(([0-9a-f]{0,4}:){1,7}[0-9a-f]{1,4}|([0-9]{1,3}\.){3}[0-9]{1,3})$
0
répondu Chris 2016-03-07 16:43:54

InetAddressUtils a tous les motifs définis. J'ai fini par utiliser leur motif directement, et je le colle ici pour référence: 

private static final String IPV4_BASIC_PATTERN_STRING =
        "(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}" + // initial 3 fields, 0-255 followed by .
         "([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])"; // final field, 0-255

private static final Pattern IPV4_PATTERN =
    Pattern.compile("^" + IPV4_BASIC_PATTERN_STRING + "$");

private static final Pattern IPV4_MAPPED_IPV6_PATTERN = // TODO does not allow for redundant leading zeros
        Pattern.compile("^::[fF]{4}:" + IPV4_BASIC_PATTERN_STRING + "$");

private static final Pattern IPV6_STD_PATTERN =
    Pattern.compile(
            "^[0-9a-fA-F]{1,4}(:[0-9a-fA-F]{1,4}){7}$");

private static final Pattern IPV6_HEX_COMPRESSED_PATTERN =
    Pattern.compile(
            "^(([0-9A-Fa-f]{1,4}(:[0-9A-Fa-f]{1,4}){0,5})?)" + // 0-6 hex fields
             "::" +
             "(([0-9A-Fa-f]{1,4}(:[0-9A-Fa-f]{1,4}){0,5})?)$"); // 0-6 hex fields
0
répondu user4604205 2016-03-07 17:01:51

voilà ce que j'ai trouvé, en utilisant un peu de lookahead et des groupes nommés. C'est bien sûr juste IPv6, mais il ne devrait pas interférer avec des modèles supplémentaires si vous voulez ajouter IPv4: 

(?=([0-9a-f]+(:[0-9a-f])*)?(?P<wild>::)(?!([0-9a-f]+:)*:))(::)?([0-9a-f]{1,4}:{1,2}){0,6}(?(wild)[0-9a-f]{0,4}|[0-9a-f]{1,4}:[0-9a-f]{1,4})
0
répondu user1977022 2016-03-07 17:03:52

vous pouvez utiliser the ipextract shell tools j'ai fait à cet effet. Ils sont basés sur regexp et grep.

Utilisation: 

$ ifconfig | ipextract6
fe80::1%lo0
::1
fe80::7ed1:c3ff:feec:dee1%en0
0
répondu Phil L. 2016-03-07 17:05:30

j'ai généré ce qui suit en utilisant python et fonctionne avec le module re. Les assertions prospectives permettent de s'assurer que le nombre exact de points ou de colonnes apparaît dans l'adresse. Il ne supporte pas IPv4 en notation IPv6. 

pattern = '^(?=\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$)(?:(?:25[0-5]|[12][0-4][0-9]|1[5-9][0-9]|[1-9]?[0-9])\.?){4}$|(?=^(?:[0-9a-f]{0,4}:){2,7}[0-9a-f]{0,4}$)(?![^:]*::.+::[^:]*$)(?:(?=.*::.*)|(?=\w+:\w+:\w+:\w+:\w+:\w+:\w+:\w+))(?:(?:^|:)(?:[0-9a-f]{4}|[1-9a-f][0-9a-f]{0,3})){0,8}(?:::(?:[0-9a-f]{1,4}(?:$|:)){0,6})?$'
result = re.match(pattern, ip)
if result: result.group(0)
0
répondu Mike Wilmes 2016-10-03 22:20:52

correspond à ceux d'une origine locale avec des crochets inclus. Je sais que ce n'est pas aussi complet mais en javascript les autres ont eu des problèmes difficiles à tracer principalement celui de ne pas travailler, donc cela semble m'obtenir ce dont j'avais besoin pour le moment. les majuscules A-F supplémentaires ne sont pas nécessaires non plus. 

^\[([0-9a-fA-F]{1,4})(\:{1,2})([0-9a-fA-F]{1,4})(\:{1,2})([0-9a-fA-F]{1,4})(\:{1,2})([0-9a-fA-F]{1,4})(\:{1,2})([0-9a-fA-F]{1,4})\]

la version de Jinnko est simplifiée et meilleure je vois.

0
répondu Master James 2017-04-09 13:33:38

comme indiqué ci-dessus, une autre façon d'obtenir une représentation textuelle IPv6 valider parser est d'utiliser la programmation. En voici un qui est entièrement conforme aux RFC-4291 et RFC-5952. J'ai écrit ce code dans ANSI C (fonctionne avec GCC, a passé des tests sur Linux - fonctionne avec clang, a passé des tests sur FreeBSD). Ainsi, il ne s'appuie que sur la bibliothèque standard ANSI C, donc il peut être compilé partout (je l'ai utilisé pour l'analyse IPv6 à l'intérieur d'un module du noyau avec FreeBSD). 

// IPv6 textual representation validating parser fully compliant with RFC-4291 and RFC-5952
// BSD-licensed / Copyright 2015-2017 Alexandre Fenyo

#include <string.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>

typedef enum { false, true } bool;

static const char hexdigits[] = "0123456789abcdef";
static int digit2int(const char digit) {
  return strchr(hexdigits, digit) - hexdigits;
}

// This IPv6 address parser handles any valid textual representation according to RFC-4291 and RFC-5952.
// Other representations will return -1.
//
// note that str input parameter has been modified when the function call returns
//
// parse_ipv6(char *str, struct in6_addr *retaddr)
// parse textual representation of IPv6 addresses
// str:     input arg
// retaddr: output arg
int parse_ipv6(char *str, struct in6_addr *retaddr) {
  bool compressed_field_found = false;
  unsigned char *_retaddr = (unsigned char *) retaddr;
  char *_str = str;
  char *delim;

  bzero((void *) retaddr, sizeof(struct in6_addr));
  if (!strlen(str) || strchr(str, ':') == NULL || (str[0] == ':' && str[1] != ':') ||
      (strlen(str) >= 2 && str[strlen(str) - 1] == ':' && str[strlen(str) - 2] != ':')) return -1;

  // convert transitional to standard textual representation
  if (strchr(str, '.')) {
    int ipv4bytes[4];
    char *curp = strrchr(str, ':');
    if (curp == NULL) return -1;
    char *_curp = ++curp;
    int i;
    for (i = 0; i < 4; i++) {
      char *nextsep = strchr(_curp, '.');
      if (_curp[0] == '0' || (i < 3 && nextsep == NULL) || (i == 3 && nextsep != NULL)) return -1;
      if (nextsep != NULL) *nextsep = 0;
      int j;
      for (j = 0; j < strlen(_curp); j++) if (_curp[j] < '0' || _curp[j] > '9') return -1;
      if (strlen(_curp) > 3) return -1;
      const long val = strtol(_curp, NULL, 10);
      if (val < 0 || val > 255) return -1;
      ipv4bytes[i] = val;
      _curp = nextsep + 1;
    }
    sprintf(curp, "%x%02x:%x%02x", ipv4bytes[0], ipv4bytes[1], ipv4bytes[2], ipv4bytes[3]);
  }

  // parse standard textual representation
  do {
    if ((delim = strchr(_str, ':')) == _str || (delim == NULL && !strlen(_str))) {
      if (delim == str) _str++;
      else if (delim == NULL) return 0;
      else {
        if (compressed_field_found == true) return -1;
        if (delim == str + strlen(str) - 1 && _retaddr != (unsigned char *) (retaddr + 1)) return 0;
        compressed_field_found = true;
        _str++;
        int cnt = 0;
        char *__str;
        for (__str = _str; *__str; ) if (*(__str++) == ':') cnt++;
        unsigned char *__retaddr = - 2 * ++cnt + (unsigned char *) (retaddr + 1);
        if (__retaddr <= _retaddr) return -1;
        _retaddr = __retaddr;
      }
    } else {
      char hexnum[4] = "0000";
      if (delim == NULL) delim = str + strlen(str);
      if (delim - _str > 4) return -1;
      int i;
      for (i = 0; i < delim - _str; i++)
        if (!isxdigit(_str[i])) return -1;
        else hexnum[4 - (delim - _str) + i] = tolower(_str[i]);
      _str = delim + 1;
      *(_retaddr++) = (digit2int(hexnum[0]) << 4) + digit2int(hexnum[1]);
      *(_retaddr++) = (digit2int(hexnum[2]) << 4) + digit2int(hexnum[3]);
    }
  } while (_str < str + strlen(str));
  return 0;
}
0
répondu Alexandre Fenyo 2017-07-24 00:41:33

les Regexes pour ipv6 peuvent devenir vraiment difficiles lorsque vous considérez les adresses avec ipv4 intégré et les adresses qui sont compressées, comme vous pouvez le voir à partir de certaines de ces réponses.

la bibliothèque open-source D'IPAddress Java va valider toutes les représentations standard D'IPv6 et IPv4 et prend également en charge la longueur du préfixe (et sa validation). Avertissement: je suis le chef de projet de la bibliothèque.

exemple de Code: 

        try {
            IPAddressString str = new IPAddressString("::1");
            IPAddress addr = str.toAddress();
            if(addr.isIPv6() || addr.isIPv6Convertible()) {
                IPv6Address ipv6Addr = addr.toIPv6();
            }
            //use address
        } catch(AddressStringException e) {
            //e.getMessage has validation error
        }
0
répondu Sean F 2017-12-18 02:06:01

essayez cette petite doublure. Il ne doit correspondre qu'aux adresses IPv6 non compressées/compressées valides (pas d'hybrides IPv4) 

/(?!.*::.*::)(?!.*:::.*)(?!:[a-f0-9])((([a-f0-9]{1,4})?[:](?!:)){7}|(?=(.*:[:a-f0-9]{1,4}::|^([:a-f0-9]{1,4})?::))(([a-f0-9]{1,4})?[:]{1,2}){1,6})[a-f0-9]{1,4}/
-1
répondu Carlos Velazquez 2016-10-13 09:46:34

le regex permet l'utilisation de zéros de tête dans les pièces IPv4.

certains Unix et Mac distros convertissent ces segments en octals.

je suggère d'utiliser 25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d comme segment IPv4.

-2
répondu Aeron 2011-11-09 18:04:33