diff --git a/src/backend_task/dashpay/auto_accept_proof.rs b/src/backend_task/dashpay/auto_accept_proof.rs index 31cd344de..cfa8e52a7 100644 --- a/src/backend_task/dashpay/auto_accept_proof.rs +++ b/src/backend_task/dashpay/auto_accept_proof.rs @@ -1,6 +1,7 @@ use crate::backend_task::error::TaskError; use crate::model::dashpay_derivation::derive_auto_accept_key; use crate::model::qualified_identity::QualifiedIdentity; +use dash_sdk::dpp::dashcore::ecdsa::EcdsaSecretKey; use dash_sdk::dpp::identity::accessors::IdentityGettersV0; use dash_sdk::dpp::identity::{KeyType, Purpose, SecurityLevel}; use dash_sdk::dpp::secp256k1::Message; @@ -209,15 +210,13 @@ pub fn create_auto_accept_proof_bytes_with_key( hasher.update(&message_data); let message_hash = hasher.finalize(); - // Create secp256k1 message and sign - - let message = Message::from_digest(message_hash.into()); - - let secret_key = dash_sdk::dpp::secp256k1::SecretKey::from_secret_bytes(*(signing_key_bytes)) + // Sign the digest. The key erases itself when it drops. The signature is + // low-S with a low R ground as Dash Core grinds it; any ECDSA verifier + // accepts it. + let secret_key = EcdsaSecretKey::from_bytes(signing_key_bytes) .map_err(|e| format!("Failed to create secret key: {}", e))?; - let signature = dash_sdk::dpp::secp256k1::ecdsa::sign(message, &secret_key); - let sig_bytes = signature.serialize_compact(); + let sig_bytes = secret_key.sign(&message_hash.into()).to_bytes(); // Build the proof bytes let mut proof_bytes = Vec::new(); @@ -308,3 +307,59 @@ pub async fn verify_auto_accept_proof( } // No local persistence required + +#[cfg(test)] +mod tests { + use super::*; + use dash_sdk::dpp::secp256k1::{PublicKey, SecretKey, ecdsa}; + + /// The proof's signature verifies, the way `verify_auto_accept_proof` + /// checks it, against the public key of the key it was signed with. The + /// signature is low-S with a low R ground as Dash Core grinds it; R lands + /// low half the time on its own, so this signs for many accounts. + #[test] + fn proof_signature_verifies_and_has_low_r() { + let key_bytes = [0x2Bu8; 32]; + let public_key = + PublicKey::from_secret_key(&SecretKey::from_secret_bytes(key_bytes).expect("valid")); + let sender = Identifier::from([0x01; 32]); + let recipient = Identifier::from([0x02; 32]); + let expires_at = 1_900_000_000u64; + + for account_reference in 0..32u32 { + let proof = create_auto_accept_proof_bytes_with_key( + expires_at, + &key_bytes, + &sender, + &recipient, + account_reference, + ) + .expect("proof"); + + assert_eq!(proof[0], 0, "key type"); + assert_eq!( + &proof[1..5], + &(expires_at as u32).to_be_bytes(), + "key index" + ); + assert_eq!(proof[5], 64, "signature size"); + assert_eq!(proof.len(), 6 + 64); + + let mut message_data = Vec::new(); + message_data.extend_from_slice(&sender.to_buffer()); + message_data.extend_from_slice(&recipient.to_buffer()); + message_data.extend_from_slice(&account_reference.to_le_bytes()); + let digest: [u8; 32] = Sha256::digest(&message_data).into(); + + let signature = ecdsa::Signature::from_compact(&proof[6..]).expect("compact"); + let mut normalized = signature; + normalized.normalize_s(); + assert_eq!(normalized, signature, "high S for {account_reference}"); + assert!( + ecdsa::verify(&signature, Message::from_digest(digest), &public_key).is_ok(), + "proof does not verify for {account_reference}" + ); + assert!(proof[6] < 0x80, "R is not low for {account_reference}"); + } + } +} diff --git a/src/backend_task/dashpay/encryption.rs b/src/backend_task/dashpay/encryption.rs index e6f11be17..56ec3e64d 100644 --- a/src/backend_task/dashpay/encryption.rs +++ b/src/backend_task/dashpay/encryption.rs @@ -4,9 +4,49 @@ use cbc; use dash_sdk::dpp::identity::IdentityPublicKey; use dash_sdk::dpp::identity::KeyType; use dash_sdk::dpp::identity::identity_public_key::accessors::v0::IdentityPublicKeyGettersV0; -use dash_sdk::dpp::secp256k1::{PublicKey, SecretKey}; +use dash_sdk::dpp::secp256k1::{self, PublicKey}; use sha2::{Digest, Sha256}; -use zeroize::Zeroizing; +use zeroize::{Zeroize, ZeroizeOnDrop, Zeroizing}; + +/// A secp256k1 secret key erased when dropped, for the ECDH below. +/// +/// `secp256k1::SecretKey` is `Copy` with no `Drop`, so a plain one would +/// outlive the exchange in freed memory. Everywhere else DET uses the +/// self-erasing `EcdsaSecretKey`, which has no ECDH; this keeps the raw +/// secp256k1 ECDH (unchanged output) and overwrites the key once it is done. +/// +/// The erase is best effort: it uses secp256k1's volatile `non_secure_erase`, +/// and the compiler may still have moved the bytes elsewhere before. Not +/// `Clone`/`Copy` on purpose, so the only copy is the one that gets erased. +struct EcdhSecretKey(secp256k1::SecretKey); + +impl EcdhSecretKey { + /// Build a secret key from a 32-byte scalar, refusing zero and values not + /// below the curve order. + fn from_secret_bytes(scalar: &[u8; 32]) -> Result { + let mut source = secp256k1::SecretKey::from_secret_bytes(*scalar)?; + let key = Self(source); + // `SecretKey` is `Copy`, so wrapping it copies the scalar; erase the + // local copy as well so only the wrapped one remains. + source.non_secure_erase(); + Ok(key) + } +} + +impl Zeroize for EcdhSecretKey { + /// Overwrite the held key through secp256k1's volatile erase. + fn zeroize(&mut self) { + self.0.non_secure_erase(); + } +} + +impl ZeroizeOnDrop for EcdhSecretKey {} + +impl Drop for EcdhSecretKey { + fn drop(&mut self) { + self.zeroize(); + } +} /// Generate ECDH shared key according to DashPay DIP-15 /// Uses libsecp256k1_ecdh method: SHA256((y[31]&0x1|0x2) || x) @@ -19,10 +59,8 @@ pub fn generate_ecdh_shared_key( public_key: &IdentityPublicKey, ) -> Result, String> { // Parse the private key - let secret_key = SecretKey::from_secret_bytes( - private_key - .try_into() - .map_err(|_| "Invalid private key length".to_string())?, + let secret_key = EcdhSecretKey::from_secret_bytes( + <&[u8; 32]>::try_from(private_key).map_err(|_| "Invalid private key length".to_string())?, ) .map_err(|e| format!("Invalid private key: {}", e))?; @@ -36,10 +74,7 @@ pub fn generate_ecdh_shared_key( // Perform ECDH to get shared secret. The 64-byte point is secret; // hold it in `Zeroizing` so it is wiped once the key is hashed out. let shared_secret = Zeroizing::new( - dash_sdk::dpp::secp256k1::ecdh::shared_secret_point( - &public_key, - &secret_key, - ), + secp256k1::ecdh::shared_secret_point(&public_key, &secret_key.0), ); // Extract x and y coordinates (64 bytes total: 32 + 32) @@ -299,6 +334,27 @@ mod tests { use bip39::rand::{self, RngCore}; use dash_sdk::dpp::secp256k1::{PublicKey, SecretKey}; + /// The zeroize that `Drop` runs leaves none of the original key bytes + /// behind. Checked through `zeroize` itself, because reading a value after + /// its drop has run is not allowed. + #[test] + fn ecdh_secret_key_zeroize_overwrites_the_key() { + let scalar = [0x5a; 32]; + let mut key = EcdhSecretKey::from_secret_bytes(&scalar).expect("valid scalar"); + assert_eq!(key.0.to_secret_bytes(), scalar); + + key.zeroize(); + + assert_ne!(key.0.to_secret_bytes(), scalar); + } + + /// The ECDH key refuses the same invalid scalars secp256k1 does. + #[test] + fn ecdh_secret_key_rejects_invalid_scalar() { + assert!(EcdhSecretKey::from_secret_bytes(&[0; 32]).is_err()); + assert!(EcdhSecretKey::from_secret_bytes(&[0xff; 32]).is_err()); + } + fn generate_test_shared_key() -> [u8; 32] { let mut shared_key = [0u8; 32]; rand::thread_rng().fill_bytes(&mut shared_key); diff --git a/src/backend_task/wallet/derive_identity_key_for_display.rs b/src/backend_task/wallet/derive_identity_key_for_display.rs index 52dd10322..777a286ef 100644 --- a/src/backend_task/wallet/derive_identity_key_for_display.rs +++ b/src/backend_task/wallet/derive_identity_key_for_display.rs @@ -28,9 +28,9 @@ impl AppContext { let network = self.network; let wif = self .with_identity_secret_key(identity_id, target.clone(), key_id, |secret_key| { - let private_key = - PrivateKey::from_byte_array(secret_key.as_secret_bytes(), network) - .map_err(|_| TaskError::IdentityKeyMalformed)?; + // Identity keys are compressed by convention. The clone erases + // itself when `private_key` drops. + let private_key = PrivateKey::new(secret_key.clone(), network); Ok(Secret::new(private_key.to_wif())) }) .await?; diff --git a/src/backend_task/wallet/mod.rs b/src/backend_task/wallet/mod.rs index 1a74dbbdb..f81983fc3 100644 --- a/src/backend_task/wallet/mod.rs +++ b/src/backend_task/wallet/mod.rs @@ -18,7 +18,7 @@ use crate::model::qualified_identity::PrivateKeyTarget; use crate::model::wallet::WalletSeedHash; use dash_sdk::dpp::address_funds::PlatformAddress; use dash_sdk::dpp::balances::credits::Credits; -use dash_sdk::dpp::dashcore::ecdsa::EcdsaRecSignature; +use dash_sdk::dpp::dashcore::ecdsa::{EcdsaRecSignature, EcdsaSecretKey}; use dash_sdk::dpp::dashcore::hashes::Hash; use dash_sdk::dpp::dashcore::sign_message::{self, signed_msg_hash}; use dash_sdk::dpp::dashcore::{OutPoint, PrivateKey}; @@ -26,7 +26,6 @@ use dash_sdk::dpp::identity::core_script::CoreScript; use dash_sdk::dpp::identity::identity_public_key::accessors::v0::IdentityPublicKeyGettersV0; use dash_sdk::dpp::identity::{KeyID, KeyType}; use dash_sdk::dpp::key_wallet::bip32::DerivationPath; -use dash_sdk::dpp::secp256k1::{Message, SecretKey}; use dash_sdk::platform::Identifier; use std::collections::BTreeMap; use std::sync::Arc; @@ -37,30 +36,30 @@ use std::sync::Arc; /// a verifier can recover the signer's public key from the signature alone. /// Shared by the wallet-key and identity-key message-signing tasks. /// +/// The recoverable signature is plain RFC 6979 (no low-R grinding), so the +/// envelope bytes match every earlier build. [`EcdsaSecretKey`] marks every +/// key compressed, so the envelope is rebuilt with the caller's flag. +/// /// # Errors /// /// [`TaskError::WalletMessageSigningFailed`] if the signature cannot be put /// in the envelope; the detail is logged. pub(crate) fn dash_signed_message( message: &str, - secret_key: &SecretKey, + secret_key: &EcdsaSecretKey, compressed: bool, ) -> Result { let message_hash = signed_msg_hash(message); - let digest = Message::from_digest(*message_hash.as_byte_array()); - let recoverable = dash_sdk::dpp::secp256k1::ecdsa::RecoverableSignature::sign_ecdsa_recoverable( - digest, secret_key, - ); - let (recovery_id, _) = recoverable.serialize_compact(); - let envelope = EcdsaRecSignature::from_parts( - recoverable.to_standard().into(), - recovery_id.to_u8(), - compressed, - ) - .map_err(|detail| { - tracing::warn!(error = %detail, "Sign-message envelope construction failed"); - TaskError::WalletMessageSigningFailed - })?; + let recoverable = secret_key.sign_recoverable(message_hash.as_byte_array()); + let envelope = recoverable + .signature() + .and_then(|signature| { + EcdsaRecSignature::from_parts(signature, recoverable.recovery_id()?, compressed) + }) + .map_err(|detail| { + tracing::warn!(error = %detail, "Sign-message envelope construction failed"); + TaskError::WalletMessageSigningFailed + })?; Ok(sign_message::to_base64(envelope)) } @@ -118,10 +117,10 @@ impl AppContext { } /// Resolve the vault-backed identity key at `(identity_id, target, - /// key_id)` through the JIT chokepoint and hand its `SecretKey` to `f`. - /// The raw key zeroizes when the closure returns — only `f`'s result - /// crosses back to the caller. Shared by the identity-key sign and - /// display tasks. + /// key_id)` through the JIT chokepoint and lend it to `f` as an + /// [`EcdsaSecretKey`]. The raw key and the parsed key are both wiped when + /// the closure returns — only `f`'s result crosses back to the caller. + /// Shared by the identity-key sign and display tasks. /// /// The placement is the caller's word, and it addresses the vault label /// directly, so the bytes are matched against the public key the stored @@ -150,7 +149,7 @@ impl AppContext { identity_id: Identifier, target: PrivateKeyTarget, key_id: KeyID, - f: impl FnOnce(SecretKey) -> Result, + f: impl FnOnce(&EcdsaSecretKey) -> Result, ) -> Result { let identity = self .get_local_qualified_identity(&identity_id)? @@ -200,7 +199,7 @@ impl AppContext { .ok_or(TaskError::IdentityKeyMissing)?; // Present-but-malformed key bytes are distinct from a // genuinely absent key and from a signing/derivation failure. - let secret_key = SecretKey::from_secret_bytes(*key).map_err(|detail| { + let secret_key = EcdsaSecretKey::from_bytes(key).map_err(|detail| { tracing::warn!(error = %detail, "Identity-key secret construction failed"); TaskError::IdentityKeyMalformed })?; @@ -216,7 +215,7 @@ impl AppContext { ); return Err(TaskError::IdentityKeyMismatch); } - f(secret_key) + f(&secret_key) }) .await } @@ -398,7 +397,7 @@ mod tests { use dash_sdk::dpp::identity::{Identity, Purpose, SecurityLevel}; use dash_sdk::dpp::key_wallet::bip32::ChildNumber; use dash_sdk::dpp::platform_value::BinaryData; - use dash_sdk::dpp::secp256k1::PublicKey; + use dash_sdk::dpp::secp256k1::{PublicKey, SecretKey}; use dash_sdk::dpp::version::PlatformVersion; use dash_sdk::platform::IdentityPublicKey; use std::sync::atomic::{AtomicBool, Ordering}; @@ -523,8 +522,10 @@ mod tests { /// hardcoded recovery header would fail ~50% of the time here. Both the /// wallet-key and identity-key signers call this one helper. fn assert_recovers(compressed: bool) { - let secret_key = SecretKey::from_secret_bytes([0x42u8; 32]).expect("valid secret"); - let expected_pubkey = PublicKey::from_secret_key(&secret_key); + let secret_key = EcdsaSecretKey::from_bytes(&[0x42u8; 32]).expect("valid secret"); + let expected_pubkey = PublicKey::from_secret_key( + &SecretKey::from_secret_bytes([0x42u8; 32]).expect("valid secret"), + ); let message = "Bilby was here"; let base64 = dash_signed_message(message, &secret_key, compressed).expect("signs"); @@ -539,16 +540,20 @@ mod tests { /// The envelope keeps the layout the previous encoder produced: a header /// byte `27 + recovery id` (`+ 4` when compressed), then the compact - /// `r || s` of the same deterministic signature. + /// `r || s` of the same deterministic signature. The reference signs with + /// the raw secp256k1 primitive, so this also proves the signature bytes + /// did not change when signing moved to `EcdsaSecretKey`. #[test] fn the_envelope_keeps_its_byte_layout() { use dash_sdk::dpp::secp256k1::Message; use dash_sdk::dpp::secp256k1::ecdsa::RecoverableSignature; let message = "Bilby was here"; - let secret_key = SecretKey::from_secret_bytes([0x42u8; 32]).expect("valid secret"); + let reference_key = SecretKey::from_secret_bytes([0x42u8; 32]).expect("valid secret"); + let secret_key = EcdsaSecretKey::from_bytes(&[0x42u8; 32]).expect("valid secret"); let digest = Message::from_digest(*signed_msg_hash(message).as_byte_array()); let (recovery_id, compact) = - RecoverableSignature::sign_ecdsa_recoverable(digest, &secret_key).serialize_compact(); + RecoverableSignature::sign_ecdsa_recoverable(digest, &reference_key) + .serialize_compact(); for compressed in [false, true] { let mut expected = [0u8; 65]; expected[0] = 27 + recovery_id.to_u8() + if compressed { 4 } else { 0 }; @@ -642,7 +647,7 @@ mod tests { let bytes = fixture .ctx - .with_identity_secret_key(identity_id, MAIN, 7, |key| Ok(key.to_secret_bytes())) + .with_identity_secret_key(identity_id, MAIN, 7, |key| Ok(*key.to_bytes())) .await .expect("a key that matches its record must resolve"); @@ -785,7 +790,7 @@ mod tests { let bytes = fixture .ctx - .with_identity_secret_key(identity_id, MAIN, 7, |key| Ok(key.to_secret_bytes())) + .with_identity_secret_key(identity_id, MAIN, 7, |key| Ok(*key.to_bytes())) .await .expect("the sibling placement's live bytes must be served"); diff --git a/src/backend_task/wallet/sign_message_with_identity_key.rs b/src/backend_task/wallet/sign_message_with_identity_key.rs index fc383e5ee..96cb87598 100644 --- a/src/backend_task/wallet/sign_message_with_identity_key.rs +++ b/src/backend_task/wallet/sign_message_with_identity_key.rs @@ -34,7 +34,7 @@ impl AppContext { let signature = self .with_identity_secret_key(identity_id, target.clone(), key_id, |secret_key| { // Identity keys are compressed by convention. - dash_signed_message(message.as_str(), &secret_key, true) + dash_signed_message(message.as_str(), secret_key, true) }) .await?; diff --git a/src/backend_task/wallet/sign_message_with_key.rs b/src/backend_task/wallet/sign_message_with_key.rs index e2d0bf60d..2a3b10840 100644 --- a/src/backend_task/wallet/sign_message_with_key.rs +++ b/src/backend_task/wallet/sign_message_with_key.rs @@ -8,7 +8,6 @@ use crate::context::AppContext; use crate::model::wallet::WalletSeedHash; use dash_sdk::dpp::identity::KeyType; use dash_sdk::dpp::key_wallet::bip32::DerivationPath; -use dash_sdk::dpp::secp256k1::SecretKey; use std::sync::Arc; impl AppContext { @@ -40,12 +39,11 @@ impl AppContext { &derivation_path, TaskError::WalletMessageSigningFailed, |private_key| { - let secret_key = SecretKey::from_secret_bytes(*private_key.inner.to_bytes()) - .map_err(|detail| { - tracing::warn!(error = %detail, "Sign-message secret key construction failed"); - TaskError::WalletMessageSigningFailed - })?; - dash_signed_message(message.as_str(), &secret_key, private_key.compressed) + dash_signed_message( + message.as_str(), + &private_key.inner, + private_key.compressed, + ) }, ) .await?; diff --git a/src/model/dashpay_derivation/dip14.rs b/src/model/dashpay_derivation/dip14.rs index 7bb826d2b..7c7c3a755 100644 --- a/src/model/dashpay_derivation/dip14.rs +++ b/src/model/dashpay_derivation/dip14.rs @@ -1,5 +1,5 @@ use dash_sdk::dpp::dashcore::Network; -use dash_sdk::dpp::dashcore::ecdsa::EcdsaPublicKey; +use dash_sdk::dpp::dashcore::ecdsa::{EcdsaError, EcdsaPublicKey, EcdsaSecretKey}; use dash_sdk::dpp::dashcore::hashes::hmac::{Hmac, HmacEngine}; use dash_sdk::dpp::dashcore::hashes::sha512; /// DIP-14 compliant 256-bit HD key derivation implementation @@ -8,8 +8,8 @@ use dash_sdk::dpp::dashcore::hashes::sha512; /// as specified in DIP-0014 for DashPay contact relationships. use dash_sdk::dpp::dashcore::hashes::{Hash, HashEngine}; use dash_sdk::dpp::key_wallet::bip32::{ChainCode, ExtendedPrivKey, ExtendedPubKey, Fingerprint}; -use dash_sdk::dpp::secp256k1::SecretKey; use dash_sdk::platform::Identifier; +use zeroize::Zeroizing; use super::DerivationError; @@ -56,17 +56,15 @@ pub fn ckd_priv_256( } let hmac_result = Hmac::::from_engine(hmac_engine); - let hmac_bytes = hmac_result.to_byte_array(); + let hmac_bytes = Zeroizing::new(hmac_result.to_byte_array()); // Split into I_L (first 32 bytes) and I_R (last 32 bytes) let (i_l, i_r) = hmac_bytes.split_at(32); // Parse I_L as a private key (refusing zero and values >= n) and add it // to the parent key. - let i_l: &[u8; 32] = i_l - .try_into() - .map_err(|_| dash_sdk::dpp::secp256k1::Error::InvalidSecretKey)?; - SecretKey::from_secret_bytes(*i_l)?; + let i_l: &[u8; 32] = i_l.try_into().map_err(|_| EcdsaError::InvalidSecretKey)?; + EcdsaSecretKey::from_bytes(i_l)?; // k_i = parse_256(I_L) + k_par (mod n) let child_key = parent_key.private_key.add_tweak(i_l)?; diff --git a/src/model/dashpay_derivation/mod.rs b/src/model/dashpay_derivation/mod.rs index 24a2aaad5..5ed877885 100644 --- a/src/model/dashpay_derivation/mod.rs +++ b/src/model/dashpay_derivation/mod.rs @@ -22,10 +22,6 @@ pub enum DerivationError { #[error("The wallet keys could not be derived. The wallet data may be invalid.")] Bip32(#[from] dash_sdk::dpp::key_wallet::bip32::Error), - /// A secp256k1 operation on derived key material failed. - #[error("The wallet key material could not be processed. The wallet data may be invalid.")] - Secp256k1(#[from] dash_sdk::dpp::secp256k1::Error), - /// An ECDSA operation on derived key material failed. #[error("The wallet key material could not be processed. The wallet data may be invalid.")] Ecdsa(#[from] dash_sdk::dpp::dashcore::ecdsa::EcdsaError), diff --git a/src/model/qualified_identity/mod.rs b/src/model/qualified_identity/mod.rs index 3dd57c599..27e908b85 100644 --- a/src/model/qualified_identity/mod.rs +++ b/src/model/qualified_identity/mod.rs @@ -443,12 +443,12 @@ impl Signer for QualifiedIdentity { // If there's a mismatch (due to incorrect stored derivation path), regenerate the correct path if identity_public_key.key_type() == KeyType::ECDSA_HASH160 { use dash_sdk::dpp::dashcore::PublicKey; + use dash_sdk::dpp::dashcore::ecdsa::EcdsaSecretKey; use dash_sdk::dpp::dashcore::hashes::{Hash, ripemd160, sha256}; - use dash_sdk::dpp::secp256k1::SecretKey; let platform_key_data = identity_public_key.data().as_slice(); - if let Ok(secret_key) = SecretKey::from_secret_bytes(*private_key) { + if let Ok(secret_key) = EcdsaSecretKey::from_bytes(&private_key) { let derived_pubkey = PublicKey::new(secret_key.public_key()); let pubkey_bytes = derived_pubkey.to_bytes(); let sha256_hash = sha256::Hash::hash(&pubkey_bytes); diff --git a/src/ui/identity/keys/key_info_screen.rs b/src/ui/identity/keys/key_info_screen.rs index 692088e5c..c8ccdceea 100644 --- a/src/ui/identity/keys/key_info_screen.rs +++ b/src/ui/identity/keys/key_info_screen.rs @@ -33,6 +33,7 @@ use crate::wallet_backend::IdentityKeyView; use crate::wallet_backend::secret_seam::SecretScheme; use dash_sdk::dashcore_rpc::dashcore::PrivateKey as RPCPrivateKey; use dash_sdk::dpp::dashcore::address::Payload; +use dash_sdk::dpp::dashcore::ecdsa::EcdsaSecretKey; use dash_sdk::dpp::dashcore::hashes::Hash; use dash_sdk::dpp::dashcore::{Address, PrivateKey, PubkeyHash, ScriptHash}; use dash_sdk::dpp::identity::KeyType; @@ -43,7 +44,6 @@ use dash_sdk::dpp::identity::identity_public_key::accessors::v0::IdentityPublicK use dash_sdk::dpp::identity::identity_public_key::contract_bounds::ContractBounds; use dash_sdk::dpp::key_wallet::bip32::DerivationPath; use dash_sdk::dpp::platform_value::string_encoding::Encoding; -use dash_sdk::dpp::secp256k1::SecretKey; use dash_sdk::platform::IdentityPublicKey; use eframe::egui::{self}; use egui::{Color32, RichText, ScrollArea}; @@ -1302,7 +1302,7 @@ impl KeyInfoScreen { /// are compressed by convention, so a verifier can recover the signer's /// public key and address from the signature alone. fn sign_ecdsa_local(private_key_bytes: &[u8; 32], message: &str) -> Result { - let secret_key = SecretKey::from_secret_bytes(*private_key_bytes) + let secret_key = EcdsaSecretKey::from_bytes(private_key_bytes) .expect("clear private key is a valid 32-byte secret"); crate::backend_task::wallet::dash_signed_message(message, &secret_key, true) } @@ -1785,6 +1785,7 @@ mod tests { use dash_sdk::dpp::identity::identity_public_key::v0::IdentityPublicKeyV0; use dash_sdk::dpp::identity::{Identity, KeyID, KeyType, Purpose, SecurityLevel}; use dash_sdk::dpp::platform_value::BinaryData; + use dash_sdk::dpp::secp256k1::SecretKey; use dash_sdk::dpp::version::PlatformVersion; use dash_sdk::platform::Identifier; use std::collections::BTreeMap; diff --git a/src/wallet_backend/det_signer.rs b/src/wallet_backend/det_signer.rs index 84df4f0e4..e33f13e75 100644 --- a/src/wallet_backend/det_signer.rs +++ b/src/wallet_backend/det_signer.rs @@ -35,10 +35,10 @@ use async_trait::async_trait; use dash_sdk::dpp::dashcore::Network; -use dash_sdk::dpp::dashcore::ecdsa::{EcdsaPublicKey, EcdsaSignature}; +use dash_sdk::dpp::dashcore::ecdsa::{EcdsaError, EcdsaPublicKey, EcdsaSecretKey, EcdsaSignature}; use dash_sdk::dpp::key_wallet::bip32::{DerivationPath, ExtendedPrivKey, ExtendedPubKey}; use dash_sdk::dpp::key_wallet::signer::{ExtendedPubKeySigner, Signer, SignerMethod}; -use dash_sdk::dpp::secp256k1::{self, Message, PublicKey, ecdsa}; +use dash_sdk::dpp::secp256k1::ecdsa; use zeroize::Zeroizing; use crate::wallet_backend::secret_access::SecretPlaintext; @@ -51,22 +51,15 @@ pub enum DetSignerError { /// Derivation from the held seed failed. #[error("just-in-time signer key derivation failed")] Derive(#[source] dash_sdk::dpp::key_wallet::bip32::Error), - /// secp256k1 sign / digest construction failed. + /// The held single key is not a valid secp256k1 secret key. #[error("just-in-time signer secp256k1 operation failed")] - Sign(#[source] secp256k1::Error), + Sign(#[source] EcdsaError), /// The held secret is the wrong kind for the requested operation /// (e.g. a single-key plaintext asked for path-based HD signing). #[error("just-in-time signer received the wrong secret kind for this operation")] WrongSecretKind, } -/// Hash a 32-byte digest into an ECDSA-ready [`Message`], surfacing the -/// upstream digest-length error as a typed signer error rather than -/// panicking. -fn message_from_digest(digest: [u8; 32]) -> Result { - Ok(Message::from_digest(digest)) -} - /// JIT [`Signer`] backed by a **borrowed** held secret. /// /// Constructed from a [`SecretPlaintext`] borrow inside a @@ -121,65 +114,27 @@ impl<'a> DetSigner<'a> { } } - /// Derive the secp256k1 secret at `path` from the held HD seed. Errors - /// with [`DetSignerError::WrongSecretKind`] if the held secret is a - /// single key (no derivation tree). - /// - /// Signing stays on the secp256k1 primitive (plain RFC 6979 nonce), so - /// signatures are byte-identical to earlier builds; the newer - /// `EcdsaSecretKey::sign` grinds for a low R and would change them. - fn derive_secret(&self, path: &DerivationPath) -> Result { - let scalar = self.derive_xprv(path)?.private_key.to_bytes(); - ErasedSecretKey::from_scalar(&scalar) - } - /// Sign `msg` (a 32-byte digest) with the held **single key** directly, /// no derivation. Errors if the held secret is an HD seed. Used by the /// JIT single-key signing chokepoint /// ([`WalletBackend::sign_single_key`](super::WalletBackend::sign_single_key)). + /// + /// The signature is low-S with a low R ground as Dash Core grinds it (see + /// [`EcdsaSecretKey::sign`]); the key erases itself when it drops. pub(crate) fn sign_single_key_ecdsa( &self, msg: &[u8; 32], ) -> Result { match &self.secret { HeldSecret::SingleKey(key) => { - let sk = ErasedSecretKey::from_scalar(key)?; - let message = message_from_digest(*msg)?; - Ok(dash_sdk::dpp::secp256k1::ecdsa::sign(message, &sk)) + let secret = EcdsaSecretKey::from_bytes(key).map_err(DetSignerError::Sign)?; + Ok(secret.sign(msg).into()) } HeldSecret::HdSeed(_) => Err(DetSignerError::WrongSecretKind), } } } -/// A secp256k1 secret key erased when dropped. secp256k1's own type keeps its -/// bytes after use, while the derived key it is built from would have wiped -/// them; this keeps the signing primitive (byte-identical signatures) without -/// leaving the key behind in freed memory. -struct ErasedSecretKey(secp256k1::SecretKey); - -impl ErasedSecretKey { - fn from_scalar(scalar: &[u8; 32]) -> Result { - secp256k1::SecretKey::from_secret_bytes(*scalar) - .map(Self) - .map_err(DetSignerError::Sign) - } -} - -impl std::ops::Deref for ErasedSecretKey { - type Target = secp256k1::SecretKey; - - fn deref(&self) -> &Self::Target { - &self.0 - } -} - -impl Drop for ErasedSecretKey { - fn drop(&mut self) { - self.0.non_secure_erase(); - } -} - impl std::fmt::Debug for DetSigner<'_> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { let kind = match self.secret { @@ -206,16 +161,16 @@ impl Signer for DetSigner<'_> { path: &DerivationPath, sighash: [u8; 32], ) -> Result<(EcdsaSignature, EcdsaPublicKey), Self::Error> { - let secret = self.derive_secret(path)?; - let msg = message_from_digest(sighash)?; - let signature = dash_sdk::dpp::secp256k1::ecdsa::sign(msg, &secret); - let public_key = PublicKey::from_secret_key(&secret); - Ok((signature.into(), public_key.into())) + // Sign with the derived key itself, which erases itself on drop, so no + // copy of the scalar is made. `EcdsaSecretKey::sign` is low-S and + // grinds a low R as Dash Core does. + let xprv = self.derive_xprv(path)?; + let secret = &xprv.private_key; + Ok((secret.sign(&sighash), secret.public_key())) } async fn public_key(&self, path: &DerivationPath) -> Result { - let secret = self.derive_secret(path)?; - Ok(PublicKey::from_secret_key(&secret).into()) + Ok(self.derive_xprv(path)?.private_key.public_key()) } } @@ -248,6 +203,7 @@ mod tests { use crate::wallet_backend::secret_prompt::test_support::{ScriptedAnswer, TestPrompt}; use crate::wallet_backend::single_key::open_secret_store; use crate::wallet_backend::wallet_seed_store::WalletSeedView; + use dash_sdk::dpp::secp256k1::{self, Message, PublicKey}; use std::sync::Arc; const SENTINEL_PASSPHRASE: &str = "correct-horse-battery-staple-SENTINEL"; @@ -338,8 +294,11 @@ mod tests { for network in [Network::Testnet, Network::Mainnet] { // Independent reference: derive the key directly from the seed at - // the path, then sign + recover the public key with the same - // secp256k1 primitive `DetSigner` uses internally. + // the path, then sign + recover the public key with the raw + // secp256k1 primitive. The signer signs through + // `EcdsaSecretKey::sign`, which grinds a low R as Dash Core does, + // so the reference is secp256k1's own low-R signer; plain RFC 6979 + // `ecdsa::sign` differs in about half of all signatures. let reference_sk = secp256k1::SecretKey::from_secret_bytes( *path .derive_priv_ecdsa_for_master_seed(&PARITY_SEED, network) @@ -349,10 +308,8 @@ mod tests { ) .expect("valid scalar"); let reference_msg = Message::from_digest(sighash); - let reference_sig = EcdsaSignature::from(dash_sdk::dpp::secp256k1::ecdsa::sign( - reference_msg, - &reference_sk, - )); + let reference_sig = + EcdsaSignature::from(secp256k1::ecdsa::sign_low_r(reference_msg, &reference_sk)); let reference_pk = EcdsaPublicKey::from(PublicKey::from_secret_key(&reference_sk)); // The JIT signer over the same seed, held open through the @@ -379,6 +336,56 @@ mod tests { } } + /// FUND-SAFETY: every HD signature the signer hands to a Core transaction + /// verifies against the key it reports, and is in the standard form Dash + /// Core relays: low S (a high S is non-standard) and a low R ground the + /// way Dash Core grinds it, so the DER encoding never exceeds 70 bytes. + /// R lands low half the time on its own, so a single digest proves + /// nothing; this signs many. + #[tokio::test] + async fn hd_signer_signatures_are_valid_and_standard() { + let path: DerivationPath = "m/44'/1'/0'/0/0".parse().unwrap(); + let held = Zeroizing::new(PARITY_SEED); + let signer = DetSigner::from_held(SecretPlaintext::HdSeed(&held), Network::Testnet); + + for i in 0..32u8 { + let sighash = [i; 32]; + let (signature, public_key) = signer.sign_ecdsa(&path, sighash).await.expect("sign"); + assert_signature_is_valid_and_standard(&sighash, signature, public_key, i); + } + } + + /// Check `signature` over `digest` against `public_key`, and that it has the + /// low-S, low-R form Dash Core relays. + fn assert_signature_is_valid_and_standard( + digest: &[u8; 32], + signature: EcdsaSignature, + public_key: EcdsaPublicKey, + case: u8, + ) { + let raw = ecdsa::Signature::from(signature); + let mut normalized = raw; + normalized.normalize_s(); + assert_eq!(normalized, raw, "high S for case {case}"); + assert!( + ecdsa::verify( + &raw, + Message::from_digest(*digest), + &PublicKey::from(public_key) + ) + .is_ok(), + "signature does not verify for case {case}" + ); + assert!( + signature.to_bytes()[0] < 0x80, + "R is not low for case {case}" + ); + assert!( + raw.serialize_der().len() <= 70, + "DER signature is longer than 70 bytes for case {case}" + ); + } + /// FUND-SAFETY PARITY: `DetSigner::extended_public_key` (the BIP-32 xpub /// export callers use to non-hardened-derive descendant payment addresses /// without a re-prompt) must reproduce, byte-for-byte, an independent @@ -491,8 +498,14 @@ mod tests { sa.with_secret_session(&scope, async |session| { let signer = DetSigner::from_held(session.plaintext(), Network::Testnet); - // Raw single-key sign succeeds. - signer.sign_single_key_ecdsa(&msg).expect("raw sign"); + // Raw single-key sign succeeds, with a valid, standard signature. + let signature = signer.sign_single_key_ecdsa(&msg).expect("raw sign"); + assert_signature_is_valid_and_standard( + &msg, + signature.into(), + PublicKey::from_secret_key(&sk).into(), + 0, + ); // Path-based HD surface rejects a single-key secret. let err = signer.sign_ecdsa(&path, msg).await.expect_err("wrong kind"); assert!(matches!(err, DetSignerError::WrongSecretKind));