Biểu thức chính quy khớp với địa chỉ IPv6 hợp lệ

Tôi đang gặp sự cố khi viết một biểu thức chính quy khớp với các địa chỉ IPv6 hợp lệ, bao gồm cả những địa chỉ ở dạng nén của chúng (với ::hoặc số không ở đầu bị bỏ qua khỏi mỗi cặp byte).

Ai đó có thể đề xuất một biểu thức chính quy sẽ đáp ứng yêu cầu không?

Tôi đang xem xét việc mở rộng từng cặp byte và khớp kết quả với một regex đơn giản hơn.

Tôi không thể nhận được câu trả lời của @Factor Mystic để hoạt động với biểu thức chính quy POSIX, vì vậy tôi đã viết một câu trả lời hoạt động với biểu thức chính quy POSIX và biểu thức chính quy PERL.

Nó phải phù hợp với:

• Địa chỉ IPv6
• không có địa chỉ IPv6 được nén ( phần 2.2 của rfc5952 )
• địa chỉ IPv6 liên kết cục bộ với chỉ mục vùng ( phần 11 của rfc4007 )
• Địa chỉ IPv6 nhúng IPv4 ( phần 2 của rfc6052 )
• Địa chỉ IPv6 được ánh xạ IPv4 ( phần 2.1 của rfc2765 )
• Địa chỉ được dịch qua IPv4 ( phần 2.1 của rfc2765 )

Biểu thức IPv6 Thông thường:

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

Để dễ đọc, sau đây là phần chia biểu thức chính quy ở trên tại các điểm OR chính thành các dòng riêng biệt:

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

Để làm cho phần trên dễ hiểu hơn, mã "giả" sau đây sao chép phần trên:

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

Tôi đã đăng một tập lệnh trên GitHub để kiểm tra biểu thức chính quy: https://gist.github.com/syzdek/6086792

Phần sau sẽ xác thực địa chỉ IPv4, IPv6 (đầy đủ và nén) và IPv6v4 (đầy đủ và nén):

'/^(?>(?>([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'

Có vẻ như bạn đang sử dụng Python. Nếu vậy, bạn có thể sử dụng một cái gì đó như sau:

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

Tôi không nghĩ rằng bạn phải có IPv6 được biên dịch sang Python để có được inet_pton, điều này cũng có thể phân tích cú pháp địa chỉ IPv4 nếu bạn chuyển vào socket.AF_INETlàm tham số đầu tiên. Lưu ý: điều này có thể không hoạt động trên các hệ thống không phải Unix.

Từ " 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)

Tôi phải chấp nhận mạnh mẽ câu trả lời từ Frank Krueger .

Trong khi bạn nói rằng bạn cần một biểu thức chính quy để khớp với địa chỉ IPv6, tôi cho rằng điều bạn thực sự cần là có thể kiểm tra xem một chuỗi đã cho có phải là địa chỉ IPv6 hợp lệ hay không. Có một sự khác biệt tinh tế nhưng quan trọng ở đây.

Có nhiều cách để kiểm tra xem một chuỗi đã cho có phải là địa chỉ IPv6 hợp lệ hay không và đối sánh biểu thức chính quy chỉ là một giải pháp.

Sử dụng thư viện hiện có nếu bạn có thể. Thư viện sẽ có ít lỗi hơn và việc sử dụng nó sẽ dẫn đến việc bạn phải duy trì ít mã hơn.

Biểu thức chính quy được đề xuất bởi Factor Mystic là dài và phức tạp. Nó rất có thể hoạt động, nhưng bạn cũng nên xem xét cách bạn đối phó nếu nó bất ngờ thất bại. Điểm tôi đang cố gắng đưa ra ở đây là nếu bạn không thể tự mình tạo biểu thức chính quy bắt buộc, bạn sẽ không thể dễ dàng gỡ lỗi nó.

Nếu bạn không có thư viện phù hợp, tốt hơn là bạn nên viết quy trình xác thực IPv6 của riêng mình mà không phụ thuộc vào biểu thức chính quy. Nếu bạn viết nó, bạn hiểu nó và nếu bạn hiểu nó, bạn có thể thêm nhận xét để giải thích nó để những người khác cũng có thể hiểu và sau đó duy trì nó.

Hãy thận trọng khi sử dụng biểu thức chính quy có chức năng mà bạn không thể giải thích cho người khác.

Tôi không phải là chuyên gia Ipv6 nhưng tôi nghĩ bạn có thể có được kết quả khá tốt dễ dàng hơn với kết quả này:

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

để trả lời "là một ipv6 hợp lệ" nó trông giống như ok đối với tôi. Để chia nhỏ nó thành nhiều phần ... hãy quên nó đi. Tôi đã bỏ qua địa chỉ không xác định (: :) vì không sử dụng "địa chỉ không xác định" trong cơ sở dữ liệu của tôi.

phần đầu: ^([0-9A-Fa-f]{0,4}:){2,7}<- khớp với phần có thể nén được, chúng ta có thể dịch điều này là: từ 2 đến 7 dấu hai chấm có thể có số thập phân giữa chúng.

