feat: add signMessageWithoutRand method for kaspa wasm

cli/src/modules/message.rs

@@ -1,5 +1,6 @@
 use kaspa_addresses::Version;
 use kaspa_bip32::secp256k1::XOnlyPublicKey;
+use kaspa_wallet_core::message::SignMessageOptions;
 use kaspa_wallet_core::{
     account::{BIP32_ACCOUNT_KIND, KEYPAIR_ACCOUNT_KIND},
     message::{sign_message, verify_message, PersonalMessage},
@@ -87,8 +88,9 @@ impl Message {
 
         let pm = PersonalMessage(message);
         let privkey = self.get_address_private_key(&ctx, kaspa_address).await?;
+        let sign_options = SignMessageOptions { no_aux_rand: false };
 
-        let sig_result = sign_message(&pm, &privkey);
+        let sig_result = sign_message(&pm, &privkey, &sign_options);
 
         match sig_result {
             Ok(signature) => {

wallet/core/src/message.rs

@@ -15,13 +15,28 @@ impl AsRef<[u8]> for PersonalMessage<'_> {
     }
 }
 
+#[derive(Clone)]
+pub struct SignMessageOptions {
+    /// The auxiliary randomness exists only to mitigate specific kinds of power analysis
+    /// side-channel attacks. Providing it definitely improves security, but omitting it
+    /// should not be considered dangerous, as most legacy signature schemes don't provide
+    /// mitigations against such attacks. To read more about the relevant discussions that
+    /// arose in adding this randomness please see: https://github.com/sipa/bips/issues/195
+    pub no_aux_rand: bool,
+}
+
 /// Sign a message with the given private key
-pub fn sign_message(msg: &PersonalMessage, privkey: &[u8; 32]) -> Result<Vec<u8>, Error> {
+pub fn sign_message(msg: &PersonalMessage, privkey: &[u8; 32], options: &SignMessageOptions) -> Result<Vec<u8>, Error> {
     let hash = calc_personal_message_hash(msg);
 
     let msg = secp256k1::Message::from_digest_slice(hash.as_bytes().as_slice())?;
     let schnorr_key = secp256k1::Keypair::from_seckey_slice(secp256k1::SECP256K1, privkey)?;
-    let sig: [u8; 64] = *schnorr_key.sign_schnorr(msg).as_ref();
+
+    let sig: [u8; 64] = if options.no_aux_rand {
+        *secp256k1::SECP256K1.sign_schnorr_no_aux_rand(&msg, &schnorr_key).as_ref()
+    } else {
+        *schnorr_key.sign_schnorr(msg).as_ref()
+    };
 
     Ok(sig.to_vec())
 }
@@ -74,7 +89,26 @@ mod tests {
         ])
         .unwrap();
 
-        verify_message(&pm, &sign_message(&pm, &privkey).expect("sign_message failed"), &pubkey).expect("verify_message failed");
+        let sign_with_aux_rand = SignMessageOptions { no_aux_rand: false };
+        let sign_with_no_aux_rand = SignMessageOptions { no_aux_rand: true };
+        verify_message(&pm, &sign_message(&pm, &privkey, &sign_with_aux_rand).expect("sign_message failed"), &pubkey)
+            .expect("verify_message failed");
+        verify_message(&pm, &sign_message(&pm, &privkey, &sign_with_no_aux_rand).expect("sign_message failed"), &pubkey)
+            .expect("verify_message failed");
+    }
+
+    #[test]
+    fn test_basic_sign_without_rand_twice_should_get_same_signature() {
+        let pm = PersonalMessage("Hello Kaspa!");
+        let privkey: [u8; 32] = [
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+        ];
+
+        let sign_with_no_aux_rand = SignMessageOptions { no_aux_rand: true };
+        let signature = sign_message(&pm, &privkey, &sign_with_no_aux_rand).expect("sign_message failed");
+        let signature_twice = sign_message(&pm, &privkey, &sign_with_no_aux_rand).expect("sign_message failed");
+        assert_eq!(signature, signature_twice);
     }
 
     #[test]
@@ -90,7 +124,12 @@ mod tests {
         ])
         .unwrap();
 
-        verify_message(&pm, &sign_message(&pm, &privkey).expect("sign_message failed"), &pubkey).expect("verify_message failed");
+        let sign_with_aux_rand = SignMessageOptions { no_aux_rand: false };
+        let sign_with_no_aux_rand = SignMessageOptions { no_aux_rand: true };
+        verify_message(&pm, &sign_message(&pm, &privkey, &sign_with_aux_rand).expect("sign_message failed"), &pubkey)
+            .expect("verify_message failed");
+        verify_message(&pm, &sign_message(&pm, &privkey, &sign_with_no_aux_rand).expect("sign_message failed"), &pubkey)
+            .expect("verify_message failed");
     }
 
     #[test]
@@ -110,7 +149,12 @@ Ut omnis magnam et accusamus earum rem impedit provident eum commodi repellat qu
         ])
         .unwrap();
 
-        verify_message(&pm, &sign_message(&pm, &privkey).expect("sign_message failed"), &pubkey).expect("verify_message failed");
+        let sign_with_aux_rand = SignMessageOptions { no_aux_rand: false };
+        let sign_with_no_aux_rand = SignMessageOptions { no_aux_rand: true };
+        verify_message(&pm, &sign_message(&pm, &privkey, &sign_with_aux_rand).expect("sign_message failed"), &pubkey)
+            .expect("verify_message failed");
+        verify_message(&pm, &sign_message(&pm, &privkey, &sign_with_no_aux_rand).expect("sign_message failed"), &pubkey)
+            .expect("verify_message failed");
     }
 
     #[test]

wallet/core/src/wasm/message.rs

@@ -14,6 +14,7 @@ const TS_MESSAGE_TYPES: &'static str = r#"
 export interface ISignMessage {
     message: string;
     privateKey: PrivateKey | string;
+    noAuxRand?: boolean;
 }
 "#;
 
@@ -30,10 +31,12 @@ pub fn js_sign_message(value: ISignMessage) -> Result<HexString, Error> {
     if let Some(object) = Object::try_from(&value) {
         let private_key = object.cast_into::<PrivateKey>("privateKey")?;
         let raw_msg = object.get_string("message")?;
+        let no_aux_rand = object.get_bool("noAuxRand").unwrap_or(false);
         let mut privkey_bytes = [0u8; 32];
         privkey_bytes.copy_from_slice(&private_key.secret_bytes());
         let pm = PersonalMessage(&raw_msg);
-        let sig_vec = sign_message(&pm, &privkey_bytes)?;
+        let sign_options = SignMessageOptions { no_aux_rand };
+        let sig_vec = sign_message(&pm, &privkey_bytes, &sign_options)?;
         privkey_bytes.zeroize();
         Ok(faster_hex::hex_string(sig_vec.as_slice()).into())
     } else {