Validate IPv4 addresses using PCRE's recursion patterns. A shorter but less efficient alternative to https://regex101.com/r/wZ6oY5/1

This regular expression will match an IPv4 address as well as both compressed or uncompressed IPv6 address.

This regex matches every IPv4 address with or without 0s before every number. For example: 192.168.1.1 00000000000192.168.00000000000001.01

Valid: 000.01.249.255 1.199.200.0 0.0.0.0 Invalid: 1000..256.300

A good enough approximation to IPv6 based on the examples at https://www.ibm.com/docs/en/ts3500-tape-library?topic=functionality-ipv4-ipv6-address-formats

IPv4 Address Input

Regex to match an IPv4 address at beginning

Searches for dotted decimal IPv4 Adresses and saves the numbers in match groups.

Capture 0.0.0.0-255.255.255.255 IP address octets. Capture private ranges, such as '169.254.' and '10.'

IPv4 Validation to RFC 3986 found at https://tools.ietf.org/html/rfc3986#section-1.1.1.

Validate IPv4 addresses using PCRE's recursion patterns.

This pcre style regex tests for valid URLs capturing the whole address. It will capture http and https only. Compatible with multiple sub-domains and raw IPV4 addresses, as well as paths, queries, and parameters. See below for examples: Will match these valid URLS: https://www.example.com/foo/?bar=baz&inga=42&quux http://foo.com/blah_(wikipedia)#cite-1 http://foo.com/blah_(wikipedia)_blah#cite-1 http://foo.com/unicode_(✪)_in_parens http://foo.com/(something)?after=parens http://code.google.com/events/#&product=browser http://142.42.1.1/ http://142.42.1.1:8080/ Will NOT match though valid URLS http://✪df.ws/123 http://userid:password@example.com:8080 http://userid:password@example.com:8080/ http://userid@example.com http://userid@example.com/ http://userid@example.com:8080 http://userid@example.com:8080/ http://userid:password@example.com http://userid:password@example.com/ Does NOT and should not match these bad URLS: http:// http://. http://.. http://../ http://? http://?? http://??/ http://# http://## http://##/ http://foo.bar?q=Spaces should be encoded // //a ///a /// http:///a foo.com rdar://1234 h://test http:// shouldfail.com :// should fail http://foo.bar/foo(bar)baz quux ftps://foo.bar/ http://-error-.invalid/ http://a.b--c.de/ http://-a.b.co http://a.b-.co http://3628126748 http://.www.foo.bar/ http://www.foo.bar./ http://.www.foo.bar./ Its not perfect, it will match http://999.999.999.999 and similar invalid IPV4 addresses and is not optimized but met my needs.

Validates and parses absolute URLs: Optional http:// or https:// at the start IPv4 supported, IPv6 NOT supported International characters (punycode) NOT supported Extracts scheme, username, password, IPv4 address or domain, port, path, querystring and fragment Sensible restrictions on domain and path

as the title says

This is loosely based on some other examples, but goes a bit further in terms of what it will and won't match. In particular, it matches IPv6 addresses like ff02::, ff02:1000::, and (the syntactically valid but improbable) ::0001:0002

I didn't find any good (any easy) ones. So here you go ^^

Looks bloated, but also validates that the address format is correct, i.e. no false-positives for 777.777.777.777

matches valid ipv4 addresses

Matches publicly available IPv4 addresses (excludes 10., 172.16-32, and 192.168 blocks).

Validates an IPv4 address for use as a URI host as defined in RFC-3986.

Matches ranges from 0-255 for all four octets. Extra leading or trailing '.' invalidate the match, as do values > 255.

Check if the given string is a private address

Valid IP Octets include: 1-9 & 11-223, then 0-255, twice, then 1-254 but with no leading zeroes. This will exclude the 10.0.0/8 private IP range, the reserved and multi-cast range, 224.0.0.0 and up, as well as the private IP ranges 172.16.0.0/12 and 192.168.0.0/16. In other words, this will address all publicly accessible IPv4 addresses from 1.0.0.1 through 223.255.255.254.

find leading zeros in ipv4 adresses

The given regex matches the IPV4 address of given ip address string.

