it-swarm.com.de

Überprüfung der IPv4-Adressen mit Regexp

Ich habe versucht, einen effizienten Regex für die IPv4-Validierung zu erhalten, jedoch ohne viel Glück. Es schien, als hätte ich es schon einmal mit (25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?(\.|$)){4} gehabt, aber es führt zu seltsamen Ergebnissen:

[[email protected] bashscripts]$ grep --version
grep (GNU grep) 2.7


[[email protected] bashscripts]$ grep -E '\b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?(\.|$)){4}\b' <<< 192.168.1.1
192.168.1.1
[[email protected] bashscripts]$ grep -E '\b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?(\.|$)){4}\b' <<< 192.168.1.255
192.168.1.255
[[email protected] bashscripts]$ grep -E '\b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?(\.|$)){4}\b' <<< 192.168.255.255
[[email protected] bashscripts]$ grep -E '\b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?(\.|$)){4}\b' <<< 192.168.1.2555
192.168.1.2555

Ich suchte nach einer Frage, ob dies bereits gefragt und beantwortet wurde, aber andere Antworten scheinen lediglich zu zeigen, wie man 4 Gruppen von 1 bis 3 Zahlen ermittelt oder für mich nicht funktioniert.

Irgendwelche Ideen? Vielen Dank!

43

Sie haben bereits eine funktionierende Antwort, aber für den Fall, dass Sie neugierig sind, was mit Ihrem ursprünglichen Ansatz falsch war, ist die Antwort, dass Sie für Ihre Alternative Klammern benötigen. Andernfalls ist der (\.|$) nur erforderlich, wenn die Anzahl unter 200 liegt.

'\b((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\.|$)){4}\b'
    ^                                    ^
60
Mark Byers

^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$

Akzeptieren :

127.0.0.1
192.168.1.1
192.168.1.255
255.255.255.255
0.0.0.0
1.1.1.01

Ablehnen :

30.168.1.255.1
127.1
192.168.1.256
-1.2.3.4
3...3

Versuchen Sie es online mit Unit-Tests: https://www.debuggex.com/r/-EDZOqxTxhiTncN6/1

55
Sllouyssgort

Regex ist nicht das Werkzeug für diesen Job. Es ist besser, einen Parser zu schreiben, der die vier Zahlen trennt und prüft, ob sie im Bereich [0,255] liegen. Der nicht funktionale Regex ist bereits unlesbar!

24
Tim

Neue und verbesserte kürzere Version

^(?:(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])(\.(?!$)|$)){4}$

Es wird der negative Lookahead (?!) Verwendet, um den Fall zu entfernen, dass die IP mit einem . Endet.

Alte Antwort

