verify a signature in pallet

Question

I followed the answer of "how to verify a signature in a pallet", and try to verify some data signed by a private key on chain logic.

    #[pallet::weight(10_000)]
    pub fn my_verify(origin: OriginFor<T>, data: Vec<u8>, sig: T::Signature, from: T::PublicKey) -> DispatchResult{
        log::info!("--------public key is {:?}", from.clone().into_account());
        log::info!("--------signature is {:?}", sig.clone());
        log::info!("--------data is {:?}", data.clone());

        let ok = sig.verify(&data[..], &from.into_account());
        // `ok` is a bool. Use in an `if` or `ensure!`.
        ensure!(ok, <Error<T>>::SignatureVerifyError);
        Ok(())
    }

but I got false from sig.verify(). My config is exactly the same as the question's answer.

    #[pallet::config]
pub trait Config: frame_system::Config {
    /// A Signature can be verified with a specific `PublicKey`.
    /// The additional traits are boilerplate.
    type Signature: Verify<Signer = Self::PublicKey> + Encode + Decode + Member + TypeInfo;

    /// A PublicKey can be converted into an `AccountId`. This is required by the
    /// `Signature` type.
    /// The additional traits are boilerplate.
    type PublicKey: IdentifyAccount<AccountId = Self::PublicKey> + Encode + Decode + Member + TypeInfo;

    type Event: From<Event<Self>> + IsType<<Self as frame_system::Config>::Event>;

    #[pallet::constant]
    type MaxMinersOwned: Get<u32>;

    #[pallet::constant]
    type EpochCycle: Get<u32>;
}

and runtime config is like this:

impl pallet_xenon::Config for Runtime {
type Signature = sp_core::sr25519::Signature;
type PublicKey = sp_core::sr25519::Public;

type Event = Event;
type MaxMinersOwned = MaxMinersOwned;
type EpochCycle = EpochCycle;

}

So what mistake did I make? Help!!! Please!!!

my console shows the log output like this:

Answer 1

How did you create the signature that you are testing with?
I assume you used PolkadotJS? That will not work per default, but can easily be fixed.
PolkadotJS has the quirk of wrapping everything in <Bytes></Bytes> tags.
You can update your Rust code to expect this wrapping, or don't. Depending on your use-case.

Lets write some tests to verify the assumption. First do a test where we sign with Rust and verify with Rust:

#[test]
fn sig_verify_rust_works() {
    use sp_core::Pair;

    new_test_ext().execute_with(|| {
        let alice = sp_core::sr25519::Pair::from_string("//Alice", None).unwrap();
        let msg: Vec<u8> = b"The actual message".to_vec();
        let sig = alice.sign(&msg[..]);

        // Works as expected - no magic involved.
        assert_ok!(Example::my_verify(Origin::root(), msg, sig, alice.public()));
    });
}

Now a test where we try to verify a signature that was created by PolkadotJS:

#[test]
fn sig_verify_polkadotjs_works() {
    use sp_core::Pair;

    new_test_ext().execute_with(|| {
        let alice = sp_core::sr25519::Pair::from_string("//Alice", None).unwrap();
        
        // Signature on "The actual message" by Alice via PolkadotJS.
        let sig = b"860ab35af395c6cc989b0498269d26c13d488431f8ceac89ed82744eb84361162ce7f6c817575e46c07287f000397a0c3d5521577ac63e20ce1d0b3ab158cd88";
        let sig = hex::decode(sig).unwrap();
        let sig = sp_core::sr25519::Signature::from_slice(&sig[..]).unwrap();
        
        // This will not work since it's missing the wrapping:
        let msg: Vec<u8> = b"The actual message".to_vec();
        assert!(Example::my_verify(Origin::root(), msg, sig.clone(), alice.public()).is_err());

        // This will work since it's wrapped:
        let msg: Vec<u8> = b"<Bytes>The actual message</Bytes>".to_vec();
        assert!(Example::my_verify(Origin::root(), msg, sig, alice.public()).is_ok());
    });
}

As you can see: The <Bytes></Bytes> makes the difference.
Interestingly enough, PolkadotJS does accepts both as valid, with and without the wrapping.

If you are using something besides PolkadotJS, you need to pay attention to the Signing context as mentioned in the original post: How to verify a signature in a Pallet?.

Answer 2

I have met a similar(on ECDSA) problem before. But I'm not sure if this could help you. That takes me a whole night to debug(I think there are some bugs on my code before).

Finally, I found the substrate's signing & verification are a little bit different. For SR25519, the signing context is 'substrate', check sign & verify.

After I switch to https://github.com/paritytech/libsecp256k1, the issues were gone.