Validates the format of IPv4/IPv6 hostnames as well as domain names.

Intended to verify a valid IPv4 subnet mask against every valid IPv4 subnet mask possible using octet format. Does not check against a string that is using CIDR notation.

Matches valid internet-routable IPv4 addresses (Not RFC1918, RFC5735, RFC3927) with optional port delimited by colon. I wrote this specifically for Snort rules that look for hardcoded IPv4 addresses in the HTTP Host header field, but I imagine this may have its uses aside from that. This would have been much simpler to write using negative lookahead (NLA), but for kicks I did it without it. I know that NLA is not always supported, so this should work. If non-capture groups aren't supported either, you can just change (?: ) to ( ) and it should still work fine (\cough\Yara\cough\). Just to be clear: This expression purposefully will not match: Addresses that start with 0 (0.X.X.X) Loopback addresses (127.0.0.0/8) Addresses that start with 224 through 255 (Class D and E addresses) Private IPs (10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16) APIPA (169.254.0.0/16) The port expression will match ports from 1-65535.

IPv4 w/ w/o port validation and localhost string supported

Use It for partial/complete IPv4 address input text checking. OK examples: 19 / 192. / 192.168.1 / 192.168.1.1 / 0.0.0.0 KO examples: 1A / 01 / 192.168..1

Accepts: Valid IPv4: 127.0.0.1 192.168.1.1 192.168.1.255 192.168.255.255 0.0.0.0 Valid Hostnames: abdc N7 Valid FQDN: ABCD.fr truc-bidule.com sub.one-stuff.somewhere.com sub1.sub2.sub3.sub4.sub5.sub6.net Rejects all the rest: 127.0.0.1 192.168.1.1a 192.068.1.255 30.168.1.255.1 127.1 192.168.1.256 -1.2.3.4 1.1.1.1. 3...3 523 rêve abc.f abc.c6 -n.fr abc.org a bc.fr ab. net to to to_to my_thing.com

Match tokens that are either IPv4 addresses or MAC addresses (three formats)

This extracts the first three octets of an IPv4 address, or the first half of an IPv6 address. This may be suitable for classifying addresses by address groups.

This pcre style regex tests for valid URLs capturing the whole address. It will capture http and https only. Compatible with multiple sub-domains and raw IPV4 addresses, as well as paths, queries, and parameters. See below for examples: Will match these valid URLS: https://www.example.com/foo/?bar=baz&inga=42&quux http://foo.com/blah_(wikipedia)#cite-1 http://foo.com/blah_(wikipedia)_blah#cite-1 http://foo.com/unicode_(✪)_in_parens http://foo.com/(something)?after=parens http://code.google.com/events/#&product=browser http://142.42.1.1/ http://142.42.1.1:8080/ Will NOT match though valid URLS http://✪df.ws/123 http://userid:password@example.com:8080 http://userid:password@example.com:8080/ http://userid@example.com http://userid@example.com/ http://userid@example.com:8080 http://userid@example.com:8080/ http://userid:password@example.com http://userid:password@example.com/ Does NOT and should not match these bad URLS: http:// http://. http://.. http://../ http://? http://?? http://??/ http://# http://## http://##/ http://foo.bar?q=Spaces should be encoded // //a ///a /// http:///a foo.com rdar://1234 h://test http:// shouldfail.com :// should fail http://foo.bar/foo(bar)baz quux ftps://foo.bar/ http://-error-.invalid/ http://a.b--c.de/ http://-a.b.co http://a.b-.co http://3628126748 http://.www.foo.bar/ http://www.foo.bar./ http://.www.foo.bar./ Its not perfect, it will match http://999.999.999.999 and similar invalid IPV4 addresses and is not optimized but met my needs.

Detects whether a given IPv6 string is within a reserved block, as defined on https://en.wikipedia.org/wiki/IPv6_address#Special_addresses Please note that this assume that the string given is already a valid IPv6 address - If IPv6 validation is important to you, please make sure you pass any string through a more general IPv6 validator before testing it against this regex. Also allows for extracting mapped IPv4 addresses from the IPv4 mapped address ranges.