^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}
    (?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$ 

Ich denke, dies ist der genaueste und strengste reguläre Ausdruck. Er akzeptiert keine Dinge wie 000.021.01.0., Wie es bei den meisten anderen Antworten der Fall ist, und erfordert zusätzlichen regulären Ausdruck, um ähnliche Fälle abzulehnen - dh 0 Startnummern und eine IP, die mit einem . endet

14
Danail Gabenski

IPv4-Adresse (genaue Erfassung) Entspricht 0.0.0.0 bis 255.255.255.255 Verwenden Sie diesen Regex, um die IP-Nummern mit der Genauigkeit ..__ abzugleichen. Jede der 4 Nummern wird in einer Erfassungsgruppe gespeichert, sodass Sie darauf zugreifen können zur Weiterverarbeitung.

\b
(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.
(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.
(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.
(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)
\b

aus der JGsoft RegexBuddy-Bibliothek übernommen

Edit: Dieser (\.|$)-Teil wirkt seltsam

10
Valerij

Ich war auf der Suche nach etwas Ähnlichem für IPv4-Adressen - ein Regex, der auch die Überprüfung der Verwendung häufig genutzter privater IP-Adressen (192.168.x.y, 10.x.y.z, 172.16.x.y) verhinderte.

(?!(10\.|172\.(1[6-9]|2\d|3[01])\.|192\.168\.).*)
(?!255\.255\.255\.255)(25[0-5]|2[0-4]\d|[1]\d\d|[1-9]\d|[1-9])
(\.(25[0-5]|2[0-4]\d|[1]\d\d|[1-9]\d|\d)){3}

(Diese sollten sich natürlich in einer Zeile befinden und zur besseren Lesbarkeit in 3 separaten Zeilen formatiert sein.) Regular expression visualization

Debuggex Demo

Es ist möglicherweise nicht auf Geschwindigkeit optimiert, funktioniert jedoch gut, wenn nur nach "echten" Internetadressen gesucht wird.

Dinge, die versagen (und sollten):

0.1.2.3         (0.0.0.0/8 is reserved for some broadcasts)
10.1.2.3        (10.0.0.0/8 is considered private)
172.16.1.2      (172.16.0.0/12 is considered private)
172.31.1.2      (same as previous, but near the end of that range)
192.168.1.2     (192.168.0.0/16 is considered private)
255.255.255.255 (reserved broadcast is not an IP)
.2.3.4
1.2.3.
1.2.3.256
1.2.256.4
1.256.3.4
256.2.3.4
1.2.3.4.5
1..3.4

IPs, die funktionieren werden (und sollten):

1.0.1.0         (China)
8.8.8.8         (Google DNS in USA)
100.1.2.3       (USA)
172.15.1.2      (USA)
172.32.1.2      (USA)
192.167.1.2     (Italy)

Wird bereitgestellt, falls andere Personen nach einer Überprüfung der "Internet-IP-Adressen ohne die üblichen privaten Adressen" suchen.

4
PhillipHolmes

Ich denke, viele Leute, die diesen Beitrag lesen, werden nach etwas Einfacherem suchen, auch wenn sie technisch unzulässige IP-Adressen durchlassen.

Dies ist am einfachsten, was ich mir vorstellen könnte:

Python/Ruby/Perl:

/(\d+(\.|$)){4}/

grep -E (GNU Grep 3.1), awk (Version 20070501) und sed:

/([0-9]+(\.|$)){4}/

Marionette erlaubt das:

/(\d+[\.$]){4}/
2
Alex Harvey

Dies ist etwas länger als einige, aber ich verwende IPv4-Adressen. Einfach ohne Kompromisse.

^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])$
2
Mickstar

'' 'Dieser Code funktioniert für mich und ist so einfach.

Hier habe ich den Wert von ip genommen und versuche ihn mit Regex abzugleichen.

ip="25.255.45.67"    

op=re.match('(\d+).(\d+).(\d+).(\d+)',ip)

if ((int(op.group(1))<=255) and (int(op.group(2))<=255) and int(op.group(3))<=255) and (int(op.group(4))<=255)):

print("valid ip")

else:

print("Not valid")

Obige Bedingung prüft, ob der Wert 255 für alle 4 Oktette überschreitet, dann ist er nicht gültig. Bevor wir die Bedingung anwenden, müssen wir sie jedoch in eine Ganzzahl konvertieren, da der Wert in einer Zeichenfolge enthalten ist.

group (0) druckt die übereinstimmende Ausgabe, wohingegen group (1) den ersten übereinstimmenden Wert druckt und hier "25" ist und so weiter. '' '

1
Shruti Lakkihal

Die obigen Antworten sind gültig, aber was ist, wenn sich die IP-Adresse nicht am Ende der Zeile befindet und sich zwischen dem Text befindet. Dieser reguläre Ausdruck funktioniert sogar damit.

code: '\b((([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])(\.)){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5]))\b'

eingabetextdatei:

ip address 0.0.0.0 asfasf
 sad sa 255.255.255.255 cvjnzx
zxckjzbxk  999.999.999.999 jshbczxcbx
sjaasbfj 192.168.0.1 asdkjaksb
oyo 123241.24121.1234.3423 yo
yo 0000.0000.0000.0000 y
aw1a.21asd2.21ad.21d2
yo 254.254.254.254 y0
172.24.1.210 asfjas
200.200.200.200
000.000.000.000
007.08.09.210
010.10.30.110

ausgabetext:

0.0.0.0
255.255.255.255
192.168.0.1
254.254.254.254
172.24.1.210
200.200.200.200
1
Kushagra Gupta

Es gelang mir, aus allen anderen Antworten einen Regex zu konstruieren.

(25[0-5]|2[0-4][0-9]|[1][0-9][0-9]|[1-9][0-9]|[0-9]?)(\.(25[0-5]|2[0-4][0-9]|[1][0-9][0-9]|[1-9][0-9]|[0-9]?)){3}
1
Vicky
/^(?:(25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)\.){3}(?1)$/m
1
Etienne Gautier
(((25[0-5])|(2[0-4]\d)|(1\d{2})|(\d{1,2}))\.){3}(((25[0-5])|(2[0-4]\d)|(1\d{2})|(\d{1,2})))

Testen Sie die Suche nach Übereinstimmungen im Text https://regex101.com/r/9CcMEN/2

Folgende Regeln definieren die gültigen Kombinationen in jeder Nummer einer IP-Adresse:

  • Beliebige ein- oder zweistellige Nummer.
  • Eine dreistellige Zahl, die mit 1 beginnt.

  • Eine dreistellige Zahl, die mit 2 beginnt, wenn die zweite Ziffer 0 Bis 4 ist.

  • Eine dreistellige Zahl, die mit 25 beginnt, wenn die dritte Ziffer 0 Bis 5 ist.

Beginnen wir mit (((25[0-5])|(2[0-4]\d)|(1\d{2})|(\d{1,2}))\.), einem Satz von vier verschachtelten Unterausdrücken, die wir in umgekehrter Reihenfolge betrachten. (\d{1,2}) entspricht einer ein- oder zweistelligen Zahl oder Nummern 0 bis 99. (1\d{2}) stimmt mit jeder dreistelligen Zahl überein, die mit 1 (1 gefolgt von zwei beliebigen Ziffern) beginnt, oder Zahlen 100 bis 199. (2[0-4]\d) stimmt mit den Nummern 200 bis 249 überein. (25[0-5]) stimmt mit den Nummern 250 bis 255 überein. Jeder dieser Unterausdrücke ist in einem anderen Unterausdruck mit einem | zwischen jedem eingeschlossen (so dass einer der vier Unterausdrücke übereinstimmen muss, nicht alle). Nachdem der Zahlenbereich \. mit . übereinstimmt, wird die gesamte Serie (alle Zahlenoptionen plus \.) in einen weiteren Unterausdruck eingeschlossen und mit {3} dreimal wiederholt. Schließlich wird der Nummernbereich wiederholt (diesmal ohne den nachfolgenden \.), um mit der endgültigen IP-Adressnummer übereinzustimmen. Durch Beschränken der vier Zahlen auf Werte zwischen 0 und 255 kann dieses Muster tatsächlich mit gültigen IP-Adressen übereinstimmen und ungültige Adressen ablehnen.

Auszug aus: Ben Forta. „Regelmäßige Ausdrücke lernen.“


Wenn weder am Anfang der IP-Adresse noch am Ende ein Zeichen gewünscht wird, müssen ^ und $-Metazeichen verwendet werden.

^(((25[0-5])|(2[0-4]\d)|(1\d{2})|(\d{1,2}))\.){3}(((25[0-5])|(2[0-4]\d)|(1\d{2})|(\d{1,2})))$

Testen Sie die Suche nach Übereinstimmungen im Text https://regex101.com/r/uAP31A/1

1
snr

Mit Subnetzmaske:

^$|([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\
.([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\
.([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\
.([01]?\\d\\d?|2[0-4]\\d|25[0-5])
((/([01]?\\d\\d?|2[0-4]\\d|25[0-5]))?)$
1
hsuk
-bash-3.2$ echo "191.191.191.39" | egrep 
  '(^|[^0-9])((2([6-9]|5[0-5]?|[0-4][0-9]?)?|1([0-9][0-9]?)?|[3-9][0-9]?|0)\.{3}
     (2([6-9]|5[0-5]?|[0-4][0-9]?)?|1([0-9][0-9]?)?|[3-9][0-9]?|0)($|[^0-9])'

>> 191.191.191.39

(Dies ist ein DFA, der den gesamten Adressraum (einschließlich Broadcasts usw.) und nichts anderes angibt.

0
Jonathzen

Versuche dies:

\b(([1-9]|[1-9][0-9]|1[0-9][0-9]|2[0-5][0-5])\.([1-9]|[1-9][0-9]|1[0-9][0-9]|2[0-5][0-5])\.([1-9]|[1-9][0-9]|1[0-9][0-9]|2[0-5][0-5])\.(2[0-5][0-5]|1[0-9][0-9]|[1-9][0-9]|[1-9]))\b
0
AAP

Für Zahlen von 0 bis 255 verwende ich diesen regulären Ausdruck:

(([0-9])|([1-9][0-9])|(1([0-9]{2}))|(2[0-4][0-9])|(25[0-5]))

Der obige reguläre Ausdruck stimmt mit einer Ganzzahl von 0 bis 255 überein, stimmt jedoch nicht mit 256 überein.

Für IPv4 verwende ich diesen regulären Ausdruck:

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

Es ist in dieser Struktur: ^(N)((\.(N)){3})$ wobei N der reguläre Ausdruck ist, der verwendet wird, um eine Zahl von 0 bis 255 zu finden.
Dieser reguläre Ausdruck entspricht der folgenden IP-Adresse:

0.0.0.0
192.168.1.2

aber nicht die unten:

10.1.0.256
1.2.3.
127.0.1-2.3

Für IPv4 CIDR (Classless Inter-Domain Routing) verwende ich diesen regulären Ausdruck:

^(([0-9])|([1-9][0-9])|(1([0-9]{2}))|(2[0-4][0-9])|(25[0-5]))((\.(([0-9])|([1-9][0-9])|(1([0-9]{2}))|(2[0-4][0-9])|(25[0-5]))){3})\/(([0-9])|([12][0-9])|(3[0-2]))$

Es ist in dieser Struktur: ^(N)((\.(N)){3})\/M$ wobei N der reguläre Ausdruck ist, der verwendet wird, um die Zahl von 0 bis 255 abzugleichen, und M der reguläre Ausdruck ist, der verwendet wird, um die Zahl von 0 bis 32 abzugleichen.
Dieser reguläre Ausdruck passt zu CIDR wie folgt:

0.0.0.0/0
192.168.1.2/32

aber nicht die unten:

10.1.0.256/16
1.2.3./24
127.0.0.1/33

Und für eine Liste von IPv4-CIDRs wie "10.0.0.0/16", "192.168.1.1/32" Verwende ich diesen regulären Ausdruck:

^("(([0-9])|([1-9][0-9])|(1([0-9]{2}))|(2[0-4][0-9])|(25[0-5]))((\.(([0-9])|([1-9][0-9])|(1([0-9]{2}))|(2[0-4][0-9])|(25[0-5]))){3})\/(([0-9])|([12][0-9])|(3[0-2]))")((,([ ]*)("(([0-9])|([1-9][0-9])|(1([0-9]{2}))|(2[0-4][0-9])|(25[0-5]))((\.(([0-9])|([1-9][0-9])|(1([0-9]{2}))|(2[0-4][0-9])|(25[0-5]))){3})\/(([0-9])|([12][0-9])|(3[0-2]))"))*)$

Es ist in dieser Struktur: ^(“C”)((,([ ]*)(“C”))*)$ wobei C der reguläre Ausdruck ist, der zur Übereinstimmung mit CIDR verwendet wird (wie 0.0.0.0/0).
Dieser reguläre Ausdruck entspricht der folgenden CIDR-Liste:

“10.0.0.0/16”,”192.168.1.2/32”, “1.2.3.4/32”

aber nicht die unten:

“10.0.0.0/16” 192.168.1.2/32 “1.2.3.4/32”

Vielleicht wird es kürzer, aber für mich ist es einfach so gut zu verstehen.

Ich hoffe es hilft!

0
congacon

Dieser stimmt nur mit gültigen IP-Adressen überein (keine vorangestellten Nullen, aber er stimmt mit Oktetten von 0 bis 255 überein, unabhängig von ihrer 'Funktion' [dh reserviert, privat usw.]) und ermöglicht Inline-Übereinstimmungen, bei denen möglicherweise Leerzeichen vor und/oder vorhanden sind nach der IP oder bei Verwendung der CIDR-Notation.

grep -E '(^| )((([1-9]?[0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5]))\.){3}([1-9]?[0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])($| |/)'

$ grep -E '(^| )((([1-9]?[0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5]))\.){3}([1-9]?[0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])($| |/)' <<< '10.0.1.2'
10.0.1.2

$ grep -E '(^| )((([1-9]?[0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5]))\.){3}([1-9]?[0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])($| |/)' <<< 'ip address 10.0.1.2'
ip address 10.0.1.2

$ grep -E '(^| )((([1-9]?[0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5]))\.){3}([1-9]?[0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])($| |/)' <<< 'ip address 10.0.1.2 255.255.255.255'
ip address 10.0.1.2 255.255.255.255

$ grep -E '(^| )((([1-9]?[0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5]))\.){3}([1-9]?[0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])($| |/)' <<< 'ip address 10.0.1.2/32'
ip address 10.0.1.2/32

$ grep -E '(^| )((([1-9]?[0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5]))\.){3}([1-9]?[0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])($| |/)' <<< 'ip address 10.0.1.2.32'
$

$ grep -E '(^| )((([1-9]?[0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5]))\.){3}([1-9]?[0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])($| |/)' <<< 'ip address10.0.1.2'
$

$ grep -E '(^| )((([1-9]?[0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5]))\.){3}([1-9]?[0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])($| |/)' <<< '10.0.1.256'
$

$ grep -E '(^| )((([1-9]?[0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5]))\.){3}([1-9]?[0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])($| |/)' <<< '0.0.0.0'
0.0.0.0

$ grep -E '(^| )((([1-9]?[0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5]))\.){3}([1-9]?[0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])($| |/)' <<< '255.255.255.255'
255.255.255.255

$ grep -E '(^| )((([1-9]?[0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5]))\.){3}([1-9]?[0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])($| |/)' <<< '255.255.255.256'
$

Natürlich können Sie in Fällen, in denen die IP inline ist, die grep-Option "-o" und Ihre Präferenz für den Leerraumabschneider verwenden, wenn Sie nur die gesamte IP und nichts als die IP wollen.

Für diejenigen von uns, die Python verwenden, ist das Äquivalent ungefähr:

>>> ipv4_regex = re.compile(r'(^| )((?:[1-9]?\d|1\d{2}|2[0-4]\d|25[0-5])\.){3}(?:[1-9]?\d|1\d{2}|2[0-4]\d|25[0-5])($| |/)')
>>> ipv4_regex.search('ip address 10.1.2.3/32')
<re.Match object; span=(10, 20), match=' 10.1.2.3/'>

Wenn Sie wählerisch (faul) sind wie ich, würden Sie wahrscheinlich die Gruppierung vorziehen, um die gesamte IP und nichts als die IP oder die CIDR und nichts als die CIDR oder eine Kombination davon zu erhalten. Wir können (? P) syntax verwenden, um unsere Gruppen zur leichteren Bezugnahme zu benennen.

>>> ipv4_regex = re.compile(r'(?:^| )(?P<address>((?:[1-9]?\d|1\d{2}|2[0-4]\d|25[0-5])\.){3}(?:[1-9]?\d|1\d{2}|2[0-4]\d|25[0-5]))(?P<slash>/)?(?(slash)(?P<cidr>[0-9]|[12][0-9]|3[0-2]))(?:$| )')
>>> match = ipv4_regex.search('ip address 10.0.1.2/32')
>>> match.group('address')
'10.0.1.2'
>>> match.group('cidr')
'32'
>>> "".join((match.group('address'), match.group('slash'), match.group('cidr')))
'10.0.1.2/32'

Natürlich gibt es Möglichkeiten, nicht nur Regex zu verwenden. Hier sind einige Bedingungen, die Sie überprüfen können (dieser findet keine Inline-Adresse, überprüft nur, ob die übergebene Adresse gültig ist).

Überprüfen Sie zunächst, ob jedes Zeichen in der Adresse eine Ziffer oder ein '.'

Als nächstes überprüfe, ob es genau 3 'gibt.'

Die nächsten beiden Überprüfungen stellen sicher, dass jedes Oktett zwischen 0 und 255 liegt.

Und die letzte Überprüfung ist, dass keine Oktette mit einer '0' vorangestellt werden

def validate_ipv4_address(address):
    return all(re.match('\.|\d', c) for c in address) \
        and address.count('.') == 3 \
        and all(0 <= int(octet) <= 255 for octet in address.split('.')) \
        and all((len(bin(int(octet))) <= 10 for octet in address.split('.'))) \
        and all(len(octet) == 1 or d[0] != '0' for octet in address.split('.'))


>>> validate_ipv4_address('255.255.255.255')
True
>>> validate_ipv4_address('10.0.0.1')
True
>>> validate_ipv4_address('01.01.01.01')
False
>>> validate_ipv4_address('123.456.789.0')
False
>>> validate_ipv4_address('0.0.0.0')
True
>>> validate_ipv4_address('-1.0.0.0')
False
>>> validate_ipv4_address('1.1.1.')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 4, in validate_ipv4_address
  File "<stdin>", line 4, in <genexpr>
ValueError: invalid literal for int() with base 10: ''
>>> validate_ipv4_address('.1.1.1')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 4, in validate_ipv4_address
  File "<stdin>", line 4, in <genexpr>
ValueError: invalid literal for int() with base 10: ''
>>> validate_ipv4_address('1..1.1')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 4, in validate_ipv4_address
  File "<stdin>", line 4, in <genexpr>
ValueError: invalid literal for int() with base 10: ''

(Bitweise sollte jedes Oktett 8 Bit oder weniger sein, aber jedem wird '0b' vorangestellt.)

>>> bin(0)
'0b0'
>>> len(bin(0))
3
>>> bin(255)
'0b11111111'
>>> len(bin(256))
11
0
Jason Shaffner

Ich habe sehr schlechte reguläre Ausdrücke auf dieser Seite gesehen. Also bin ich mit meinen eigenen gekommen:

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

Erläuterung:

num-group = (0-9|10-99|100-199|200-249|250-255)
<border> + { <num-group> + <dot-cahracter> }x3 + <num-group> + <border>

Hier können Sie überprüfen, wie es funktioniert hier

0
Martin Mlích
    const char*ipv4_regexp = "\\b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\."
    "(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\."
    "(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\."
    "(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\b";

Ich habe den regulären Ausdruck aus der JGsoft RegexBuddy-Bibliothek an die C-Sprache (regcomp/regexec) angepasst und festgestellt, dass er funktioniert, aber es gibt ein kleines Problem in einigen Betriebssystemen wie Linux .. Dieser reguläre Ausdruck akzeptiert eine IPv4-Adresse wie 192.168.100.009, wobei 009 Unter Linux wird ein Oktalwert betrachtet, daher ist die Adresse nicht die, von der Sie gedacht haben, dass ich den regulären Ausdruck wie folgt geändert habe:

    const char* ipv4_regex = "\\b(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\."
           "(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\."
           "(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\."
           "(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\b";

die Verwendung dieses regulären Ausdrucks 192.168.100.009 ist keine gültige IPv4-Adresse, während 192.168.100.9 in Ordnung ist.

Ich habe auch einen regulären Ausdruck für die Multicast-Adresse geändert.

    const char* mcast_ipv4_regex = "\\b(22[4-9]|23[0-9])\\."
                        "(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\."
                        "(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9]?)\\."
                        "(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\b";

Ich denke, Sie müssen den regulären Ausdruck an die Sprache anpassen, die Sie zur Entwicklung Ihrer Anwendung verwenden

Ich habe ein Beispiel in Java eingefügt:

    package utility;

    import Java.util.regex.Matcher;
    import Java.util.regex.Pattern;

    public class NetworkUtility {

        private static String ipv4RegExp = "\\b(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d?)\\b";

        private static String ipv4MulticastRegExp = "2(?:2[4-9]|3\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d?|0)){3}";

        public NetworkUtility() {

        }

        public static boolean isIpv4Address(String address) {
            Pattern pattern = Pattern.compile(ipv4RegExp);
            Matcher matcher = pattern.matcher(address);

            return matcher.matches();
        }

        public static boolean isIpv4MulticastAddress(String address) {
             Pattern pattern = Pattern.compile(ipv4MulticastRegExp);
             Matcher matcher = pattern.matcher(address);

             return matcher.matches();
        }
    }
0
Fabio Stafforte

^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\\.)){3}+((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?))$


Oben wird Regex für die IP-Adresse wie folgt angegeben: 221.234.000.112 auch für 221.234.0.112, 221.24.03.112, 221.234.0.1


Sie können sich alle Arten von Adressen wie oben vorstellen

0
Ram Sharma

Ich fand dieses Beispiel sehr nützlich, außerdem erlaubt es verschiedene IPv4-Notationen.

beispielcode mit Python:

    def is_valid_ipv4(ip4):
    """Validates IPv4 addresses.
    """
    import re
    pattern = re.compile(r"""
        ^
        (?:
          # Dotted variants:
          (?:
            # Decimal 1-255 (no leading 0's)
            [3-9]\d?|2(?:5[0-5]|[0-4]?\d)?|1\d{0,2}
          |
            0x0*[0-9a-f]{1,2}  # Hexadecimal 0x0 - 0xFF (possible leading 0's)
          |
            0+[1-3]?[0-7]{0,2} # Octal 0 - 0377 (possible leading 0's)
          )
          (?:                  # Repeat 0-3 times, separated by a dot
            \.
            (?:
              [3-9]\d?|2(?:5[0-5]|[0-4]?\d)?|1\d{0,2}
            |
              0x0*[0-9a-f]{1,2}
            |
              0+[1-3]?[0-7]{0,2}
            )
          ){0,3}
        |
          0x0*[0-9a-f]{1,8}    # Hexadecimal notation, 0x0 - 0xffffffff
        |
          0+[0-3]?[0-7]{0,10}  # Octal notation, 0 - 037777777777
        |
          # Decimal notation, 1-4294967295:
          429496729[0-5]|42949672[0-8]\d|4294967[01]\d\d|429496[0-6]\d{3}|
          42949[0-5]\d{4}|4294[0-8]\d{5}|429[0-3]\d{6}|42[0-8]\d{7}|
          4[01]\d{8}|[1-3]\d{0,9}|[4-9]\d{0,8}
        )
        $
    """, re.VERBOSE | re.IGNORECASE)
    return pattern.match(ip4) <> None
0
internety

Sucht eine gültige IP-Adresse, solange die IP um ein anderes Zeichen als Ziffern (hinter oder hinter der IP) steht. 4 Rückreferenzen erstellt: $ + {first}. $ + {Second}. $ + {Third}. $ + {Fort}

Find String:
#any valid IP address
(?<IP>(?<![\d])(?<first>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?<second>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?<third>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?<forth>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))(?![\d]))
#only valid private IP address RFC1918
(?<IP>(?<![\d])(:?(:?(?<first>10)[\.](?<second>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5])))|(:?(?<first>172)[\.](?<second>(:?1[6-9])|(:?2[0-9])|(:?3[0-1])))|(:?(?<first>192)[\.](?<second>168)))[\.](?<third>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?<forth>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))(?![\d]))

Notepad++ Replace String Option 1: Replaces the whole IP (NO Change):
$+{IP}

Notepad++ Replace String Option 2: Replaces the whole IP octect by octect (NO Change)
$+{first}.$+{second}.$+{third}.$+{forth}

Notepad++ Replace String Option 3: Replaces the whole IP octect by octect (replace 3rd octect value with 0)
$+{first}.$+{second}.0.$+{forth}
NOTE: The above will match any valid IP including 255.255.255.255 for example and change it to 255.255.0.255 which is wrong and not very useful of course.

Ersetzen eines Teils jedes Oktkts durch einen tatsächlichen Wert. Sie können jedoch ein eigenes Suchen und Ersetzen erstellen. Dies ist wirklich nützlich, um IPs in Textdateien zu verbessern:

for example replace the first octect group of the original Find regex above:
(?<first>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))
with
(?<first>10)

and
(?<second>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))
with
(?<second>216)
and you are now matching addresses starting with first octect 192 only