theo sau là: [0-9A-Fa-f]{1,4}$<- một số thập lục phân (bỏ qua số 0 ở đầu) HOẶC ((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\.|$)){4}<- một địa chỉ Ipv4

Điều này cũng bắt các địa chỉ loopback (:: 1) và ipv6. đã thay đổi {} thành + và đặt: bên trong dấu ngoặc vuông đầu tiên.

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

đã thử nghiệm với đầu ra ifconfig -a http://regexr.com/

Tùy chọn o tùy chọn đầu cuối Unix hoặc Mac OSx chỉ trả về đầu ra phù hợp (ipv6) bao gồm :: 1

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

Nhận Tất cả địa chỉ IP (IPv4 HOẶC IPv6) và in khớp trên thuật ngữ OSx unix

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

Biểu thức chính quy này sẽ khớp với các địa chỉ IPv6 và IPv4 hợp lệ phù hợp với việc triển khai GNU C ++ của regex với chế độ MỞ RỘNG THƯỜNG XUYÊN được sử dụng:

"^\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*$"

Hãy coi chừng! Trong Java, việc sử dụng InetAddress và các lớp liên quan (Inet4Address, Inet6Address, URL) có thể liên quan đến trafic mạng! Ví dụ: phân giải DNS (URL.equals, InetAddress từ chuỗi!). Cuộc gọi này có thể mất nhiều thời gian và đang bị chặn!

Đối với IPv6, tôi có một cái gì đó như thế này. Tất nhiên, điều này không xử lý các chi tiết rất tinh vi của IPv6 như chỉ số vùng chỉ được phép trên một số lớp địa chỉ IPv6. Và regex này không được viết để chụp theo nhóm, nó chỉ là một loại regexp "khớp".

S - Phân đoạn 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})

Sơ đồ (phần đầu đối sánh địa chỉ IPv6 với hậu tố IPv4, phần thứ hai khớp với địa chỉ IPv6, phần cuối là chỉ mục vùng):

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

Và đây có thể là regex (không phân biệt chữ hoa chữ thường, bao quanh những thứ cần thiết như đầu / cuối dòng, v.v.):

(?:
(?:
::(?:[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]+)?

Sau regex chỉ dành cho IPv6. Nhóm 1 đấu với IP.

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

Một regex đơn giản sẽ phù hợp, nhưng tôi không khuyên bạn nên xác thực theo bất kỳ loại nào là:

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

Lưu ý rằng điều này phù hợp với nén ở bất kỳ đâu trong địa chỉ, mặc dù nó sẽ không khớp với địa chỉ lặp lại :: 1. Tôi thấy đây là một thỏa hiệp hợp lý để giữ cho regex đơn giản.

Tôi sử dụng thành công điều này trong các quy tắc lựa chọn thông minh iTerm2 để nhấp bốn lần vào địa chỉ IPv6.

Nếu bạn sử dụng Perl, hãy thử 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);

Xác thực :: IP

use Validate::IP qw'is_ipv6';

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

Trong Scala, sử dụng trình xác nhận Apache Commons nổi tiếng.

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)

Sau thử nghiệm của phương pháp 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
  }
}

Nhìn vào các mẫu có trong các câu trả lời khác, có một số mẫu hay có thể được cải thiện bằng cách tham khảo các nhóm và sử dụng các lookahead. Đây là một ví dụ về một mẫu tự tham chiếu mà tôi sẽ sử dụng trong PHP nếu tôi phải:

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

Lưu ý: PHP có một bộ lọc tích hợp cho điều này sẽ là một giải pháp tốt hơn mẫu này.

Phân tích Regex101

Tôi đã tạo phần sau bằng python và hoạt động với mô-đun re. Các xác nhận nhìn về phía trước đảm bảo rằng số lượng dấu chấm hoặc dấu hai chấm chính xác xuất hiện trong địa chỉ. Nó không hỗ trợ IPv4 trong ký hiệu 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)

Regexes cho ipv6 có thể thực sự khó khăn khi bạn xem xét các địa chỉ có ipv4 nhúng và các địa chỉ được nén, như bạn có thể thấy từ một số câu trả lời sau.

Thư viện IPAddress Java mã nguồn mở sẽ xác thực tất cả các biểu diễn tiêu chuẩn của IPv6 và IPv4 và cũng hỗ trợ độ dài tiền tố (và xác thực như vậy). Tuyên bố từ chối trách nhiệm: Tôi là người quản lý dự án của thư viện đó.

Ví dụ về mã:

        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
        }

Trong Java, bạn có thể sử dụng lớp thư viện sun.net.util.IPAddressUtil:

IPAddressUtil.isIPv6LiteralAddress(iPaddress);

