Add support for wide characters in passwords.

The crypt function cannot handle most wide (Unicode) characters,
but does handle some by attempting to downgrade to an 8-but string.

In order to support wide characters in passwords while not breaking
any passwords which worked before this change, a password will be
encoded into UTF-8 before being sent to crypt only when crypt dies
on the original string.

Author: taniwallach

lib/WeBWorK/Authen.pm

@@ -54,6 +54,8 @@ use Date::Format;
 use Scalar::Util qw(weaken);
 use Mojo::Util qw(b64_encode b64_decode);
 
+use Encode qw(encode_utf8);
+
 use WeBWorK::Debug;
 use WeBWorK::Utils qw(x runtime_use);
 use WeBWorK::Utils::Logs qw(writeCourseLog);
@@ -633,8 +635,21 @@ sub checkPassword {
 	my $Password = $db->getPassword($userID);
 	if (defined $Password) {
 		# Check against the password in the database.
-		my $possibleCryptPassword = crypt $possibleClearPassword, $Password->password;
-		my $dbPassword            = $Password->password;
+		my $possibleCryptPassword = '';
+		# Wrap crypt in an eval to catch any "Wide character in crypt" errors.
+		# When such an error occurs - try to encode to UTF-8 and they run crypt.
+		eval { $possibleCryptPassword = crypt $possibleClearPassword, $Password->password; };
+		if ($@) {
+			if ($@ =~ /Wide char/) {
+				my $utf8possibleClearPassword = encode_utf8($possibleClearPassword);
+				$possibleCryptPassword = crypt $utf8possibleClearPassword, $Password->password;
+			} else {
+				$self->write_log_entry('AUTH WWDB: submitted password rejected - failure in crypt');
+				return 0;
+			}
+		}
+
+		my $dbPassword = $Password->password;
 		# This next line explicitly insures that blank or null passwords from the database can never succeed in matching
 		# an entered password.  This also rejects cases when the database has a crypted password which matches a
 		# submitted all white-space or null password by requiring that the $possibleClearPassword contain some non-space

lib/WeBWorK/ContentGenerator/Options.pm

@@ -56,7 +56,16 @@ sub initialize ($c) {
 				$userID ne $effectiveUserID ? eval { $db->getPassword($c->{effectiveUser}->user_id) } : $password;
 
 			# Check that either password is not defined or if it is defined then we have the right one.
-			if (!defined $password || crypt($currP // '', $password->password) eq $password->password) {
+			my $cryptedCurrP;
+			if (defined $password) {
+				# Wrap crypt in an eval to catch any "Wide character in crypt" errors.
+				# If crypt fails due to a wide character, encode to UTF-8 before calling crypt.
+				eval { $cryptedCurrP = crypt($currP // '', $password->password); };
+				if ($@ && $@ =~ /Wide char/) {
+					$cryptedCurrP = crypt(Encode::encode_utf8($currP), $password->password);
+				}
+			}
+			if (!defined $password || $cryptedCurrP eq $password->password) {
 				my $e_user_name = $c->{effectiveUser}->first_name . ' ' . $c->{effectiveUser}->last_name;
 				if ($newP eq $confirmP) {
 					if (!defined $effectiveUserPassword) {

lib/WeBWorK/Utils.pm

@@ -151,7 +151,18 @@ sub cryptPassword ($clearPassword) {
 		$salt .= ('.', '/', '0' .. '9', 'A' .. 'Z', 'a' .. 'z')[ rand 64 ];
 	}
 
-	return crypt(trim_spaces($clearPassword), $salt);
+	# crypt does not support much beyond ASCII and fails on most wide
+	# characters. Work around this without changing behavior whenever
+	# crypt works as-is, so as not to break existing passwords which
+	# worked before the change.
+	my $cryptedPassord = '';
+	eval { $cryptedPassord = crypt(trim_spaces($clearPassword), $salt); };
+	if ($@ && $@ =~ /Wide char/) {
+		# Try to encode to UTF-8 and they run crypt
+		$cryptedPassord = crypt(Encode::encode_utf8(trim_spaces($clearPassword)), $salt);
+	}
+
+	return $cryptedPassord;
 }
 
 sub undefstr ($default, @values) {