Reserved handle word check should be post-canonical

[wilwade]

Summary

A user can claim a handle very similar to those in the RESERVED_WORDS list by using Unicode characters.

Issue details

During the execution of the claim_handle extrinsic, the base handle, which is passed by the user, is validated by the validate_base_handle function. One of the checks in this function ensures that the handle is not part of a list of reserved words:

ensure!(!is_reserved_handle(&base_handle_str), Error::<T>::HandleIsNotAllowed);

The is_reserved_handle function does not check the canonical base representation of the base_handle_str. As a result, a user can create a handle which looks very similar to a reserved one.

As an example, the following test claims a handle with "here" as prefix, by using Unicode character "\u0435" instead of "e" for the first 'e':

fn claim_handle_unicode() {
	new_test_ext().execute_with(|| {
		let alice = sr25519::Pair::from_seed(&[0; 32]);
		let expiry = 100;
		let (payload, proof) =
			get_signed_claims_payload(&alice, "hеre".as_bytes().to_vec(), expiry);
		assert_ok!(Handles::claim_handle(
			RuntimeOrigin::signed(alice.public().into()),
			alice.public().into(),
			proof,
			payload
		));

	});
}

The code for the final handle creation correctly uses the base_handle_str with a suffix that does take the canonical representation into account. As a result, there will never be two handles that only differ by a similar Unicode character.

However, to prevent any kind of confusion, the check for reserved handles in the RESERVED_WORDS list should use the canonical representation.

Mitigation

A simple mitigation would be to adjust the is_reserved_handle function to check the canonicalized representations of the strings:

pub fn is_reserved_handle(input_str: &str) -> bool {
  RESERVED_WORDS.map(|w| convert_to_canonical(w)).contains(&convert_to_canonical(&input_str))
}

However for efficiency, reserved word map should be converted for the constant and test moved to after the canonical conversion of the input.