Regular Expression to match an ssh connection string - regex

Question

I'm trying in vain to write a regular expression to match valid ssh connection strings.
I really only need to recognise strings of the format:
user#hostname:/some/path
but it would be nice to also match an implicit home directory:
user#hostname:
I've so-far come up with this regex:
/^[:alnum:]+\#\:(\/[:alnum:]+)*$/
which doesn't work as intended.
Any suggestions welcome before my brain explodes and I start speaking in line noise :)

Answer 1

Your supplied regex doesn't have the hostname section. Try:
/^[:alnum:]+\#[:alnum:\.]\:(\/[:alnum:]+)*$/
or
/^[A-Za-z][A-Za-z0-9_]*\#[A-Za-z][A-Za-z0-9_\.]*\:(\/[A-Za-z][A-Za-z0-9_]*)*$/
since I don't trust alnum without double brackets.
Also, :alnum: may not give you the required range for your sections. You can have "." characters in your host name and may also need to allow for "_" characters. And it's rare I've seen usernames or hostnames start with a non-alphabetic.
Just as a side note, I try to avoid the enhanced regexes since they don't run on all regex engines (I've been using UNIX for a long time). Unfortunately that makes my regexes ungainly (see above) and not overly internationalizable. Apologies for that.

Answer 2

Bracket expressions go inside their own brackets. You are matching any one of colon, 'a', 'l', 'm', 'n', or 'u'.
And like Pax said, you missed the hostname. But the bracket expressions are still wrong.

Answer 3

After some more revisions I'm using:
/^\w+\#(\w|\.)+\:(\/\w+)*$/
which seems to match my test cases and accounts for hostnames, FQDNs and IP addresses in the host portion. It also makes the path after the colon optional to allow for implicit home directories.
Thanks for the help so far - I didn't spot the lack of hostname until it was pointed out.

Answer 4

What sgm is getting at, is you are doing
/^[:alnum:]+\#\:(\/[:alnum:]+)*$/
Where you should be doing
/^[[:alnum:]]+\#\:(\/[[:alnum:]]+)*$/
Pax's answer is also practical, but won't work without the proper double bracketing.
my $at = q{#};
my #res = (
qr/^[:alnum:]+${at}[:alnum:]+:(\/[:alnum:]+)*$/,
qr/^[[:alnum:]]+${at}[[:alnum:]]+:(\/[[:alnum:]]+)*$/,
qr/^[a-z][[:alnum:]_]*${at}[a-z][[:alnum:]_.]*:(\/[^\/]*)*$/i,
);
my #u = qw{
user#hostname:/some/path
bob_foo#bobs.fish.stores.com:/foo/bar/baz/quux_
9foo#9foo.org:/9foo/9foo
baz#foo.org:/9foo/_#_numerics_are_fine_in_URI_and_so_is_anything_else_(virtually)
};
for my $str (#u) {
for my $re (#res) {
if ( $str =~ $re ) {
print "$str =~ $re\n";
}
else {
print "NOT $str =~ $re\n";
}
}
}
POSIX syntax [: :] belongs inside character classes in regex; marked by <-- HERE in m/^[:alnum:] <-- HERE +#[:alnum:]+:(/[:alnum:]+)*$/ at /tmp/egl.pl line 27.
POSIX syntax [: :] belongs inside character classes in regex; marked by <-- HERE in m/^[:alnum:]+#[:alnum:] <-- HERE +:(/[:alnum:]+)*$/ at /tmp/egl.pl line 27.
POSIX syntax [: :] belongs inside character classes in regex; marked by <-- HERE in m/^[:alnum:]+#[:alnum:]+:(/[:alnum:] <-- HERE +)*$/ at /tmp/egl.pl line 27.
NOT user#hostname:/some/path =~ (?-xism:^[:alnum:]+#[:alnum:]+:(/[:alnum:]+)*$)
user#hostname:/some/path =~ (?-xism:^[[:alnum:]]+#[[:alnum:]]+:(/[[:alnum:]]+)*$)
user#hostname:/some/path =~ (?i-xsm:^[a-z][[:alnum:]_]*#[a-z][[:alnum:]_.]*:(/[^/]*)*$)
NOT bob_foo#bobs.fish.stores.com:/foo/bar/baz/quux_ =~ (?-xism:^[:alnum:]+#[:alnum:]+:(/[:alnum:]+)*$)
NOT bob_foo#bobs.fish.stores.com:/foo/bar/baz/quux_ =~ (?-xism:^[[:alnum:]]+#[[:alnum:]]+:(/[[:alnum:]]+)*$)
bob_foo#bobs.fish.stores.com:/foo/bar/baz/quux_ =~ (?i-xsm:^[a-z][[:alnum:]_]*#[a-z][[:alnum:]_.]*:(/[^/]*)*$)
NOT 9foo#9foo.org:/9foo/9foo =~ (?-xism:^[:alnum:]+#[:alnum:]+:(/[:alnum:]+)*$)
NOT 9foo#9foo.org:/9foo/9foo =~ (?-xism:^[[:alnum:]]+#[[:alnum:]]+:(/[[:alnum:]]+)*$)
NOT 9foo#9foo.org:/9foo/9foo =~ (?i-xsm:^[a-z][[:alnum:]_]*#[a-z][[:alnum:]_.]*:(/[^/]*)*$)
NOT baz#foo.org:/9foo/_#_numerics_are_fine_in_URI_and_so_is_anything_else_(virtually) =~ (?-xism:^[:alnum:]+#[:alnum:]+:(/[:alnum:]+)*$)
NOT baz#foo.org:/9foo/_#_numerics_are_fine_in_URI_and_so_is_anything_else_(virtually) =~ (?-xism:^[[:alnum:]]+#[[:alnum:]]+:(/[[:alnum:]]+)*$)
baz#foo.org:/9foo/_#_numerics_are_fine_in_URI_and_so_is_anything_else_(virtually) =~ (?i-xsm:^[a-z][[:alnum:]_]*#[a-z][[:alnum:]_.]*:(/[^/]*)*$)

Answer 5

OK, further revision to:
/^\w+\#(\w|\.)+\:(\/(\w|.)+)*$/
to account for the . that might be present in a file name.

Answer 6

Final go:
/^\w+\#(\w|\.)+\:(\/(\w|.)+\/?)*$/
This also allows for an optional trailing slash.

Answer 7

These didn't quite do it for what I needed; as some were broke or not liberal enough. For example if you have a folder named stackoverflow.com not having dots would break it. Implementations are inconsistent about what \w means, so I wouldn't recommend using that, especially since we know darn well what characters we need.
The following is a bash example to construct the regex:
#should match 99.9% of SSH users
user_regex='[a-zA-Z][a-zA-Z0-9_]+'
#match domains
host_regex='([a-zA-Z][a-zA-Z0-9\-]*\.)*[a-zA-Z][a-zA-Z0-9\-]*'
#match paths starting with / and empty strings (which is valid for our use!)
path_regex='(\/[A-Za-z0-9_\-\.]+)*\/?'
#the complete regex
master_regex="^$user_regex\#$host_regex\:$path_regex\$"
This affords the modularity to check your parts later, if need be. To enable IP addresses in the match add 0-9 to the two first letter match portions of the host regex.