Rất khó để tìm thấy một biểu thức chính quy hoạt động cho tất cả các trường hợp IPv6. Chúng thường khó bảo trì, không dễ đọc và có thể gây ra các vấn đề về hiệu suất. Do đó, tôi muốn chia sẻ một giải pháp thay thế mà tôi đã phát triển: Biểu thức chính quy (RegEx) cho IPv6 Tách biệt khỏi IPv4

Bây giờ bạn có thể hỏi rằng "Phương pháp này chỉ tìm thấy IPv6, làm thế nào tôi có thể tìm thấy IPv6 trong văn bản hoặc tệp?" Dưới đây là các phương pháp cho vấn đề này.

Lưu ý : Nếu bạn không muốn sử dụng lớp IPAddress trong .NET, bạn cũng có thể thay thế nó bằng phương thức của tôi . Nó cũng bao gồm IPv4 được ánh xạ và các trường hợp đặc biệt, trong khi IPAddress không bao gồm.

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

}

InetAddressUtilsđã xác định tất cả các mẫu. Tôi đã kết thúc bằng cách sử dụng trực tiếp mẫu của họ và đang dán nó ở đây để tham khảo:

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 

Sử dụng Ruby? Thử cái này:

/^(((?=.*(::))(?!.*\3.+\3))\3?|[\dA-F]{1,4}:)([\dA-F]{1,4}(\3|:\b)|\2){5}(([\dA-F]{1,4}(\3|:\b|$)|\2){2}|(((2[0-4]|1\d|[1-9])?\d|25[0-5])\.?\b){4})\z/i

Tùy thuộc vào nhu cầu của bạn, ước tính như:

[0-9a-f:]+

có thể là đủ (ví dụ như với việc thu thập tệp nhật ký đơn giản.)

Đối với người dùng PHP 5.2+ filter_varhoạt động tốt.

Tôi biết điều này không trả lời câu hỏi ban đầu (cụ thể là một giải pháp regex), nhưng tôi đăng bài này với hy vọng nó có thể giúp ích cho người khác trong tương lai.

$is_ip4address = (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4) !== FALSE);
$is_ip6address = (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6) !== FALSE);

Điều này sẽ hoạt động cho IPv4 và IPv6:

^(([0-9a-f]{0,4}:){1,7}[0-9a-f]{1,4}|([0-9]{1,3}\.){3}[0-9]{1,3})$

Đây là những gì tôi đã nghĩ ra, sử dụng một chút tìm kiếm và các nhóm được đặt tên. Tất nhiên đây chỉ là IPv6, nhưng nó sẽ không ảnh hưởng đến các mẫu bổ sung nếu bạn muốn thêm 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})

Bạn có thể sử dụng các công cụ shell ipextract mà tôi đã tạo cho mục đích này. Chúng dựa trên regexp và grep.

Sử dụng:

$ ifconfig | ipextract6
fe80::1%lo0
::1
fe80::7ed1:c3ff:feec:dee1%en0

Chỉ so khớp các từ địa phương từ một nguồn gốc có bao gồm dấu ngoặc vuông. Tôi biết nó không toàn diện nhưng trong javascript, những cái khác gặp khó khăn trong việc theo dõi các vấn đề chủ yếu là không hoạt động, vì vậy điều này dường như giúp tôi có được những gì tôi cần. AF viết hoa phụ cũng không cần thiết.

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

Phiên bản của Jinnko được đơn giản hóa và tôi thấy tốt hơn.

Như đã nêu ở trên, một cách khác để có được trình phân tích cú pháp xác thực biểu diễn văn bản IPv6 là sử dụng lập trình. Đây là một trong những hoàn toàn phù hợp với RFC-4291 và RFC-5952. Tôi đã viết mã này bằng ANSI C (hoạt động với GCC, đã vượt qua các bài kiểm tra trên Linux - hoạt động với tiếng kêu, đã vượt qua các bài kiểm tra trên FreeBSD). Do đó, nó chỉ dựa vào thư viện chuẩn ANSI C, vì vậy nó có thể được biên dịch ở mọi nơi (tôi đã sử dụng nó để phân tích cú pháp IPv6 bên trong một mô-đun hạt nhân với 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;
}

Hãy thử một lớp lót nhỏ này. Nó chỉ nên khớp với các địa chỉ IPv6 không nén / nén hợp lệ (không có IPv4 lai)

/(?!.*::.*::)(?!.*:::.*)(?!:[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}/

Regex cho phép sử dụng các số 0 ở đầu trong các phần IPv4.

Một số phân phối Unix và Mac chuyển đổi các phân đoạn đó thành số bát phân.

Tôi đề nghị sử dụng 25[0-5]|2[0-4]\d|1\d\d|[1-9]?\dlàm phân đoạn IPv4.

Nếu bạn chỉ muốn IP-s bình thường (không có dấu gạch chéo), tại đây:

^(?:[0-9a-f]{1,4}(?:::)?){0,7}::[0-9a-f]+$

Tôi sử dụng nó cho công cụ đánh dấu cú pháp của mình trong ứng dụng chỉnh sửa tệp máy chủ. Hoạt động như một sự quyến rũ.