Find on notepad++:
(?<IP>(?<![\d])(?<first>10)[\.](?<second>216)[\.](?<third>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?<forth>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))(?![\d]))

Sie können Replace mithilfe von Rückreferenzgruppen auf dieselbe Weise wie zuvor ausführen.

Sie können sich ein Bild davon machen, wie das obige hier übereinstimmt:

cat ipv4_validation_test.txt
Full Match:
0.0.0.1
12.108.1.34
192.168.1.1
10.249.24.212
10.216.1.212
192.168.1.255
255.255.255.255
0.0.0.0


Partial Match (IP Extraction from line)
30.168.1.0.1
-1.2.3.4
sfds10.216.24.23kgfd
da11.15.112.255adfdsfds
sfds10.216.24.23kgfd


NO Match
1.1.1.01
3...3
127.1.
192.168.1..
192.168.1.256
da11.15.112.2554adfdsfds
da311.15.112.255adfdsfds

Mit grep können Sie die Ergebnisse unten sehen:

From grep:
grep -oP '(?<IP>(?<![\d])(?<first>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?<second>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?<third>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?<forth>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))(?![\d]))' ipv4_validation_test.txt
0.0.0.1
12.108.1.34
192.168.1.1
10.249.24.212
10.216.1.212
192.168.1.255
255.255.255.255
0.0.0.0
30.168.1.0
1.2.3.4
10.216.24.23
11.15.112.255
10.216.24.23


grep -P '(?<IP>(?<![\d])(?<first>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?<second>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?<third>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?<forth>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))(?![\d]))' ipv4_validation_test.txt
0.0.0.1
12.108.1.34
192.168.1.1
10.249.24.212
10.216.1.212
192.168.1.255
255.255.255.255
0.0.0.0
30.168.1.0.1
-1.2.3.4
sfds10.216.24.23kgfd
da11.15.112.255adfdsfds
sfds10.216.24.23kgfd


#matching ip addresses starting with 10.216
grep -oP '(?<IP>(?<![\d])(?<first>10)[\.](?<second>216)[\.](?<third>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?<forth>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))(?![\d]))' ipv4_validation_test.txt
10.216.1.212
10.216.24.23
10.216.24.23
0
rda

Der präziseste, unkomplizierteste und kompakteste IPv4-Regex, den ich mir vorstellen kann, ist

^(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$

Aber was ist mit der Leistung/Effizienz von ... Sorry, ich weiß nicht, wen interessiert das?

0
fuweichin

Ich würde PCRE und das Schlüsselwort define verwenden: 

/^
 ((?&byte))\.((?&byte))\.((?&byte))\.((?&byte))$
 (?(DEFINE)
     (?<byte>25[0-5]|2[0-4]\d|[01]?\d\d?))
/gmx

Demo: https://regex101.com/r/IB7j48/2

Der Grund dafür ist, das (25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)-Muster viermal zu wiederholen. Andere Lösungen, wie die unten stehende, funktionieren gut, erfassen jedoch nicht jede Gruppe, wie sie von vielen verlangt wird.

/^((\d+?)(\.|$)){4}/ 

Die einzige andere Möglichkeit, vier Capture-Gruppen zu erstellen, besteht darin, das Muster viermal zu wiederholen: 

/^(?<one>\d+)\.(?<two>\d+)\.(?<three>\d+)\.(?<four>\d+)$/

Das Aufnehmen einer IPv4 in Perl ist daher sehr einfach 

$ echo "Hey this is my IP address 138.131.254.8, bye!" | \
  Perl -ne 'print "[$1, $2, $3, $4]" if \
    /\b((?&byte))\.((?&byte))\.((?&byte))\.((?&byte))
     (?(DEFINE)
        \b(?<byte>25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?))
    /x'

[138, 131, 254, 8]
0
nowox

Ich denke, das ist das kürzeste.

^(([01]?\d\d?|2[0-4]\d|25[0-5]).){3}([01]?\d\d?|2[0-4]\d|25[0-5])$
0
Altan Gokcek

Einfacher Weg 

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

Demo

0
BabiBN
((\.|^)(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]?|0$)){4}

Dieser Regex wird nicht akzeptiert 08.8.8.8 oder 8.08.8.8 oder 8.8.08.8 oder 8.8.8.08

0
sudistack
ip address can be from 0.0.0.0 to 255.255.255.255

(((0|1)?[0-9][0-9]?|2[0-4][0-9]|25[0-5])[.]){3}((0|1)?[0-9][0-9]?|2[0-4][0-9]|25[0-5])$

(0|1)?[0-9][0-9]? - checking value from 0 to 199
2[0-4][0-9]- checking value from 200 to 249
25[0-5]- checking value from 250 to 255
[.] --> represent verify . character 
{3} --> will match exactly 3
$ --> end of string
0

Es folgt der reguläre Ausdruck, um die IP-Adresse zu überprüfen. 

^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$
0
Dilip Paudel