diff --git a/Cargo.lock b/Cargo.lock index 9aeb4627f89..79a474b5da3 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1916,6 +1916,7 @@ dependencies = [ "rs-dapi-client", "rs-sdk-trusted-context-provider", "sanitize-filename", + "secp256k1", "serde", "serde_json", "tempfile", @@ -5449,6 +5450,7 @@ dependencies = [ "rayon", "rs-sdk-trusted-context-provider", "rusqlite", + "secp256k1", "serde", "serde_json", "sha2 0.10.9", @@ -5484,6 +5486,7 @@ dependencies = [ "parking_lot", "platform-wallet", "rs-sdk-ffi", + "secp256k1", "serde_json", "tokio", "tokio-metrics", @@ -6593,6 +6596,7 @@ dependencies = [ "once_cell", "platform-encryption", "rs-sdk-trusted-context-provider", + "secp256k1", "serde", "serde_json", "simple-signer", @@ -7350,6 +7354,7 @@ dependencies = [ "grovedb-bincode", "hex", "rand 0.8.6", + "secp256k1", "tracing", "zeroize", ] @@ -8958,6 +8963,7 @@ dependencies = [ "rand 0.8.6", "rs-dapi-client", "rs-sdk-trusted-context-provider", + "secp256k1", "serde", "serde-wasm-bindgen 0.5.0", "serde_json", diff --git a/packages/rs-dpp/Cargo.toml b/packages/rs-dpp/Cargo.toml index 425f1f438c8..0d59e963977 100644 --- a/packages/rs-dpp/Cargo.toml +++ b/packages/rs-dpp/Cargo.toml @@ -12,7 +12,6 @@ authors = [ ] [dependencies] -secp256k1 = { workspace = true } dash-pkc = { git = "https://github.com/dashpay/base-sdk", rev = "33fcc59e1868c803f9608e0e78ee8bddf3abcee7", default-features = false, features = ["bls"], optional = true } # Keep downstream lockfiles from retaining blst versions without WASM aggregate verification. # TODO: Remove this constraint once the pinned rust-dashcore dependency graph enforces a compatible blst minimum. @@ -92,6 +91,7 @@ tracing = { version = "0.1.41" } grovedb-commitment-tree = { workspace = true, optional = true } [dev-dependencies] +secp256k1 = { workspace = true } tokio = { version = "1.40", features = ["full"] } pretty_assertions = { version = "1.4.1" } dpp = { path = ".", default-features = false, features = [ diff --git a/packages/rs-dpp/src/identity/identity_public_key/key_type.rs b/packages/rs-dpp/src/identity/identity_public_key/key_type.rs index 02df74d6347..115348572c4 100644 --- a/packages/rs-dpp/src/identity/identity_public_key/key_type.rs +++ b/packages/rs-dpp/src/identity/identity_public_key/key_type.rs @@ -3,13 +3,14 @@ use anyhow::bail; use bincode::{Decode, DecodeUntrusted, Encode}; #[cfg(feature = "cbor")] use ciborium::value::Value as CborValue; +use dashcore::crypto::ecdsa::EcdsaSecretKey; +#[cfg(feature = "random-public-keys")] +use dashcore::key::rand::rngs::StdRng as EcdsaRng; +#[cfg(feature = "random-public-keys")] +use dashcore::key::rand::{RngCore, SeedableRng}; use dashcore::Network; use itertools::Itertools; use lazy_static::lazy_static; -#[cfg(feature = "random-public-keys")] -use secp256k1::rand::rngs::StdRng as EcdsaRng; -#[cfg(feature = "random-public-keys")] -use secp256k1::rand::SeedableRng; #[cfg(feature = "bls-signatures")] use crate::bls::{self, BlsError}; @@ -71,6 +72,17 @@ lazy_static! { .unwrap(); } +#[cfg(feature = "random-public-keys")] +fn random_ecdsa_secret_key(rng: &mut EcdsaRng) -> EcdsaSecretKey { + loop { + let mut bytes = [0; 32]; + rng.fill_bytes(&mut bytes); + if let Ok(key) = EcdsaSecretKey::from_bytes(&bytes) { + return key; + } + } +} + impl KeyType { /// Gets the default size of the public key pub fn default_size(&self) -> usize { @@ -163,9 +175,9 @@ impl KeyType { let mut seed = [0u8; 32]; rng.fill(&mut seed); let mut rng = EcdsaRng::from_seed(seed); - let secret_key = secp256k1::SecretKey::new(&mut rng); - let public_key = secp256k1::PublicKey::from_secret_key(&secret_key); - public_key.serialize().to_vec() + let secret_key = random_ecdsa_secret_key(&mut rng); + let public_key = secret_key.public_key(); + public_key.to_compressed().to_vec() } KeyType::BLS12_381 => { let private_key = bls::SecretKey::random(rng); @@ -207,11 +219,11 @@ impl KeyType { ) -> Result, ProtocolError> { match self { KeyType::ECDSA_SECP256K1 => { - let secret_key = secp256k1::SecretKey::from_secret_bytes(*private_key_bytes) + let secret_key = EcdsaSecretKey::from_bytes(private_key_bytes) .map_err(|e| ProtocolError::Generic(e.to_string()))?; - let public_key = secp256k1::PublicKey::from_secret_key(&secret_key); + let public_key = secret_key.public_key(); - Ok(public_key.serialize().to_vec()) + Ok(public_key.to_compressed().to_vec()) } KeyType::BLS12_381 => { #[cfg(feature = "bls-signatures")] @@ -233,11 +245,11 @@ impl KeyType { )); } KeyType::ECDSA_HASH160 => { - let secret_key = secp256k1::SecretKey::from_secret_bytes(*private_key_bytes) + let secret_key = EcdsaSecretKey::from_bytes(private_key_bytes) .map_err(|e| ProtocolError::Generic(e.to_string()))?; - let public_key = secp256k1::PublicKey::from_secret_key(&secret_key); + let public_key = secret_key.public_key(); - Ok(ripemd160_sha256(public_key.serialize().as_slice()).to_vec()) + Ok(ripemd160_sha256(public_key.to_compressed().as_slice()).to_vec()) } KeyType::EDDSA_25519_HASH160 => { #[cfg(feature = "ed25519-dalek")] @@ -264,12 +276,9 @@ impl KeyType { let mut seed = [0u8; 32]; rng.fill(&mut seed); let mut rng = EcdsaRng::from_seed(seed); - let secret_key = secp256k1::SecretKey::new(&mut rng); - let public_key = secp256k1::PublicKey::from_secret_key(&secret_key); - ( - public_key.serialize().to_vec(), - secret_key.to_secret_bytes(), - ) + let secret_key = random_ecdsa_secret_key(&mut rng); + let public_key = secret_key.public_key(); + (public_key.to_compressed().to_vec(), *secret_key.to_bytes()) } KeyType::BLS12_381 => { let private_key = crate::bls::SecretKey::random(rng); @@ -280,11 +289,11 @@ impl KeyType { let mut seed = [0u8; 32]; rng.fill(&mut seed); let mut rng = EcdsaRng::from_seed(seed); - let secret_key = secp256k1::SecretKey::new(&mut rng); - let public_key = secp256k1::PublicKey::from_secret_key(&secret_key); + let secret_key = random_ecdsa_secret_key(&mut rng); + let public_key = secret_key.public_key(); ( - ripemd160_sha256(public_key.serialize().as_slice()).to_vec(), - secret_key.to_secret_bytes(), + ripemd160_sha256(public_key.to_compressed().as_slice()).to_vec(), + *secret_key.to_bytes(), ) } KeyType::EDDSA_25519_HASH160 => { @@ -299,11 +308,11 @@ impl KeyType { let mut seed = [0u8; 32]; rng.fill(&mut seed); let mut rng = EcdsaRng::from_seed(seed); - let secret_key = secp256k1::SecretKey::new(&mut rng); - let public_key = secp256k1::PublicKey::from_secret_key(&secret_key); + let secret_key = random_ecdsa_secret_key(&mut rng); + let public_key = secret_key.public_key(); ( - ripemd160_sha256(public_key.serialize().as_slice()).to_vec(), - secret_key.to_secret_bytes(), + ripemd160_sha256(public_key.to_compressed().as_slice()).to_vec(), + *secret_key.to_bytes(), ) } } diff --git a/packages/rs-dpp/src/identity/identity_public_key/v0/methods/mod.rs b/packages/rs-dpp/src/identity/identity_public_key/v0/methods/mod.rs index 9f30211a538..4f986140e00 100644 --- a/packages/rs-dpp/src/identity/identity_public_key/v0/methods/mod.rs +++ b/packages/rs-dpp/src/identity/identity_public_key/v0/methods/mod.rs @@ -8,10 +8,10 @@ use crate::identity::KeyType; use crate::util::hash::ripemd160_sha256; use crate::ProtocolError; use anyhow::anyhow; +use dashcore::crypto::ecdsa::EcdsaSecretKey; use dashcore::hashes::Hash; use dashcore::{Network, PublicKey as ECDSAPublicKey}; use platform_value::{BinaryData, Bytes20}; -use secp256k1::SecretKey; impl IdentityPublicKeyHashMethodsV0 for IdentityPublicKeyV0 { /// Get the original public key hash fn public_key_hash(&self) -> Result<[u8; 20], ProtocolError> { @@ -82,13 +82,13 @@ pub(in crate::identity::identity_public_key) fn validate_private_key_bytes_for_k ) -> Result { match key_type { KeyType::ECDSA_SECP256K1 => { - let secret_key = match SecretKey::from_secret_bytes(*private_key_bytes) { + let secret_key = match EcdsaSecretKey::from_bytes(private_key_bytes) { Ok(secret_key) => secret_key, Err(_) => return Ok(false), }; - let public_key = secp256k1::PublicKey::from_secret_key(&secret_key); + let public_key = secret_key.public_key(); - Ok(public_key.serialize().as_slice() == data.as_slice()) + Ok(public_key.to_compressed().as_slice() == data.as_slice()) } KeyType::BLS12_381 => { #[cfg(feature = "bls-signatures")] @@ -108,13 +108,16 @@ pub(in crate::identity::identity_public_key) fn validate_private_key_bytes_for_k )); } KeyType::ECDSA_HASH160 => { - let secret_key = match SecretKey::from_secret_bytes(*private_key_bytes) { + let secret_key = match EcdsaSecretKey::from_bytes(private_key_bytes) { Ok(secret_key) => secret_key, Err(_) => return Ok(false), }; - let public_key = secp256k1::PublicKey::from_secret_key(&secret_key); + let public_key = secret_key.public_key(); - Ok(ripemd160_sha256(public_key.serialize().as_slice()).as_slice() == data.as_slice()) + Ok( + ripemd160_sha256(public_key.to_compressed().as_slice()).as_slice() + == data.as_slice(), + ) } KeyType::EDDSA_25519_HASH160 => { #[cfg(feature = "ed25519-dalek")] diff --git a/packages/rs-dpp/src/lib.rs b/packages/rs-dpp/src/lib.rs index f893f1423ff..2a7ab144989 100644 --- a/packages/rs-dpp/src/lib.rs +++ b/packages/rs-dpp/src/lib.rs @@ -14,8 +14,6 @@ extern crate core; pub use dashcore; -/// Low-level ECDSA primitives used by Platform signature validation. -pub use secp256k1; #[cfg(feature = "core_key_wallet")] pub use key_wallet; diff --git a/packages/rs-dpp/src/state_transition/mod.rs b/packages/rs-dpp/src/state_transition/mod.rs index a47c0d07eb8..6622a854ef3 100644 --- a/packages/rs-dpp/src/state_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/mod.rs @@ -9,6 +9,8 @@ use platform_value::{BinaryData, Identifier}; pub use state_transition_types::*; use bincode::{Decode, DecodeUntrusted, Encode}; +#[cfg(all(feature = "state-transition-signing", feature = "core_key_wallet"))] +use dashcore::crypto::ecdsa::{EcdsaPublicKey, EcdsaRecSignature}; #[cfg(any( feature = "state-transition-signing", feature = "state-transition-validation" @@ -2225,15 +2227,10 @@ impl StateTransition { path: &::key_wallet::bip32::DerivationPath, signer: &S, ) -> Result<(), ProtocolError> { - use dashcore::crypto::ecdsa::EcdsaRecSignature; - use dashcore::signer::double_sha; - use secp256k1::ecdsa::{RecoverableSignature, RecoveryId}; - use secp256k1::Message; - let data = self.signable_bytes()?; // Pre-image transform matches `dashcore::signer::sign`: double-SHA256 // of the signable bytes is the actual ECDSA message digest. - let data_hash = double_sha(&data); + let data_hash = signer::double_sha(&data); let digest: [u8; 32] = data_hash.as_slice().try_into().map_err(|_| { ProtocolError::Generic("double_sha did not return 32 bytes".to_string()) })?; @@ -2243,32 +2240,16 @@ impl StateTransition { .await .map_err(|e| ProtocolError::ExternalSignerError(format!("signer failed: {}", e)))?; - // The signer returns a non-recoverable signature. The legacy path - // stores a 65-byte recoverable compact signature, so we brute-force - // the recovery id (0..3) by reconstructing a `RecoverableSignature` - // and comparing the recovered public key with the one the signer - // returned. Byte parity with `dashcore::signer::sign` requires the - // same deterministic nonce without low-R grinding, as well as low-S - // normalization. Core `sign_recoverable` meets that contract; `sign` - // performs low-R grinding and may produce different bytes. - let compact_64 = signature.to_bytes(); - let msg = Message::from_digest(digest); - - let mut found: Option = None; - for id in 0..4i32 { - let recid = match RecoveryId::try_from(id) { - Ok(r) => r, - Err(_) => continue, - }; - let candidate = match RecoverableSignature::from_compact(&compact_64, recid) { - Ok(s) => s, + // Recover the metadata without changing the signer's compact signature bytes. + let mut found = None; + for id in 0..4 { + let candidate = match EcdsaRecSignature::from_parts(signature, id, true) { + Ok(candidate) => candidate, Err(_) => continue, }; - if let Ok(recovered) = candidate.recover_ecdsa(msg) { - if recovered == public_key.into() { - found = Some(candidate); - break; - } + if EcdsaPublicKey::recover(&digest, &candidate).is_ok_and(|key| key == public_key) { + found = Some(candidate); + break; } } let recoverable = found.ok_or_else(|| { @@ -2282,18 +2263,7 @@ impl StateTransition { ) })?; - // Compressed-pubkey convention matches `dashcore::signer::sign`, which - // always passes `true` regardless of the underlying key encoding. The - // signer's `sign_ecdsa` returns the compressed `secp256k1::PublicKey`, - // so this is consistent. - let (recovery_id, _) = recoverable.serialize_compact(); - let compact_65 = EcdsaRecSignature::from_parts( - recoverable.to_standard().into(), - recovery_id.to_u8(), - true, - ) - .map_err(|e| ProtocolError::ExternalSignerError(e.to_string()))? - .to_bytes(); + let compact_65 = recoverable.to_bytes(); if !self.set_signature(compact_65.to_vec().into()) { return Err(ProtocolError::InvalidVerificationWrongNumberOfElements { diff --git a/packages/rs-dpp/src/state_transition/traits/state_transition_identity_signed.rs b/packages/rs-dpp/src/state_transition/traits/state_transition_identity_signed.rs index 3bc6085669f..b66172bf9e0 100644 --- a/packages/rs-dpp/src/state_transition/traits/state_transition_identity_signed.rs +++ b/packages/rs-dpp/src/state_transition/traits/state_transition_identity_signed.rs @@ -6,7 +6,7 @@ use crate::consensus::signature::{ InvalidSignaturePublicKeySecurityLevelError, PublicKeyIsDisabledError, }; use anyhow::anyhow; -use secp256k1::{PublicKey as RawPublicKey, SecretKey as RawSecretKey}; +use dashcore::crypto::ecdsa::{EcdsaError, EcdsaSecretKey}; #[cfg(feature = "state-transition-validation")] use crate::state_transition::errors::WrongPublicKeyPurposeError; @@ -107,11 +107,11 @@ pub trait StateTransitionIdentitySigned: StateTransitionLike { pub fn get_compressed_public_ec_key(private_key: &[u8]) -> Result<[u8; 33], ProtocolError> { let sk = <[u8; 32]>::try_from(private_key) - .map_err(|_| secp256k1::Error::InvalidSecretKey) - .and_then(RawSecretKey::from_secret_bytes) + .map_err(|_| EcdsaError::InvalidSecretKey) + .and_then(|bytes| EcdsaSecretKey::from_bytes(&bytes)) .map_err(|e| anyhow!("Invalid ECDSA private key: {}", e))?; - let public_key_compressed = RawPublicKey::from_secret_key(&sk).serialize(); + let public_key_compressed = sk.public_key().to_compressed(); Ok(public_key_compressed) } diff --git a/packages/rs-dpp/src/tests/fixtures/instant_asset_lock_proof_fixture.rs b/packages/rs-dpp/src/tests/fixtures/instant_asset_lock_proof_fixture.rs index 07308342871..99c7679efe7 100644 --- a/packages/rs-dpp/src/tests/fixtures/instant_asset_lock_proof_fixture.rs +++ b/packages/rs-dpp/src/tests/fixtures/instant_asset_lock_proof_fixture.rs @@ -1,4 +1,4 @@ -use secp256k1::SecretKey; +use dashcore::crypto::ecdsa::EcdsaSecretKey; use std::str::FromStr; use dashcore::bls_sig_utils::BLSSignature; @@ -10,7 +10,6 @@ use dashcore::transaction::special_transaction::TransactionPayload; use dashcore::{ InstantLock, Network, OutPoint, PrivateKey, ScriptBuf, Transaction, TxIn, TxOut, Txid, }; -use secp256k1::rand::rng; use crate::identity::state_transition::asset_lock_proof::{AssetLockProof, InstantAssetLockProof}; @@ -45,16 +44,14 @@ pub fn instant_asset_lock_proof_transaction_fixture( one_time_private_key: Option, amount: Option, ) -> Transaction { - let mut rng = rng(); - let private_key_hex = "cSBnVM4xvxarwGQuAfQFwqDg9k5tErHUHzgWsEfD4zdwUasvqRVY"; let private_key = PrivateKey::from_str(private_key_hex).unwrap(); let public_key = private_key.public_key(); let public_key_hash = public_key.pubkey_hash(); //let from_address = Address::p2pkh(&public_key, Network::Testnet); - let secret_key = SecretKey::new(&mut rng); + let secret_key = EcdsaSecretKey::generate(); let one_time_private_key = one_time_private_key.unwrap_or_else(|| { - PrivateKey::from_byte_array(secret_key.as_secret_bytes(), Network::Testnet) + PrivateKey::from_byte_array(&secret_key.to_bytes(), Network::Testnet) .expect("valid test secret key") }); let one_time_public_key = one_time_private_key.public_key(); diff --git a/packages/rs-dpp/tests/ecdsa_compatibility.rs b/packages/rs-dpp/tests/ecdsa_compatibility.rs index 4a5fb76af00..5e7c4186072 100644 --- a/packages/rs-dpp/tests/ecdsa_compatibility.rs +++ b/packages/rs-dpp/tests/ecdsa_compatibility.rs @@ -16,9 +16,9 @@ use dpp::dashcore::{sign_message, PublicKey}; use dpp::identity::identity_public_key::methods::hash::IdentityPublicKeyHashMethodsV0; use dpp::identity::identity_public_key::v0::IdentityPublicKeyV0; use dpp::identity::{IdentityPublicKey, KeyType, Purpose, SecurityLevel}; -use dpp::secp256k1::{ecdsa::RecoverableSignature, ecdsa::RecoveryId, Message}; use dpp::serialization::PlatformMessageSignable; use dpp::ProtocolError; +use secp256k1::{ecdsa::RecoverableSignature, ecdsa::RecoveryId, Message}; use vectors::{ECDSA_PUBLIC_KEY, TRANSFER_ECDSA_SIGNATURE, TRANSFER_HASH, TRANSFER_SIGNABLE}; fn fixture() -> (Vec, Vec, Vec) { @@ -34,7 +34,7 @@ fn should_match_historical_verification_for_all_headers_and_scalar_boundaries() let (data, signature, public_key) = fixture(); let message = Message::from_digest(dpp::dashcore::hashes::sha256d::Hash::hash(&data).to_byte_array()); - let raw_key = dpp::secp256k1::PublicKey::from_slice(&public_key).unwrap(); + let raw_key = secp256k1::PublicKey::from_slice(&public_key).unwrap(); let order = hex::decode("fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141").unwrap(); let mut signatures = vec![signature.clone()]; @@ -80,8 +80,8 @@ fn should_preserve_witness_fee_operations_for_recovery_and_multisig_search() { AddressWitnessVerificationOperations::for_p2pkh(data.len()) ); - let other = dpp::secp256k1::SecretKey::from_secret_bytes([2; 32]).unwrap(); - let other_key = dpp::secp256k1::PublicKey::from_secret_key(&other).serialize(); + let other = secp256k1::SecretKey::from_secret_bytes([2; 32]).unwrap(); + let other_key = secp256k1::PublicKey::from_secret_key(&other).serialize(); let mut script = vec![0x51, 33]; script.extend_from_slice(&other_key); script.push(33); @@ -348,3 +348,35 @@ fn should_use_core_identity_public_key_errors_and_preserve_encoding() { "unable to create pub key - key prefix invalid: 6" ); } + +#[test] +fn should_preserve_seeded_key_generation_and_rng_consumption() { + use rand::{rngs::StdRng, Rng, SeedableRng}; + use secp256k1::rand::{rngs::StdRng as LegacyRng, SeedableRng as _}; + let version = dpp::version::PlatformVersion::latest(); + for seed in 0..64 { + for key_type in [ + KeyType::ECDSA_SECP256K1, + KeyType::ECDSA_HASH160, + KeyType::BIP13_SCRIPT_HASH, + ] { + let mut actual_rng = StdRng::seed_from_u64(seed); + let mut expected_rng = actual_rng.clone(); + let mut seed = [0u8; 32]; + expected_rng.fill(&mut seed); + let secret = secp256k1::SecretKey::new(&mut LegacyRng::from_seed(seed)); + let public = secp256k1::PublicKey::from_secret_key(&secret).serialize(); + let expected_public = if key_type == KeyType::ECDSA_SECP256K1 { + public.to_vec() + } else { + hash160::Hash::hash(&public).to_byte_array().to_vec() + }; + let (actual_public, actual_secret) = key_type + .random_public_and_private_key_data(&mut actual_rng, version) + .unwrap(); + assert_eq!(actual_secret, secret.to_secret_bytes()); + assert_eq!(actual_public, expected_public); + assert_eq!(actual_rng.gen::<[u8; 32]>(), expected_rng.gen::<[u8; 32]>()); + } + } +} diff --git a/packages/rs-drive-abci/examples/generate_wasm_contract_cache_vectors.rs b/packages/rs-drive-abci/examples/generate_wasm_contract_cache_vectors.rs index 32a039a8d70..5d11e11e539 100644 --- a/packages/rs-drive-abci/examples/generate_wasm_contract_cache_vectors.rs +++ b/packages/rs-drive-abci/examples/generate_wasm_contract_cache_vectors.rs @@ -9,6 +9,7 @@ use dapi_grpc::platform::v0::{ use dpp::address_funds::AddressWitness; use dpp::block::block_info::BlockInfo; use dpp::bls::SecretKey; +use dpp::dashcore::crypto::ecdsa::EcdsaSecretKey; use dpp::dashcore::signer; use dpp::data_contract::accessors::v0::{DataContractV0Getters, DataContractV0Setters}; use dpp::data_contract::conversion::value::v0::DataContractValueConversionMethodsV0; @@ -21,7 +22,6 @@ use dpp::identity::{ Identity, IdentityPublicKey, IdentityV0, KeyType, PartialIdentity, Purpose, SecurityLevel, }; use dpp::platform_value::{platform_value, BinaryData, Value}; -use dpp::secp256k1; use dpp::state_transition::batch_transition::accessors::DocumentsBatchTransitionAccessorsV0; use dpp::state_transition::batch_transition::batched_transition::document_transition::DocumentTransition; use dpp::state_transition::batch_transition::batched_transition::BatchedTransitionRef; @@ -128,12 +128,12 @@ fn identity_key_with_seed(seed: u8) -> IdentityPublicKey { purpose: Purpose::AUTHENTICATION, security_level: SecurityLevel::CRITICAL, key_type: KeyType::ECDSA_SECP256K1, - data: secp256k1::PublicKey::from_secret_key( - &secp256k1::SecretKey::from_secret_bytes([seed; 32]).expect("identity secret"), - ) - .serialize() - .to_vec() - .into(), + data: EcdsaSecretKey::from_bytes(&[seed; 32]) + .expect("identity secret") + .public_key() + .to_compressed() + .to_vec() + .into(), ..Default::default() }) } diff --git a/packages/rs-drive-abci/examples/generate_wasm_state_transition_wait_vectors.rs b/packages/rs-drive-abci/examples/generate_wasm_state_transition_wait_vectors.rs index 23f0fbfdd63..71bf691cf3f 100644 --- a/packages/rs-drive-abci/examples/generate_wasm_state_transition_wait_vectors.rs +++ b/packages/rs-drive-abci/examples/generate_wasm_state_transition_wait_vectors.rs @@ -9,6 +9,7 @@ use dapi_grpc::Message; use dpp::address_funds::AddressWitness; use dpp::block::block_info::BlockInfo; use dpp::bls::SecretKey; +use dpp::dashcore::crypto::ecdsa::EcdsaSecretKey; use dpp::dashcore::signer; use dpp::data_contract::accessors::v0::{DataContractV0Getters, DataContractV0Setters}; use dpp::data_contract::config::moderation::{ContractModerationConfig, ContractModerators}; @@ -19,7 +20,6 @@ use dpp::identity::identity_public_key::v0::IdentityPublicKeyV0; use dpp::identity::signer::Signer; use dpp::identity::{Identity, IdentityPublicKey, IdentityV0, KeyType, Purpose, SecurityLevel}; use dpp::platform_value::{platform_value, BinaryData, Value}; -use dpp::secp256k1; use dpp::serialization::{PlatformSerializable, PlatformSerializableWithPlatformVersion}; use dpp::state_transition::batch_transition::accessors::DocumentsBatchTransitionAccessorsV0; use dpp::state_transition::batch_transition::batched_transition::document_transition::DocumentTransition; @@ -116,12 +116,12 @@ fn identity_key() -> IdentityPublicKey { purpose: Purpose::AUTHENTICATION, security_level: SecurityLevel::CRITICAL, key_type: KeyType::ECDSA_SECP256K1, - data: secp256k1::PublicKey::from_secret_key( - &secp256k1::SecretKey::from_secret_bytes([1; 32]).expect("identity secret"), - ) - .serialize() - .to_vec() - .into(), + data: EcdsaSecretKey::from_bytes(&[1; 32]) + .expect("identity secret") + .public_key() + .to_compressed() + .to_vec() + .into(), ..Default::default() }) } diff --git a/packages/rs-drive-abci/src/execution/check_tx/v0/mod.rs b/packages/rs-drive-abci/src/execution/check_tx/v0/mod.rs index 7870dd11be0..8191ddd26fd 100644 --- a/packages/rs-drive-abci/src/execution/check_tx/v0/mod.rs +++ b/packages/rs-drive-abci/src/execution/check_tx/v0/mod.rs @@ -295,9 +295,9 @@ mod tests { use dpp::validation::ValidationResult; use simple_signer::signer::SimpleSigner; + use crate::execution::validation::state_transition::test_helpers::random_ecdsa_secret_key; use dpp::consensus::ConsensusError; use dpp::dashcore::{signer, Network, PrivateKey}; - use dpp::secp256k1::Keypair; use dpp::data_contract::accessors::v0::{DataContractV0Getters, DataContractV0Setters}; use dpp::data_contract::document_type::random_document::{ @@ -339,6 +339,8 @@ mod tests { use assert_matches::assert_matches; use dpp::consensus::state::state_error::StateError; use dpp::dash_to_credits; + use dpp::dashcore::key::rand::rngs::StdRng as SecpStdRng; + use dpp::dashcore::key::rand::SeedableRng as _; use dpp::data_contract::associated_token::token_configuration::accessors::v0::TokenConfigurationV0Setters; use dpp::data_contract::change_control_rules::authorized_action_takers::AuthorizedActionTakers; use dpp::data_contract::change_control_rules::v0::ChangeControlRulesV0; @@ -356,8 +358,6 @@ mod tests { use dpp::identity::identity_public_key::accessors::v0::IdentityPublicKeyGettersV0; use dpp::identity::signer::Signer; use dpp::platform_value::Bytes32; - use dpp::secp256k1::rand::rngs::StdRng as SecpStdRng; - use dpp::secp256k1::rand::SeedableRng as _; use dpp::state_transition::batch_transition::methods::v1::DocumentsBatchTransitionMethodsV1; use dpp::state_transition::data_contract_update_transition::DataContractUpdateTransition; use dpp::state_transition::identity_create_transition::accessors::IdentityCreateTransitionAccessorsV0; @@ -3931,7 +3931,7 @@ mod tests { let (identity, signer, key) = setup_identity(&mut platform, 958, dash_to_credits!(0.1)); - let new_key_pair = Keypair::new(&mut rng); + let new_key_pair = random_ecdsa_secret_key(&mut rng); let mut new_key = IdentityPublicKeyInCreationV0 { id: 2, @@ -3939,7 +3939,7 @@ mod tests { security_level: SecurityLevel::HIGH, key_type: ECDSA_SECP256K1, read_only: false, - data: new_key_pair.public_key().serialize().to_vec().into(), + data: new_key_pair.public_key().to_compressed().to_vec().into(), signature: Default::default(), contract_bounds: None, }; @@ -3947,9 +3947,9 @@ mod tests { let signable_bytes = new_key .signable_bytes() .expect("expected to get signable bytes"); - let secret = new_key_pair.secret_key(); + let secret = &new_key_pair; let signature = - signer::sign(&signable_bytes, &secret.to_secret_bytes()).expect("expected to sign"); + signer::sign(&signable_bytes, secret.to_bytes().as_ref()).expect("expected to sign"); new_key.signature = signature.to_vec().into(); @@ -4031,7 +4031,7 @@ mod tests { let platform_state = platform.state.load(); - let new_key_pair = Keypair::new(&mut rng); + let new_key_pair = random_ecdsa_secret_key(&mut rng); let mut new_key = IdentityPublicKeyInCreationV0 { id: 2, @@ -4039,7 +4039,7 @@ mod tests { security_level: SecurityLevel::MEDIUM, key_type: ECDSA_SECP256K1, read_only: true, - data: new_key_pair.public_key().serialize().to_vec().into(), + data: new_key_pair.public_key().to_compressed().to_vec().into(), signature: Default::default(), contract_bounds: Some(SingleContractDocumentType { id: Dashpay.id(), @@ -4066,8 +4066,8 @@ mod tests { let data = update_transition .signable_bytes() .expect("expected signable bytes"); - let secret = new_key_pair.secret_key(); - new_key.signature = signer::sign(&data, &secret.to_secret_bytes()) + let secret = &new_key_pair; + new_key.signature = signer::sign(&data, secret.to_bytes().as_ref()) .expect("expected to sign") .to_vec() .into(); diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create_from_addresses/tests.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create_from_addresses/tests.rs index 9596a86d6b5..aabbd2be487 100644 --- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create_from_addresses/tests.rs +++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create_from_addresses/tests.rs @@ -9376,23 +9376,23 @@ mod tests { mod actual_signature_verification { use super::*; use dpp::dashcore::hashes::Hash; - use dpp::secp256k1::PublicKey as RawSecp256k1PublicKey; use dpp::serialization::Signable; /// Helper to create a properly signed P2PKH witness /// Note: Creates a recoverable signature for P2PKH (65 bytes) fn create_real_p2pkh_witness( - secret_key: &dpp::secp256k1::SecretKey, + secret_key: &dpp::dashcore::crypto::ecdsa::EcdsaSecretKey, signable_bytes: &[u8], ) -> (PlatformAddress, AddressWitness) { - let raw_pubkey = RawSecp256k1PublicKey::from_secret_key(secret_key); + let raw_pubkey = secret_key.public_key(); let pubkey = PublicKey::new(raw_pubkey); - let pubkey_hash = dpp::dashcore::hashes::hash160::Hash::hash(&pubkey.to_bytes()); + let pubkey_hash = + dpp::dashcore::hashes::hash160::Hash::hash(pubkey.to_bytes().as_ref()); let address = PlatformAddress::P2pkh(pubkey_hash.to_byte_array()); // Sign using dashcore::signer which creates a recoverable signature let signature = - dpp::dashcore::signer::sign(signable_bytes, secret_key.as_secret_bytes()) + dpp::dashcore::signer::sign(signable_bytes, secret_key.to_bytes().as_ref()) .expect("signing should succeed"); let witness = AddressWitness::P2pkh { @@ -9410,16 +9410,17 @@ mod tests { let public_keys = create_default_public_keys(&mut rng, platform_version); // Create a real secret key - let secret_key = dpp::secp256k1::SecretKey::from_secret_bytes([ + let secret_key = dpp::dashcore::crypto::ecdsa::EcdsaSecretKey::from_bytes(&[ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, ]) .expect("valid secret key"); - let raw_pubkey = RawSecp256k1PublicKey::from_secret_key(&secret_key); + let raw_pubkey = secret_key.public_key(); let pubkey = PublicKey::new(raw_pubkey); - let pubkey_hash = dpp::dashcore::hashes::hash160::Hash::hash(&pubkey.to_bytes()); + let pubkey_hash = + dpp::dashcore::hashes::hash160::Hash::hash(pubkey.to_bytes().as_ref()); let address = PlatformAddress::P2pkh(pubkey_hash.to_byte_array()); let mut inputs = BTreeMap::new(); @@ -9446,7 +9447,7 @@ mod tests { // Now create the signature using recoverable signing let signature = - dpp::dashcore::signer::sign(&signable_bytes, secret_key.as_secret_bytes()) + dpp::dashcore::signer::sign(&signable_bytes, secret_key.to_bytes().as_ref()) .expect("signing should succeed"); // Create the signed transition @@ -9487,16 +9488,17 @@ mod tests { // Create address from one key let correct_secret = - dpp::secp256k1::SecretKey::from_secret_bytes([1u8; 32]).expect("valid secret key"); - let raw_correct_pubkey = RawSecp256k1PublicKey::from_secret_key(&correct_secret); + dpp::dashcore::crypto::ecdsa::EcdsaSecretKey::from_bytes(&[1u8; 32]) + .expect("valid secret key"); + let raw_correct_pubkey = correct_secret.public_key(); let correct_pubkey = PublicKey::new(raw_correct_pubkey); let pubkey_hash = - dpp::dashcore::hashes::hash160::Hash::hash(&correct_pubkey.to_bytes()); + dpp::dashcore::hashes::hash160::Hash::hash(correct_pubkey.to_bytes().as_ref()); let address = PlatformAddress::P2pkh(pubkey_hash.to_byte_array()); // But sign with different key - let wrong_secret = - dpp::secp256k1::SecretKey::from_secret_bytes([2u8; 32]).expect("valid secret key"); + let wrong_secret = dpp::dashcore::crypto::ecdsa::EcdsaSecretKey::from_bytes(&[2u8; 32]) + .expect("valid secret key"); let mut inputs = BTreeMap::new(); inputs.insert(address.clone(), (1 as AddressNonce, dash_to_credits!(1.0))); @@ -9523,7 +9525,7 @@ mod tests { // Sign with WRONG key - this will produce a signature that when recovered // will give a different public key than expected let wrong_signature = - dpp::dashcore::signer::sign(&signable_bytes, wrong_secret.as_secret_bytes()) + dpp::dashcore::signer::sign(&signable_bytes, wrong_secret.to_bytes().as_ref()) .expect("signing should succeed"); // Create transition with mismatched signature (signed by wrong key) @@ -9557,17 +9559,18 @@ mod tests { .map(|i| { let mut key_bytes = [0u8; 32]; key_bytes[0] = i; - dpp::secp256k1::SecretKey::from_secret_bytes(key_bytes).expect("valid") + dpp::dashcore::crypto::ecdsa::EcdsaSecretKey::from_bytes(&key_bytes) + .expect("valid") }) .collect(); let addresses: Vec<_> = secrets .iter() .map(|secret| { - let raw_pubkey = RawSecp256k1PublicKey::from_secret_key(secret); + let raw_pubkey = secret.public_key(); let pubkey = PublicKey::new(raw_pubkey); let pubkey_hash = - dpp::dashcore::hashes::hash160::Hash::hash(&pubkey.to_bytes()); + dpp::dashcore::hashes::hash160::Hash::hash(pubkey.to_bytes().as_ref()); PlatformAddress::P2pkh(pubkey_hash.to_byte_array()) }) .collect(); @@ -9609,7 +9612,7 @@ mod tests { .expect("should find"); let secret = &secrets[idx]; let signature = - dpp::dashcore::signer::sign(&signable_bytes, secret.as_secret_bytes()) + dpp::dashcore::signer::sign(&signable_bytes, secret.to_bytes().as_ref()) .expect("signing should succeed"); witnesses.push(AddressWitness::P2pkh { @@ -9645,15 +9648,16 @@ mod tests { .map(|i| { let mut key_bytes = [0u8; 32]; key_bytes[0] = i + 10; - dpp::secp256k1::SecretKey::from_secret_bytes(key_bytes).expect("valid") + dpp::dashcore::crypto::ecdsa::EcdsaSecretKey::from_bytes(&key_bytes) + .expect("valid") }) .collect(); let pubkeys: Vec<[u8; 33]> = secrets .iter() .map(|secret| { - let raw_pubkey = RawSecp256k1PublicKey::from_secret_key(secret); - raw_pubkey.serialize() + let raw_pubkey = secret.public_key(); + raw_pubkey.to_compressed() }) .collect(); @@ -9697,9 +9701,9 @@ mod tests { .expect("should get signable bytes"); // Sign with first 2 keys (2-of-3) using DER signatures for P2SH - let sig1 = dpp::dashcore::signer::sign(&signable_bytes, secrets[0].as_secret_bytes()) + let sig1 = dpp::dashcore::signer::sign(&signable_bytes, secrets[0].to_bytes().as_ref()) .expect("signing should succeed"); - let sig2 = dpp::dashcore::signer::sign(&signable_bytes, secrets[1].as_secret_bytes()) + let sig2 = dpp::dashcore::signer::sign(&signable_bytes, secrets[1].to_bytes().as_ref()) .expect("signing should succeed"); let _signed_transition = IdentityCreateFromAddressesTransition::V0( diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_update/mod.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_update/mod.rs index 2c82bfeb3e4..eec10e62069 100644 --- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_update/mod.rs +++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_update/mod.rs @@ -129,6 +129,7 @@ impl StateTransitionStateValidation for IdentityUpdateTransition { #[cfg(test)] mod tests { use crate::config::{PlatformConfig, PlatformTestConfig}; + use crate::execution::validation::state_transition::test_helpers::random_ecdsa_secret_key; use crate::execution::validation::state_transition::tests::{ setup_add_key_to_identity, setup_identity_return_master_key, }; @@ -140,6 +141,9 @@ mod tests { use dpp::consensus::codes::ErrorWithCode; use dpp::consensus::ConsensusError; use dpp::dash_to_credits; + use dpp::dashcore::crypto::ecdsa::EcdsaSecretKey; + use dpp::dashcore::key::rand::rngs::StdRng as SecpStdRng; + use dpp::dashcore::key::rand::SeedableRng as _; use dpp::dashcore::signer; use dpp::data_contract::accessors::v0::DataContractV0Getters; use dpp::identifier::Identifier; @@ -149,9 +153,6 @@ mod tests { use dpp::identity::signer::Signer; use dpp::identity::KeyType::ECDSA_SECP256K1; use dpp::identity::{KeyType, Purpose, SecurityLevel}; - use dpp::secp256k1::rand::rngs::StdRng as SecpStdRng; - use dpp::secp256k1::rand::SeedableRng as _; - use dpp::secp256k1::Keypair; use dpp::serialization::{PlatformSerializable, Signable}; use dpp::state_transition::identity_update_transition::v0::IdentityUpdateTransitionV0; use dpp::state_transition::identity_update_transition::IdentityUpdateTransition; @@ -262,7 +263,7 @@ mod tests { let mut rng = SecpStdRng::seed_from_u64(292); - let new_key_pair = Keypair::new(&mut rng); + let new_key_pair = random_ecdsa_secret_key(&mut rng); let mut new_key = IdentityPublicKeyInCreationV0 { id: 2, @@ -270,7 +271,7 @@ mod tests { security_level: SecurityLevel::HIGH, key_type: ECDSA_SECP256K1, read_only: false, - data: new_key_pair.public_key().serialize().to_vec().into(), + data: new_key_pair.public_key().to_compressed().to_vec().into(), signature: Default::default(), contract_bounds: None, }; @@ -293,9 +294,9 @@ mod tests { .signable_bytes() .expect("expected signable bytes"); - let secret = new_key_pair.secret_key(); + let secret = &new_key_pair; let signature = - signer::sign(&signable_bytes, &secret.to_secret_bytes()).expect("expected to sign"); + signer::sign(&signable_bytes, secret.to_bytes().as_ref()).expect("expected to sign"); new_key.signature = signature.to_vec().into(); @@ -542,14 +543,14 @@ mod tests { }; let platform_state = platform.state.load(); let mut rng = SecpStdRng::seed_from_u64(292); - let new_key_pair = Keypair::new(&mut rng); + let new_key_pair = random_ecdsa_secret_key(&mut rng); let mut new_key = IdentityPublicKeyInCreationV0 { id: 2, purpose: Purpose::AUTHENTICATION, security_level: SecurityLevel::HIGH, key_type: ECDSA_SECP256K1, read_only: false, - data: new_key_pair.public_key().serialize().to_vec().into(), + data: new_key_pair.public_key().to_compressed().to_vec().into(), signature: Default::default(), contract_bounds: Some(bounds.clone()), }; @@ -567,13 +568,10 @@ mod tests { .into() }; let signable_bytes = build(new_key.clone()).signable_bytes().unwrap(); - new_key.signature = signer::sign( - &signable_bytes, - &new_key_pair.secret_key().to_secret_bytes(), - ) - .unwrap() - .to_vec() - .into(); + new_key.signature = signer::sign(&signable_bytes, new_key_pair.to_bytes().as_ref()) + .unwrap() + .to_vec() + .into(); let mut update_transition = build(new_key); update_transition .set_signature(signer.sign(&key, signable_bytes.as_slice()).await.unwrap()); @@ -752,7 +750,7 @@ mod tests { }; let platform_state = platform.state.load(); let mut rng = SecpStdRng::seed_from_u64(293); - let new_key_pair = Keypair::new(&mut rng); + let new_key_pair = random_ecdsa_secret_key(&mut rng); let build = |revision: u64, nonce: u64, add: Vec, disable| { StateTransition::from(IdentityUpdateTransition::from(IdentityUpdateTransitionV0 { @@ -777,20 +775,17 @@ mod tests { security_level: SecurityLevel::HIGH, key_type: ECDSA_SECP256K1, read_only: false, - data: new_key_pair.public_key().serialize().to_vec().into(), + data: new_key_pair.public_key().to_compressed().to_vec().into(), signature: Default::default(), contract_bounds: Some(bounds.clone()), }; let signable_bytes = build(revision, nonce, vec![new_key.clone()], vec![]) .signable_bytes() .unwrap(); - new_key.signature = signer::sign( - &signable_bytes, - &new_key_pair.secret_key().to_secret_bytes(), - ) - .unwrap() - .to_vec() - .into(); + new_key.signature = signer::sign(&signable_bytes, new_key_pair.to_bytes().as_ref()) + .unwrap() + .to_vec() + .into(); let mut update = build(revision, nonce, vec![new_key], vec![]); update.set_signature(signer.sign(&key, signable_bytes.as_slice()).await.unwrap()); signed_updates.push(update); @@ -1111,9 +1106,9 @@ mod tests { .unwrap(); let bounds = ContractBounds::SingleContract { id: dashpay.id() }; let mut rng = SecpStdRng::seed_from_u64(292); - let pairs: BTreeMap = [2u32, 3, 4] + let pairs: BTreeMap = [2u32, 3, 4] .into_iter() - .map(|id| (id, Keypair::new(&mut rng))) + .map(|id| (id, random_ecdsa_secret_key(&mut rng))) .collect(); let bound_key = |id: u32| IdentityPublicKeyInCreationV0 { id, @@ -1121,7 +1116,7 @@ mod tests { security_level: SecurityLevel::HIGH, key_type: ECDSA_SECP256K1, read_only: false, - data: pairs[&id].public_key().serialize().to_vec().into(), + data: pairs[&id].public_key().to_compressed().to_vec().into(), signature: Default::default(), contract_bounds: Some(bounds.clone()), }; @@ -1228,7 +1223,7 @@ mod tests { let mut adds = vec![bound_key(3), bound_key(2)]; let signable = unsigned(1, adds.clone(), vec![]).signable_bytes().unwrap(); for key in &mut adds { - key.signature = signer::sign(&signable, &pairs[&key.id].secret_key().to_secret_bytes()) + key.signature = signer::sign(&signable, pairs[&key.id].to_bytes().as_ref()) .unwrap() .to_vec() .into(); @@ -1243,7 +1238,7 @@ mod tests { let mut adds = vec![bound_key(4)]; let signable = unsigned(2, adds.clone(), vec![3]).signable_bytes().unwrap(); for key in &mut adds { - key.signature = signer::sign(&signable, &pairs[&key.id].secret_key().to_secret_bytes()) + key.signature = signer::sign(&signable, pairs[&key.id].to_bytes().as_ref()) .unwrap() .to_vec() .into(); @@ -1677,7 +1672,7 @@ mod tests { let mut rng = SecpStdRng::seed_from_u64(1292); - let new_key_pair = Keypair::new(&mut rng); + let new_key_pair = random_ecdsa_secret_key(&mut rng); let new_key = IdentityPublicKeyInCreationV0 { id: 2, @@ -1685,7 +1680,7 @@ mod tests { security_level: SecurityLevel::HIGH, key_type: KeyType::ECDSA_SECP256K1, read_only: false, - data: new_key_pair.public_key().serialize().to_vec().into(), + data: new_key_pair.public_key().to_compressed().to_vec().into(), signature: Default::default(), contract_bounds: None, }; @@ -1864,7 +1859,7 @@ mod tests { let mut rng = SecpStdRng::seed_from_u64(1292); - let new_key_pair = Keypair::new(&mut rng); + let new_key_pair = random_ecdsa_secret_key(&mut rng); let mut new_key = IdentityPublicKeyInCreationV0 { id: 2, @@ -1872,7 +1867,7 @@ mod tests { security_level: SecurityLevel::MEDIUM, key_type: ECDSA_SECP256K1, read_only: false, - data: new_key_pair.public_key().serialize().to_vec().into(), + data: new_key_pair.public_key().to_compressed().to_vec().into(), signature: Default::default(), contract_bounds: Some(ContractBounds::SingleContract { id: data_contract.id(), @@ -1898,9 +1893,9 @@ mod tests { .expect("expected signable bytes"); // Sign the new key with its own private key - let secret = new_key_pair.secret_key(); + let secret = &new_key_pair; let signature = - signer::sign(&signable_bytes, &secret.to_secret_bytes()).expect("expected to sign"); + signer::sign(&signable_bytes, secret.to_bytes().as_ref()).expect("expected to sign"); new_key.signature = signature.to_vec().into(); @@ -2148,10 +2143,10 @@ mod tests { let mut rng = SecpStdRng::seed_from_u64(1292); // Two encryption keys, the newer one listed first: both write the encryption // current-key alias, and the one naming the highest key id must win. - let pairs: Vec<(u32, Purpose, Keypair)> = vec![ - (4, Purpose::ENCRYPTION, Keypair::new(&mut rng)), - (2, Purpose::ENCRYPTION, Keypair::new(&mut rng)), - (3, Purpose::DECRYPTION, Keypair::new(&mut rng)), + let pairs: Vec<(u32, Purpose, EcdsaSecretKey)> = vec![ + (4, Purpose::ENCRYPTION, random_ecdsa_secret_key(&mut rng)), + (2, Purpose::ENCRYPTION, random_ecdsa_secret_key(&mut rng)), + (3, Purpose::DECRYPTION, random_ecdsa_secret_key(&mut rng)), ]; let mut adds: Vec = pairs .iter() @@ -2161,7 +2156,7 @@ mod tests { security_level: SecurityLevel::MEDIUM, key_type: ECDSA_SECP256K1, read_only: false, - data: pair.public_key().serialize().to_vec().into(), + data: pair.public_key().to_compressed().to_vec().into(), signature: Default::default(), contract_bounds: Some(bounds.clone()), }) @@ -2267,7 +2262,7 @@ mod tests { .signable_bytes() .expect("expected signable bytes"); for (key, (_, _, pair)) in adds.iter_mut().zip(&pairs) { - key.signature = signer::sign(&signable, &pair.secret_key().to_secret_bytes()) + key.signature = signer::sign(&signable, pair.to_bytes().as_ref()) .expect("expected to sign") .to_vec() .into(); @@ -2636,7 +2631,7 @@ mod tests { let mut rng = SecpStdRng::seed_from_u64(1292); - let new_key_pair = Keypair::new(&mut rng); + let new_key_pair = random_ecdsa_secret_key(&mut rng); let mut new_key = IdentityPublicKeyInCreationV0 { id: 2, @@ -2644,7 +2639,7 @@ mod tests { security_level: SecurityLevel::MEDIUM, key_type: ECDSA_SECP256K1, read_only: false, - data: new_key_pair.public_key().serialize().to_vec().into(), + data: new_key_pair.public_key().to_compressed().to_vec().into(), signature: Default::default(), contract_bounds: Some(ContractBounds::SingleContractDocumentType { id: data_contract.id(), @@ -2671,9 +2666,9 @@ mod tests { .expect("expected signable bytes"); // Sign the new key with its own private key - let secret = new_key_pair.secret_key(); + let secret = &new_key_pair; let signature = - signer::sign(&signable_bytes, &secret.to_secret_bytes()).expect("expected to sign"); + signer::sign(&signable_bytes, secret.to_bytes().as_ref()).expect("expected to sign"); new_key.signature = signature.to_vec().into(); @@ -3007,7 +3002,7 @@ mod tests { let platform_state = platform.state.load(); let mut rng = SecpStdRng::seed_from_u64(292); - let new_key_pair = Keypair::new(&mut rng); + let new_key_pair = random_ecdsa_secret_key(&mut rng); // Add a key with id 2 and also disable key id 2 in the same transition let new_key = IdentityPublicKeyInCreationV0 { @@ -3016,7 +3011,7 @@ mod tests { security_level: SecurityLevel::HIGH, key_type: ECDSA_SECP256K1, read_only: false, - data: new_key_pair.public_key().serialize().to_vec().into(), + data: new_key_pair.public_key().to_compressed().to_vec().into(), signature: Default::default(), contract_bounds: None, }; @@ -3236,7 +3231,7 @@ mod tests { let platform_state = platform.state.load(); let mut rng = SecpStdRng::seed_from_u64(292); - let new_key_pair = Keypair::new(&mut rng); + let new_key_pair = random_ecdsa_secret_key(&mut rng); let signable_transition: IdentityUpdateTransition = IdentityUpdateTransitionV0 { identity_id: identity.id(), @@ -3249,7 +3244,7 @@ mod tests { security_level: SecurityLevel::HIGH, key_type: ECDSA_SECP256K1, read_only: false, - data: new_key_pair.public_key().serialize().to_vec().into(), + data: new_key_pair.public_key().to_compressed().to_vec().into(), signature: Default::default(), contract_bounds: None, }, @@ -3267,9 +3262,9 @@ mod tests { .expect("expected signable bytes"); // Sign the new key - let secret = new_key_pair.secret_key(); + let secret = &new_key_pair; let key_sig = - signer::sign(&signable_bytes, &secret.to_secret_bytes()).expect("expected to sign"); + signer::sign(&signable_bytes, secret.to_bytes().as_ref()).expect("expected to sign"); let mut new_key = IdentityPublicKeyInCreationV0 { id: 1, // existing key ID @@ -3277,7 +3272,7 @@ mod tests { security_level: SecurityLevel::HIGH, key_type: ECDSA_SECP256K1, read_only: false, - data: new_key_pair.public_key().serialize().to_vec().into(), + data: new_key_pair.public_key().to_compressed().to_vec().into(), signature: Default::default(), contract_bounds: None, }; @@ -3371,14 +3366,14 @@ mod tests { let platform_state = platform.state.load(); let mut rng = SecpStdRng::seed_from_u64(292); - let new_key_pair = Keypair::new(&mut rng); + let new_key_pair = random_ecdsa_secret_key(&mut rng); let mut new_key = IdentityPublicKeyInCreationV1 { id: NEW_KEY_ID, purpose: added_key.purpose, security_level: added_key.security_level, key_type: ECDSA_SECP256K1, read_only: false, - data: new_key_pair.public_key().serialize().to_vec().into(), + data: new_key_pair.public_key().to_compressed().to_vec().into(), contract_bounds: None, total_budget: added_key.total_budget, expires_at: added_key.expires_at, @@ -3405,13 +3400,10 @@ mod tests { let signable_bytes = transition_adding(new_key.clone()) .signable_bytes() .expect("expected signable bytes"); - new_key.signature = signer::sign( - &signable_bytes, - &new_key_pair.secret_key().to_secret_bytes(), - ) - .expect("expected to sign") - .to_vec() - .into(); + new_key.signature = signer::sign(&signable_bytes, new_key_pair.to_bytes().as_ref()) + .expect("expected to sign") + .to_vec() + .into(); let mut update_transition = transition_adding(new_key); update_transition.set_signature( @@ -3930,7 +3922,7 @@ mod tests { nonce: IdentityNonce, ) -> StateTransition { let mut rng = SecpStdRng::seed_from_u64(292); - let authentication_key_pair = Keypair::new(&mut rng); + let authentication_key_pair = random_ecdsa_secret_key(&mut rng); let (authentication_key_type, authentication_key_data) = match fault { Some(Fault::UndecodableBlsKeyData) => (KeyType::BLS12_381, vec![0xff; 48]), Some(Fault::ShortBlsKeyData) => (KeyType::BLS12_381, vec![0xa0; 47]), @@ -3941,7 +3933,10 @@ mod tests { } _ => ( ECDSA_SECP256K1, - authentication_key_pair.public_key().serialize().to_vec(), + authentication_key_pair + .public_key() + .to_compressed() + .to_vec(), ), }; let update_transition: IdentityUpdateTransition = IdentityUpdateTransitionV0 { @@ -3988,11 +3983,9 @@ mod tests { else { panic!("expected an identity update v0 transition"); }; - let proof_of_possession = signer::sign( - &signable_bytes, - &authentication_key_pair.secret_key().to_secret_bytes(), - ) - .expect("expected to sign"); + let proof_of_possession = + signer::sign(&signable_bytes, authentication_key_pair.to_bytes().as_ref()) + .expect("expected to sign"); update_v0.add_public_keys[0].set_signature(proof_of_possession.to_vec().into()); match fault { None => {} @@ -4103,7 +4096,9 @@ mod tests { /// keys, each with its proof of possession, signed by the owner's master key. async fn update_adding_ecdsa_keys(owner: &Owner, key_count: usize) -> StateTransition { let mut rng = SecpStdRng::seed_from_u64(517); - let key_pairs: Vec = (0..key_count).map(|_| Keypair::new(&mut rng)).collect(); + let key_pairs: Vec = (0..key_count) + .map(|_| random_ecdsa_secret_key(&mut rng)) + .collect(); let update_transition: IdentityUpdateTransition = IdentityUpdateTransitionV0 { identity_id: owner.identity.id(), revision: 1, @@ -4118,7 +4113,7 @@ mod tests { security_level: SecurityLevel::HIGH, key_type: ECDSA_SECP256K1, read_only: false, - data: key_pair.public_key().serialize().to_vec().into(), + data: key_pair.public_key().to_compressed().to_vec().into(), signature: Default::default(), contract_bounds: None, } @@ -4143,7 +4138,7 @@ mod tests { }; for (key, key_pair) in update_v0.add_public_keys.iter_mut().zip(&key_pairs) { let proof_of_possession = - signer::sign(&signable_bytes, &key_pair.secret_key().to_secret_bytes()) + signer::sign(&signable_bytes, key_pair.to_bytes().as_ref()) .expect("expected to sign"); key.set_signature(proof_of_possession.to_vec().into()); } diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/test_helpers.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/test_helpers.rs index feec8ab2f6e..ac41847e2c2 100644 --- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/test_helpers.rs +++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/test_helpers.rs @@ -16,12 +16,13 @@ use dpp::address_funds::{AddressWitness, OrchardAddress, PlatformAddress}; use dpp::block::block_info::BlockInfo; use dpp::consensus::ConsensusError; use dpp::dashcore::blockdata::script::ScriptBuf; +use dpp::dashcore::crypto::ecdsa::EcdsaSecretKey; use dpp::dashcore::hashes::{sha256, Hash}; +use dpp::dashcore::key::rand::RngCore as EcdsaRngCore; use dpp::dashcore::PublicKey; use dpp::identity::signer::Signer; use dpp::platform_value::BinaryData; use dpp::prelude::AddressNonce; -use dpp::secp256k1::{PublicKey as RawPublicKey, SecretKey as RawSecretKey}; use dpp::serialization::PlatformSerializable; use dpp::shielded::builder::OrchardProver; use dpp::shielded::SerializedAction; @@ -61,14 +62,14 @@ pub use dpp::ProtocolError as TestProtocolError; /// A P2PKH key entry containing the secret key only #[derive(Debug, Clone)] pub struct P2pkhKeyEntry { - pub secret_key: RawSecretKey, + pub secret_key: EcdsaSecretKey, } /// A P2SH multisig entry containing multiple secret keys and the redeem script #[derive(Debug, Clone)] pub struct P2shMultisigEntry { pub threshold: u8, - pub secret_keys: Vec, + pub secret_keys: Vec, pub redeem_script: Vec, } @@ -84,19 +85,19 @@ impl TestAddressSigner { Self::default() } - pub fn create_keypair(seed: [u8; 32]) -> (RawSecretKey, PublicKey) { + pub fn create_keypair(seed: [u8; 32]) -> (EcdsaSecretKey, PublicKey) { // Hash the seed to ensure it's always a valid secret key // (non-zero, less than curve order). Raw seeds like [0u8; 32] are invalid. let hashed_seed = sha256::Hash::hash(&seed); - let secret_key = RawSecretKey::from_secret_bytes(*hashed_seed.as_byte_array()) - .expect("valid secret key"); - let raw_public_key = RawPublicKey::from_secret_key(&secret_key); + let secret_key = + EcdsaSecretKey::from_bytes(hashed_seed.as_byte_array()).expect("valid secret key"); + let raw_public_key = secret_key.public_key(); let public_key = PublicKey::new(raw_public_key); (secret_key, public_key) } - pub fn sign_data(data: &[u8], secret_key: &RawSecretKey) -> Vec { - dpp::dashcore::signer::sign(data, secret_key.as_secret_bytes()) + pub fn sign_data(data: &[u8], secret_key: &EcdsaSecretKey) -> Vec { + dpp::dashcore::signer::sign(data, secret_key.to_bytes().as_ref()) .expect("signing should succeed") .to_vec() } @@ -124,7 +125,7 @@ impl TestAddressSigner { pub fn add_p2sh_multisig(&mut self, threshold: u8, seeds: &[[u8; 32]]) -> PlatformAddress { let keypairs: Vec<_> = seeds.iter().map(|s| Self::create_keypair(*s)).collect(); - let secret_keys: Vec<_> = keypairs.iter().map(|(sk, _)| *sk).collect(); + let secret_keys: Vec<_> = keypairs.iter().map(|(sk, _)| sk.clone()).collect(); let public_keys: Vec<_> = keypairs.iter().map(|(_, pk)| *pk).collect(); let redeem_script = Self::create_multisig_script(threshold, &public_keys); @@ -150,7 +151,7 @@ impl TestAddressSigner { PlatformAddress::P2pkh(hash) => self .p2pkh_keys .get(hash) - .map(|entry| entry.secret_key.to_secret_bytes()), + .map(|entry| *entry.secret_key.to_bytes()), _ => None, } } @@ -954,3 +955,14 @@ fn serialize_bundle_actions( }) .collect() } + +/// Draws the same seeded scalar as the historical secp256k1 keypair constructor. +pub fn random_ecdsa_secret_key(rng: &mut impl EcdsaRngCore) -> EcdsaSecretKey { + loop { + let mut bytes = [0; 32]; + rng.fill_bytes(&mut bytes); + if let Ok(key) = EcdsaSecretKey::from_bytes(&bytes) { + return key; + } + } +} diff --git a/packages/rs-drive-abci/tests/strategy_tests/strategy.rs b/packages/rs-drive-abci/tests/strategy_tests/strategy.rs index 04f09907282..61c60c7b588 100644 --- a/packages/rs-drive-abci/tests/strategy_tests/strategy.rs +++ b/packages/rs-drive-abci/tests/strategy_tests/strategy.rs @@ -27,9 +27,9 @@ use dpp::ProtocolError; // Scope, SpendAuthorizingKey, SpendingKey, // }; +use dpp::dashcore::crypto::ecdsa::EcdsaSecretKey as SecretKey; use dpp::data_contract::document_type::random_document::CreateRandomDocument; use dpp::data_contract::{DataContract, DataContractFactory}; -use dpp::secp256k1::SecretKey; use dpp::state_transition::identity_topup_transition::IdentityTopUpTransition; use strategy_tests::frequency::Frequency; use strategy_tests::operations::FinalizeBlockOperation::IdentityAddKeys; @@ -2196,9 +2196,9 @@ impl NetworkStrategy { .random_public_and_private_key_data(rng, platform_version) .unwrap(); let sk: [u8; 32] = pk.try_into().unwrap(); - let secret_key = SecretKey::from_str(hex::encode(sk).as_str()).unwrap(); + let secret_key = SecretKey::from_bytes(&sk).unwrap(); let mut asset_lock_proof = instant_asset_lock_proof_fixture_with_dynamic_range( - PrivateKey::from_byte_array(secret_key.as_secret_bytes(), Network::Mainnet) + PrivateKey::from_byte_array(&secret_key.to_bytes(), Network::Mainnet) .expect("valid test secret key"), amount_range, rng, @@ -2241,7 +2241,7 @@ impl NetworkStrategy { IdentityTopUpTransition::try_from_identity_with_private_key( identity, asset_lock_proof, - secret_key.as_secret_bytes(), + secret_key.to_bytes().as_ref(), 0, platform_version, None, @@ -2261,9 +2261,9 @@ impl NetworkStrategy { .random_public_and_private_key_data(rng, platform_version) .unwrap(); let sk_bytes: [u8; 32] = pk.try_into().unwrap(); - let secret_key = SecretKey::from_str(hex::encode(sk_bytes).as_str()).unwrap(); + let secret_key = SecretKey::from_bytes(&sk_bytes).unwrap(); let mut asset_lock_proof = instant_asset_lock_proof_fixture_with_dynamic_range( - PrivateKey::from_byte_array(secret_key.as_secret_bytes(), Network::Mainnet) + PrivateKey::from_byte_array(&secret_key.to_bytes(), Network::Mainnet) .expect("valid test secret key"), amount_range, rng, @@ -2316,7 +2316,7 @@ impl NetworkStrategy { ( asset_lock_proof, - secret_key.to_secret_bytes().to_vec(), + secret_key.to_bytes().to_vec(), funded_amount, ) } @@ -3170,10 +3170,9 @@ fn create_signed_instant_asset_lock_proofs_for_identities( .unwrap(); let pk_fixed: [u8; 32] = pk.try_into().unwrap(); - let secret_key = SecretKey::from_str(hex::encode(pk_fixed).as_str()).unwrap(); - let private_key = - PrivateKey::from_byte_array(secret_key.as_secret_bytes(), Network::Mainnet) - .expect("valid test secret key"); + let secret_key = SecretKey::from_bytes(&pk_fixed).unwrap(); + let private_key = PrivateKey::from_byte_array(&secret_key.to_bytes(), Network::Mainnet) + .expect("valid test secret key"); let mut asset_lock_proof = instant_asset_lock_proof_fixture_with_dynamic_range( private_key, diff --git a/packages/rs-platform-wallet-ffi/Cargo.toml b/packages/rs-platform-wallet-ffi/Cargo.toml index fd8a735f80a..62ead3c9b7a 100644 --- a/packages/rs-platform-wallet-ffi/Cargo.toml +++ b/packages/rs-platform-wallet-ffi/Cargo.toml @@ -10,6 +10,8 @@ description = "C FFI bindings for platform-wallet" crate-type = ["staticlib", "cdylib", "rlib"] [dependencies] +# Core does not expose the ECDH primitives used at this binding boundary. +secp256k1 = { workspace = true } # `bls`/`eddsa` are required explicitly, not just inherited from # `platform-wallet`'s default features: `persistence.rs` calls # `rebuild_provider_key_account` and matches on `ProviderKeyExtendedPubKey`, diff --git a/packages/rs-platform-wallet-ffi/src/dashpay.rs b/packages/rs-platform-wallet-ffi/src/dashpay.rs index 94960f1378f..bb61b971620 100644 --- a/packages/rs-platform-wallet-ffi/src/dashpay.rs +++ b/packages/rs-platform-wallet-ffi/src/dashpay.rs @@ -32,6 +32,7 @@ //! established contact via their `DashpayExternalAccount`. Runs //! the Core transaction path internally. +use dashcore::ecdsa::EcdsaSecretKey; use std::ffi::CStr; use std::os::raw::c_char; @@ -821,7 +822,7 @@ impl platform_wallet::ContactCryptoProvider for ResolverContactCryptoProvider { async fn ecdh_shared_secret( &self, path: &key_wallet::bip32::DerivationPath, - peer: &dpp::secp256k1::PublicKey, + peer: &secp256k1::PublicKey, ) -> Result, platform_wallet::PlatformWalletError> { self.signer .ecdh_shared_secret(path, peer) @@ -831,28 +832,28 @@ impl platform_wallet::ContactCryptoProvider for ResolverContactCryptoProvider { async fn export_auto_accept_private_key( &self, path: &key_wallet::bip32::DerivationPath, - ) -> Result { + ) -> Result { let scalar = self .signer .export_auto_accept_private_key(path) .map_err(|e| { platform_wallet::PlatformWalletError::InvalidIdentityData(e.to_string()) })?; - dpp::secp256k1::SecretKey::from_secret_bytes(*scalar) + EcdsaSecretKey::from_bytes(&scalar) .map_err(|e| platform_wallet::PlatformWalletError::InvalidIdentityData(e.to_string())) } async fn export_invitation_private_key( &self, path: &key_wallet::bip32::DerivationPath, - ) -> Result { + ) -> Result { let scalar = self .signer .export_invitation_private_key(path) .map_err(|e| { platform_wallet::PlatformWalletError::InvalidIdentityData(e.to_string()) })?; - dpp::secp256k1::SecretKey::from_secret_bytes(*scalar) + EcdsaSecretKey::from_bytes(&scalar) .map_err(|e| platform_wallet::PlatformWalletError::InvalidIdentityData(e.to_string())) } diff --git a/packages/rs-platform-wallet-ffi/src/invitation.rs b/packages/rs-platform-wallet-ffi/src/invitation.rs index 03d3a1eed18..f7e17540430 100644 --- a/packages/rs-platform-wallet-ffi/src/invitation.rs +++ b/packages/rs-platform-wallet-ffi/src/invitation.rs @@ -682,8 +682,8 @@ pub unsafe extern "C" fn platform_wallet_parse_invitation( #[cfg(test)] mod tests { use super::*; + use dashcore::ecdsa::EcdsaSecretKey; use dashcore::{Network, PrivateKey}; - use dpp::secp256k1::SecretKey; // Marshalling-boundary coverage. The invitation codec and claim semantics // are pinned library-side in `dash_sdk::platform::dashpay`'s invitation @@ -853,8 +853,8 @@ mod tests { /// unknown wallet is looked up, and no signer/network work is attempted. #[test] fn claim_invitation_rejects_duplicate_key_ids_before_wallet_lookup() { - let voucher = SecretKey::from_secret_bytes([0x11u8; 32]).expect("valid scalar"); - let wif = PrivateKey::from_byte_array(&voucher.to_secret_bytes(), Network::Testnet) + let voucher = EcdsaSecretKey::from_bytes(&[0x11u8; 32]).expect("valid scalar"); + let wif = PrivateKey::from_byte_array(&voucher.to_bytes(), Network::Testnet) .expect("valid voucher") .to_wif(); let uri = @@ -930,8 +930,8 @@ mod tests { /// (percent-decoded), and both are null for a link that carries neither. #[test] fn should_surface_inviter_display_name_and_avatar_in_the_preview() { - let key = SecretKey::from_secret_bytes([0x11u8; 32]).unwrap(); - let wif = PrivateKey::from_byte_array(&key.to_secret_bytes(), Network::Testnet) + let key = EcdsaSecretKey::from_bytes(&[0x11u8; 32]).unwrap(); + let wif = PrivateKey::from_byte_array(&key.to_bytes(), Network::Testnet) .expect("valid key") .to_wif(); let txid = "ab".repeat(32); diff --git a/packages/rs-platform-wallet-ffi/src/secp256k1_primitives.rs b/packages/rs-platform-wallet-ffi/src/secp256k1_primitives.rs index 3d65d672fc0..8ba7b0d17cc 100644 --- a/packages/rs-platform-wallet-ffi/src/secp256k1_primitives.rs +++ b/packages/rs-platform-wallet-ffi/src/secp256k1_primitives.rs @@ -2,8 +2,9 @@ use std::slice; -use dpp::secp256k1::ecdh::shared_secret_point; -use dpp::secp256k1::{PublicKey, SecretKey}; +use dashcore::ecdsa::{EcdsaPublicKey, EcdsaSecretKey}; +use secp256k1::ecdh::shared_secret_point; +use secp256k1::SecretKey; use zeroize::Zeroizing; use crate::error::*; @@ -27,29 +28,25 @@ fn invalid_parameter(message: impl Into) -> PlatformWalletFFIResult { fn parse_secret_key( private_key: *const u8, private_key_len: usize, -) -> Result { +) -> Result { if private_key_len != 32 { return Err(invalid_parameter(format!( "secp256k1 private keys must be exactly 32 bytes, got {private_key_len}" ))); } - // Converting the caller's slice straight into the `[u8; 32]` - // `SecretKey::from_secret_bytes` takes would leave an unguarded copy of - // the scalar on the stack. Staging it here keeps every copy this side - // owns wiped. + // Keep the borrowed input's temporary scalar copy zeroized. let mut staged = Zeroizing::new([0u8; 32]); staged.copy_from_slice(unsafe { slice::from_raw_parts(private_key, private_key_len) }); - SecretKey::from_secret_bytes(*staged) - .map(WipingSecretKey) + EcdsaSecretKey::from_bytes(&staged) .map_err(|error| invalid_parameter(format!("Invalid secp256k1 private key: {error}"))) } fn parse_compressed_public_key( public_key: *const u8, public_key_len: usize, -) -> Result { +) -> Result { if public_key_len != 33 { return Err(invalid_parameter(format!( "Compressed secp256k1 public keys must be exactly 33 bytes, got {public_key_len}" @@ -63,7 +60,7 @@ fn parse_compressed_public_key( )); } - PublicKey::from_slice(bytes) + EcdsaPublicKey::from_bytes(bytes) .map_err(|error| invalid_parameter(format!("Invalid compressed secp256k1 point: {error}"))) } @@ -94,7 +91,7 @@ pub unsafe extern "C" fn platform_wallet_secp256k1_compressed_public_key( check_ptr!(out_pubkey); let secret_key = unwrap_result_or_return!(parse_secret_key(seckey, seckey_len)); - let compressed = PublicKey::from_secret_key(&secret_key.0).serialize(); + let compressed = secret_key.public_key().to_compressed(); std::ptr::copy_nonoverlapping(compressed.as_ptr(), out_pubkey, compressed.len()); PlatformWalletFFIResult::ok() } @@ -119,7 +116,11 @@ pub unsafe extern "C" fn platform_wallet_secp256k1_ecdh_shared_x( // the scalar here is the wallet's private ephemeral key and the point // comes from the peer, so the multiplication must not branch on the // secret. Returns `x || y`; DashConnect wants the raw, unhashed X. - let shared_point = Zeroizing::new(shared_secret_point(&public_key, &secret_key.0)); + let raw_secret = WipingSecretKey(unwrap_result_or_return!(SecretKey::from_secret_bytes( + *secret_key.to_bytes() + ) + .map_err(|error| invalid_parameter(format!("Invalid secp256k1 private key: {error}"))))); + let shared_point = Zeroizing::new(shared_secret_point(&public_key.into(), &raw_secret.0)); std::ptr::copy_nonoverlapping(shared_point.as_ptr(), out_shared_x, 32); PlatformWalletFFIResult::ok() } diff --git a/packages/rs-platform-wallet-ffi/src/utils.rs b/packages/rs-platform-wallet-ffi/src/utils.rs index b844a07f3e5..a7448ce5e1f 100644 --- a/packages/rs-platform-wallet-ffi/src/utils.rs +++ b/packages/rs-platform-wallet-ffi/src/utils.rs @@ -1,20 +1,8 @@ use crate::error::*; use crate::{check_ptr, unwrap_result_or_return}; +use dashcore::ecdsa::EcdsaSecretKey; use std::os::raw::{c_char, c_uchar}; -/// RAII guard that scrubs a `secp256k1::SecretKey`'s scalar on drop. `from_secret_bytes` -/// allocates a 32-byte scalar copy of the caller's private key, and `SecretKey` -/// has no `Drop` wipe of its own — so without this the copy would survive on the -/// stack after the call returns. Mirrors `WipingSecretKey` in -/// `rs-sdk-ffi/src/mnemonic_resolver_core_signer.rs`. -struct WipingSecretKey(dpp::secp256k1::SecretKey); - -impl Drop for WipingSecretKey { - fn drop(&mut self) { - self.0.non_secure_erase(); - } -} - /// Serialize any object to JSON bytes #[no_mangle] pub unsafe extern "C" fn platform_wallet_serialize_to_json_bytes( @@ -202,21 +190,13 @@ pub unsafe extern "C" fn platform_wallet_pubkey_hash_from_private_key( return -1; } use dashcore::hashes::Hash; - use dpp::secp256k1::{PublicKey, SecretKey}; - - let sk_bytes = std::slice::from_raw_parts(private_key, 32); - // `WipingSecretKey` scrubs the `from_secret_bytes`-allocated scalar copy on every - // exit path (the success return below, the `Err` early return, and any - // panic) — the caller's `private_key` bytes are theirs to manage, but this - // copy must not linger. - let secret_key = match <[u8; 32]>::try_from(sk_bytes) - .map_err(|_| dpp::secp256k1::Error::InvalidSecretKey) - .and_then(SecretKey::from_secret_bytes) - { - Ok(sk) => WipingSecretKey(sk), + + let sk_bytes = &*private_key.cast::<[u8; 32]>(); + let secret_key = match EcdsaSecretKey::from_bytes(sk_bytes) { + Ok(sk) => sk, Err(_) => return -1, }; - let pubkey = PublicKey::from_secret_key(&secret_key.0).serialize(); + let pubkey = secret_key.public_key().to_compressed(); let hash = dashcore::hashes::hash160::Hash::hash(&pubkey); let h: [u8; 20] = hash.to_byte_array(); std::ptr::copy_nonoverlapping(h.as_ptr(), out_hash, 20); @@ -264,9 +244,6 @@ mod tests { #[test] fn test_pubkey_hash_from_private_key_matches_canonical_derivation() { - use dashcore::hashes::Hash; - use dpp::secp256k1::{PublicKey, SecretKey}; - // A fixed, in-range scalar. let mut scalar = [0u8; 32]; scalar[31] = 1; @@ -277,10 +254,7 @@ mod tests { }; assert_eq!(rc, 0); - let sk = SecretKey::from_secret_bytes(scalar).expect("in-range scalar"); - let pubkey = PublicKey::from_secret_key(&sk).serialize(); - let expected: [u8; 20] = dashcore::hashes::hash160::Hash::hash(&pubkey).to_byte_array(); - assert_eq!(out, expected); + assert_eq!(hex::encode(out), "751e76e8199196d454941c45d1b3a323f1433bd6"); } #[test] diff --git a/packages/rs-platform-wallet/Cargo.toml b/packages/rs-platform-wallet/Cargo.toml index 7da2bb5ce6c..8a7ee0b16a5 100644 --- a/packages/rs-platform-wallet/Cargo.toml +++ b/packages/rs-platform-wallet/Cargo.toml @@ -7,6 +7,8 @@ license = "MIT" description = "Platform wallet with identity management support" [dependencies] +# platform-encryption exposes raw ECDH keys; Core has no typed ECDH API yet. +secp256k1 = { workspace = true } # Dash Platform packages dpp = { path = "../rs-dpp" } dash-sdk = { path = "../rs-sdk", default-features = false, features = ["dashpay-contract", "dpns-contract", "wallet"] } diff --git a/packages/rs-platform-wallet/examples/dpns_marketplace_testnet.rs b/packages/rs-platform-wallet/examples/dpns_marketplace_testnet.rs index 440e00a5d65..53bd2060982 100644 --- a/packages/rs-platform-wallet/examples/dpns_marketplace_testnet.rs +++ b/packages/rs-platform-wallet/examples/dpns_marketplace_testnet.rs @@ -115,10 +115,10 @@ fn dapi_addresses() -> AddressList { /// Whether `sk_bytes` is the private key for `key` (33-byte pubkey for /// ECDSA_SECP256K1, hash160 for ECDSA_HASH160). fn private_key_matches(key: &dpp::identity::IdentityPublicKey, sk_bytes: &[u8; 32]) -> bool { - let Ok(sk) = dpp::secp256k1::SecretKey::from_secret_bytes(*sk_bytes) else { + let Ok(sk) = dpp::dashcore::crypto::ecdsa::EcdsaSecretKey::from_bytes(sk_bytes) else { return false; }; - let pubkey = dpp::secp256k1::PublicKey::from_secret_key(&sk).serialize(); + let pubkey = sk.public_key().to_compressed(); match key.key_type() { KeyType::ECDSA_SECP256K1 => key.data().as_slice() == pubkey.as_slice(), KeyType::ECDSA_HASH160 => { diff --git a/packages/rs-platform-wallet/src/masternode/locator.rs b/packages/rs-platform-wallet/src/masternode/locator.rs index 380664cf904..f18a6629ce7 100644 --- a/packages/rs-platform-wallet/src/masternode/locator.rs +++ b/packages/rs-platform-wallet/src/masternode/locator.rs @@ -38,13 +38,13 @@ use dash_sdk::platform::Fetch; use dashcore::hashes::{hash160, Hash}; use dashcore::{Network, PrivateKey}; use dpp::bls::{PublicKey as BlsPublicKey, SecretKey as BlsSecretKey}; +use dpp::dashcore::crypto::ecdsa::EcdsaSecretKey as SecpSecretKey; use dpp::ed25519_dalek::SigningKey; use dpp::identifier::MasternodeIdentifiers; use dpp::identity::accessors::IdentityGettersV0; use dpp::identity::identity_public_key::accessors::v0::IdentityPublicKeyGettersV0; use dpp::identity::{Identity, Purpose}; use dpp::prelude::Identifier; -use dpp::secp256k1::{PublicKey as SecpPublicKey, SecretKey as SecpSecretKey}; use zeroize::Zeroizing; use super::list::{find_in_summaries, MasternodeListQuery, MasternodeListSummary}; @@ -224,7 +224,7 @@ fn is_mainnet(network: Network) -> bool { /// only when below the group order; ed25519 accepts any 32 bytes as a seed. fn secret_candidates(bytes: &[u8; 32]) -> Vec { let mut out = Vec::with_capacity(3); - if SecpSecretKey::from_secret_bytes(*bytes).is_ok() { + if SecpSecretKey::from_bytes(bytes).is_ok() { out.push(MasternodeLocatorInput::Secret(LocatorSecret::Ecdsa { secret: Zeroizing::new(*bytes), compressed: true, @@ -358,12 +358,12 @@ pub fn parse_locator_input( /// hash160 of the secp256k1 public key for `secret`, or `None` when the /// scalar is out of range. pub fn ecdsa_key_id(secret: &[u8; 32], compressed: bool) -> Option<[u8; 20]> { - let sk = SecpSecretKey::from_secret_bytes(*secret).ok()?; - let pk = SecpPublicKey::from_secret_key(&sk); + let sk = SecpSecretKey::from_bytes(secret).ok()?; + let pk = sk.public_key(); let bytes: Vec = if compressed { - pk.serialize().to_vec() + pk.to_compressed().to_vec() } else { - pk.serialize_uncompressed().to_vec() + pk.to_uncompressed().to_vec() }; Some(hash160::Hash::hash(&bytes).to_byte_array()) } diff --git a/packages/rs-platform-wallet/src/wallet/identity/crypto/auto_accept.rs b/packages/rs-platform-wallet/src/wallet/identity/crypto/auto_accept.rs index 959afd6ab7e..5232b4d8339 100644 --- a/packages/rs-platform-wallet/src/wallet/identity/crypto/auto_accept.rs +++ b/packages/rs-platform-wallet/src/wallet/identity/crypto/auto_accept.rs @@ -24,9 +24,11 @@ //! //! `m/9'/coin'/16'/timestamp'` (all segments hardened) +use dashcore::crypto::ecdsa::{ + EcdsaError, EcdsaPublicKey, EcdsaSecretKey as SecretKey, EcdsaSignature, +}; use dashcore::hashes::{sha256, Hash, HashEngine}; use dpp::prelude::Identifier; -use dpp::secp256k1::{ecdsa::Signature, Message, SecretKey}; use key_wallet::bip32::{ChildNumber, DerivationPath}; use key_wallet::dip9::{ DASH_COIN_TYPE, DASH_TESTNET_COIN_TYPE, FEATURE_PURPOSE, FEATURE_PURPOSE_DASHPAY_AUTO_ACCEPT, @@ -117,7 +119,7 @@ pub fn derive_auto_accept_private_key( let secret_bytes = ext_priv.private_key.to_bytes(); - SecretKey::from_secret_bytes(*secret_bytes).map_err(|e| { + SecretKey::from_bytes(&secret_bytes).map_err(|e| { PlatformWalletError::InvalidIdentityData(format!( "Invalid derived auto-accept private key: {}", e @@ -148,16 +150,17 @@ pub fn sign_auto_accept_proof( timestamp: u32, ) -> Vec { let msg_hash = build_message_hash(sender_id, recipient_id, account_reference); - let message = Message::from_digest(msg_hash); - let signature = secret_key.sign_ecdsa(message); - let sig_bytes = signature.serialize_compact(); + // Recoverable signing preserves RFC 6979 bytes without low-R grinding. + let signature = secret_key.sign_recoverable(&msg_hash); + let compact = signature.to_bytes(); + let sig_bytes = &compact[1..]; let mut proof = Vec::with_capacity(1 + 4 + 1 + 64); proof.push(KEY_TYPE_ECDSA); proof.extend_from_slice(×tamp.to_be_bytes()); // 4 bytes BE proof.push(ECDSA_SIG_SIZE); - proof.extend_from_slice(&sig_bytes); // 64 bytes compact ECDSA + proof.extend_from_slice(sig_bytes); // 64 bytes compact ECDSA proof } @@ -219,7 +222,7 @@ pub fn auto_accept_proof_expiry(proof_bytes: &[u8]) -> Option { /// check clock-free makes it deterministically testable; the acceptance path /// pairs the two.) pub fn verify_auto_accept_proof_with_pubkey( - pubkey: &dpp::secp256k1::PublicKey, + pubkey: &EcdsaPublicKey, proof_bytes: &[u8], sender_id: &Identifier, recipient_id: &Identifier, @@ -232,17 +235,18 @@ pub fn verify_auto_accept_proof_with_pubkey( if sig_len != 64 || proof_bytes.len() < 6 + sig_len { return false; } - let signature_bytes = &proof_bytes[6..6 + sig_len]; + let Ok(signature_bytes) = <&[u8; 64]>::try_from(&proof_bytes[6..6 + sig_len]) else { + return false; + }; let msg_hash = build_message_hash(sender_id, recipient_id, account_reference); - let message = Message::from_digest(msg_hash); - let signature = match Signature::from_compact(signature_bytes) { + let signature = match EcdsaSignature::from_bytes(signature_bytes) { Ok(s) => s, Err(_) => return false, }; - signature.verify(message, pubkey).is_ok() + pubkey.verify(&msg_hash, signature).is_ok() } /// Verify an auto-accept proof by re-deriving the expected key from `wallet`. @@ -265,7 +269,7 @@ pub fn verify_auto_accept_proof( return Ok(false); }; let secret_key = derive_auto_accept_private_key(wallet, network, timestamp)?; - let pubkey = dpp::secp256k1::PublicKey::from_secret_key(&secret_key); + let pubkey = secret_key.public_key(); Ok(verify_auto_accept_proof_with_pubkey( &pubkey, proof_bytes, @@ -294,7 +298,7 @@ pub fn encode_auto_accept_key_blob(secret_key: &SecretKey, expiry: u32) -> Vec Result<(SecretKey, u32), Plat return Err(invalid("auto-accept key size must be 32")); } let secret_key = <[u8; 32]>::try_from(&blob[6..KEY_BLOB_LEN]) - .map_err(|_| dpp::secp256k1::Error::InvalidSecretKey) - .and_then(SecretKey::from_secret_bytes) + .map_err(|_| EcdsaError::InvalidSecretKey) + .and_then(|bytes| SecretKey::from_bytes(&bytes)) .map_err(|e| invalid(format!("invalid auto-accept private key: {e}")))?; Ok((secret_key, expiry)) } @@ -404,6 +408,29 @@ mod tests { ) } + #[test] + fn should_preserve_historical_auto_accept_signature_bytes() { + let (sender, recipient) = test_ids(); + for scalar in 1..=64u8 { + let bytes = [scalar; 32]; + let key = SecretKey::from_bytes(&bytes).unwrap(); + let legacy = secp256k1::SecretKey::from_secret_bytes(bytes).unwrap(); + let hash = build_message_hash(&sender, &recipient, 42); + let expected = legacy + .sign_ecdsa(secp256k1::Message::from_digest(hash)) + .serialize_compact(); + let proof = sign_auto_accept_proof(&key, &sender, &recipient, 42, 100); + assert_eq!(&proof[6..], &expected); + assert!(verify_auto_accept_proof_with_pubkey( + &key.public_key(), + &proof, + &sender, + &recipient, + 42 + )); + } + } + #[test] fn test_generate_proof_format() { let wallet = test_wallet(); @@ -573,7 +600,7 @@ mod tests { assert_eq!(proof.len(), 70); assert_eq!(auto_accept_proof_expiry(&proof), Some(expiry)); - let pubkey = dpp::secp256k1::PublicKey::from_secret_key(&owner_key); + let pubkey = owner_key.public_key(); assert!( verify_auto_accept_proof_with_pubkey(&pubkey, &proof, &scanner, &owner, account_ref), "owner verifies the scanner's proof against its own re-derived pubkey" @@ -595,14 +622,14 @@ mod tests { #[test] fn key_blob_round_trip_and_rejects_malformed() { - let key = SecretKey::from_secret_bytes([0x07u8; 32]).unwrap(); + let key = SecretKey::from_bytes(&[0x07u8; 32]).unwrap(); let blob = encode_auto_accept_key_blob(&key, 12345); assert_eq!(blob.len(), 38); assert_eq!(blob[0], 0x00); // key type assert_eq!(blob[5], 0x20); // key size let (k2, e2) = decode_auto_accept_key_blob(&blob).expect("decode"); - assert_eq!(k2.to_secret_bytes(), key.to_secret_bytes()); + assert_eq!(k2.to_bytes(), key.to_bytes()); assert_eq!(e2, 12345); assert!(decode_auto_accept_key_blob(&blob[..37]).is_err(), "short"); @@ -616,7 +643,7 @@ mod tests { #[test] fn uri_round_trip_and_rejects_malformed() { - let key = SecretKey::from_secret_bytes([0x09u8; 32]).unwrap(); + let key = SecretKey::from_bytes(&[0x09u8; 32]).unwrap(); let blob = encode_auto_accept_key_blob(&key, 999); let uri = encode_dashpay_contact_uri("bobspizza", &blob); assert!(uri.starts_with("dash:?du=bobspizza&dapk=")); @@ -664,7 +691,7 @@ mod tests { ); // The cap must not reject a normal-length (valid) dapk. - let key = SecretKey::from_secret_bytes([0x09u8; 32]).unwrap(); + let key = SecretKey::from_bytes(&[0x09u8; 32]).unwrap(); let blob = encode_auto_accept_key_blob(&key, 1); let uri = encode_dashpay_contact_uri("alice", &blob); assert!( @@ -675,8 +702,8 @@ mod tests { #[test] fn verify_with_pubkey_rejects_truncated_and_no_expiry() { - let key = SecretKey::from_secret_bytes([0x05u8; 32]).unwrap(); - let pubkey = dpp::secp256k1::PublicKey::from_secret_key(&key); + let key = SecretKey::from_bytes(&[0x05u8; 32]).unwrap(); + let pubkey = key.public_key(); let (s, r) = test_ids(); assert!(!verify_auto_accept_proof_with_pubkey( &pubkey, &[0u8; 3], &s, &r, 0 diff --git a/packages/rs-platform-wallet/src/wallet/identity/crypto/validation.rs b/packages/rs-platform-wallet/src/wallet/identity/crypto/validation.rs index 8b46ce08955..820cec79a72 100644 --- a/packages/rs-platform-wallet/src/wallet/identity/crypto/validation.rs +++ b/packages/rs-platform-wallet/src/wallet/identity/crypto/validation.rs @@ -364,7 +364,7 @@ pub(crate) fn validate_recipient_key( /// drift from the discovery-time ownership decision. /// /// `derived_pubkey` is the 33-byte compressed pubkey re-derived at a -/// breadcrumb path (`ExtendedPubKey::from_priv(..).public_key.serialize()`). +/// breadcrumb path (`ExtendedPubKey::from_priv(..).public_key.to_compressed()`). /// `expected_key_data` is the on-chain key's `data`, discriminated by length: /// /// - **33 bytes** → the on-chain key is an `ECDSA_SECP256K1` key whose `data` @@ -851,11 +851,11 @@ mod tests { /// Derive the compressed secp256k1 pubkey (`[u8; 33]`) for a fixed /// in-range scalar — the shape a breadcrumb re-derivation produces. fn fixed_scalar_and_compressed_pubkey() -> ([u8; 32], [u8; 33]) { - use dpp::secp256k1::{PublicKey, SecretKey}; + use dpp::dashcore::crypto::ecdsa::EcdsaSecretKey as SecretKey; let mut scalar = [0u8; 32]; scalar[31] = 7; - let sk = SecretKey::from_secret_bytes(scalar).expect("in-range scalar"); - let pubkey = PublicKey::from_secret_key(&sk).serialize(); + let sk = SecretKey::from_bytes(&scalar).expect("in-range scalar"); + let pubkey = sk.public_key().to_compressed(); (scalar, pubkey) } diff --git a/packages/rs-platform-wallet/src/wallet/identity/network/contact_info.rs b/packages/rs-platform-wallet/src/wallet/identity/network/contact_info.rs index 851b94291ef..2bebfc03bad 100644 --- a/packages/rs-platform-wallet/src/wallet/identity/network/contact_info.rs +++ b/packages/rs-platform-wallet/src/wallet/identity/network/contact_info.rs @@ -515,8 +515,8 @@ impl DashPayView<'_, B> { S: Signer + Send + Sync, C: super::ContactCryptoProvider + Sync, { + use dpp::dashcore::key::rand::{rng, RngCore}; use dpp::data_contract::accessors::v0::DataContractV0Getters; - use dpp::secp256k1::rand::{rng, RngCore}; // Build the decrypted-payload struct once: it is both the local // metadata applied to the contact AND (on publish) the plaintext the diff --git a/packages/rs-platform-wallet/src/wallet/identity/network/contact_requests.rs b/packages/rs-platform-wallet/src/wallet/identity/network/contact_requests.rs index 4d9e3e2eafb..302c2c9855f 100644 --- a/packages/rs-platform-wallet/src/wallet/identity/network/contact_requests.rs +++ b/packages/rs-platform-wallet/src/wallet/identity/network/contact_requests.rs @@ -1,6 +1,7 @@ //! DashPay contact request lifecycle: send, sync, accept, reject. use super::signing_key::AvailableSigningKey; +use dpp::dashcore::crypto::ecdsa::EcdsaSecretKey; use dpp::document::DocumentV0Getters; use dpp::identity::accessors::IdentityGettersV0; use dpp::identity::identity_public_key::accessors::v0::IdentityPublicKeyGettersV0; @@ -53,7 +54,7 @@ pub trait ContactCryptoProvider { async fn ecdh_shared_secret( &self, path: &key_wallet::bip32::DerivationPath, - peer: &dpp::secp256k1::PublicKey, + peer: &secp256k1::PublicKey, ) -> Result, PlatformWalletError>; /// Export the raw **auto-accept private key** at `path` (DIP-15 QR @@ -67,7 +68,7 @@ pub trait ContactCryptoProvider { async fn export_auto_accept_private_key( &self, path: &key_wallet::bip32::DerivationPath, - ) -> Result; + ) -> Result; /// Export the raw **invitation-funding private key** at `path` (DIP-13 /// sub-feature `3'`) — the second deliberate raw-key export (alongside @@ -88,7 +89,7 @@ pub trait ContactCryptoProvider { async fn export_invitation_private_key( &self, _path: &key_wallet::bip32::DerivationPath, - ) -> Result { + ) -> Result { Err(PlatformWalletError::InvalidIdentityData( "invitation private-key export is not supported by this crypto provider".to_string(), )) @@ -204,14 +205,14 @@ impl ContactCryptoProvider for SeedCryptoProvider { async fn ecdh_shared_secret( &self, path: &key_wallet::bip32::DerivationPath, - peer: &dpp::secp256k1::PublicKey, + peer: &secp256k1::PublicKey, ) -> Result, PlatformWalletError> { let xprv = self.wallet.derive_extended_private_key(path).map_err(|e| { PlatformWalletError::InvalidIdentityData(format!("test ecdh derive: {e}")) })?; Ok(zeroize::Zeroizing::new( platform_encryption::derive_shared_key_ecdh( - &dpp::secp256k1::SecretKey::from_secret_bytes(*xprv.private_key.to_bytes()) + &secp256k1::SecretKey::from_secret_bytes(*xprv.private_key.to_bytes()) .map_err(|e| PlatformWalletError::KeyDerivation(e.to_string()))?, peer, ), @@ -221,22 +222,22 @@ impl ContactCryptoProvider for SeedCryptoProvider { async fn export_auto_accept_private_key( &self, path: &key_wallet::bip32::DerivationPath, - ) -> Result { + ) -> Result { let xprv = self.wallet.derive_extended_private_key(path).map_err(|e| { PlatformWalletError::InvalidIdentityData(format!("test export auto-accept: {e}")) })?; - dpp::secp256k1::SecretKey::from_secret_bytes(*xprv.private_key.to_bytes()) + EcdsaSecretKey::from_bytes(&xprv.private_key.to_bytes()) .map_err(|e| PlatformWalletError::KeyDerivation(e.to_string())) } async fn export_invitation_private_key( &self, path: &key_wallet::bip32::DerivationPath, - ) -> Result { + ) -> Result { let xprv = self.wallet.derive_extended_private_key(path).map_err(|e| { PlatformWalletError::InvalidIdentityData(format!("test export invitation: {e}")) })?; - dpp::secp256k1::SecretKey::from_secret_bytes(*xprv.private_key.to_bytes()) + EcdsaSecretKey::from_bytes(&xprv.private_key.to_bytes()) .map_err(|e| PlatformWalletError::KeyDerivation(e.to_string())) } @@ -372,7 +373,7 @@ pub enum AutoAcceptProofSource { /// QR (`dapk`), binding it to the accountReference this send computes. SignWithKey { /// The auto-accept private key handed out in the QR. - secret_key: dpp::secp256k1::SecretKey, + secret_key: EcdsaSecretKey, /// The proof's expiry (the key blob's timestamp / derivation index). expiry: u32, }, @@ -653,7 +654,7 @@ impl DashPayView<'_, B> { "Recipient identity has no key at index {recipient_key_index}" )) })?; - dpp::secp256k1::PublicKey::from_slice(key.data().as_slice()).map_err(|e| { + secp256k1::PublicKey::from_slice(key.data().as_slice()).map_err(|e| { PlatformWalletError::InvalidIdentityData(format!( "Recipient encryption public key is invalid: {e}" )) @@ -2529,25 +2530,23 @@ impl DashPayView<'_, B> { .public_keys() .get(contact_encryption_key_index) { - Some(k) => { - match dpp::secp256k1::PublicKey::from_slice(k.data().as_slice()) { - Ok(pk) => pk, - Err(e) => { - tracing::warn!( - owner = %entry.owner_identity_id, contact = %entry.contact_id, - error = %e, - "drain: contact encryption key invalid; marking channel broken" - ); - self.mark_contact_channel_broken( - &entry.owner_identity_id, - &entry.contact_id, - ) - .await; - cleared.push(entry.key()); - continue; - } + Some(k) => match secp256k1::PublicKey::from_slice(k.data().as_slice()) { + Ok(pk) => pk, + Err(e) => { + tracing::warn!( + owner = %entry.owner_identity_id, contact = %entry.contact_id, + error = %e, + "drain: contact encryption key invalid; marking channel broken" + ); + self.mark_contact_channel_broken( + &entry.owner_identity_id, + &entry.contact_id, + ) + .await; + cleared.push(entry.key()); + continue; } - } + }, None => { // Left queued, not broken: the contact's identity // can gain this key later, exactly as ours can, and @@ -3075,7 +3074,7 @@ impl DashPayView<'_, B> { } }; let valid = verify_auto_accept_proof_with_pubkey( - &pubkey.into(), + &pubkey, proof, &request.sender_id, &owner, @@ -3748,7 +3747,7 @@ impl DashPayView<'_, B> { "Contact identity has no key at index {contact_encryption_key_index}" )) })?; - dpp::secp256k1::PublicKey::from_slice(key.data().as_slice()).map_err(|e| { + secp256k1::PublicKey::from_slice(key.data().as_slice()).map_err(|e| { PlatformWalletError::InvalidIdentityData(format!( "Contact encryption public key is invalid: {e}" )) @@ -5898,7 +5897,7 @@ mod contact_info_provider_tests { /// the resident `derive_shared_key_ecdh` at the same path. #[tokio::test] async fn ecdh_shared_secret_returns_zeroizing_matching_resident_derivation() { - use dpp::secp256k1::{PublicKey, SecretKey}; + use secp256k1::{PublicKey, SecretKey}; let seed = Mnemonic::from_phrase(PHRASE) .expect("valid mnemonic") diff --git a/packages/rs-platform-wallet/src/wallet/identity/network/identity_handle.rs b/packages/rs-platform-wallet/src/wallet/identity/network/identity_handle.rs index ff30931ed2c..fd5d367f61b 100644 --- a/packages/rs-platform-wallet/src/wallet/identity/network/identity_handle.rs +++ b/packages/rs-platform-wallet/src/wallet/identity/network/identity_handle.rs @@ -744,7 +744,7 @@ mod tests { /// the returned scalar. #[test] fn connect_keypairs_match_the_pinned_vectors() { - use dpp::secp256k1::{PublicKey as SecpPublicKey, SecretKey}; + use dpp::dashcore::crypto::ecdsa::EcdsaSecretKey as SecretKey; for (network, key, expected) in [ ( @@ -764,11 +764,8 @@ mod tests { assert_eq!(derived.derivation_path, key.derivation_path(network)); let secret: [u8; 32] = *derived.private_key; - let sk = SecretKey::from_secret_bytes(secret).expect("valid scalar"); - assert_eq!( - SecpPublicKey::from_secret_key(&sk).serialize(), - derived.public_key - ); + let sk = SecretKey::from_bytes(&secret).expect("valid scalar"); + assert_eq!(sk.public_key().to_compressed(), derived.public_key); } } diff --git a/packages/rs-platform-wallet/src/wallet/identity/network/invitation.rs b/packages/rs-platform-wallet/src/wallet/identity/network/invitation.rs index 2e475a55f86..b00db6a513a 100644 --- a/packages/rs-platform-wallet/src/wallet/identity/network/invitation.rs +++ b/packages/rs-platform-wallet/src/wallet/identity/network/invitation.rs @@ -14,6 +14,7 @@ //! ([`send_contact_request_with_external_signer`](IdentityWallet::send_contact_request_with_external_signer)). use std::collections::BTreeMap; +use zeroize::Zeroize; use dpp::identity::accessors::IdentityGettersV0; use dpp::identity::signer::Signer; @@ -259,7 +260,7 @@ impl IdentityWallet { let mut voucher_key = crypto_provider.export_invitation_private_key(&path).await?; // Build the (secret) URI, then scrub the exported scalar on BOTH the - // success and the encode-error path. `secp256k1::SecretKey` has no + // success and the encode-error path. `EcdsaSecretKey` has no // Drop-zeroize, so wipe it explicitly; scrubbing before propagating an // encode failure matters most there — on that path the key never // legitimately left the device, so a lingering copy is the worst kind. @@ -267,7 +268,7 @@ impl IdentityWallet { // the embedded proof; the invitee refetches the tx at claim. let network = self.sdk.network; let uri_result = encode_invitation_uri(&voucher_key, network, &proof, inviter.as_ref()); - voucher_key.non_secure_erase(); + voucher_key.zeroize(); let uri = uri_result?; Ok(Invitation { diff --git a/packages/rs-platform-wallet/src/wallet/identity/network/payments.rs b/packages/rs-platform-wallet/src/wallet/identity/network/payments.rs index f6a4f3919b1..192bf94d6f5 100644 --- a/packages/rs-platform-wallet/src/wallet/identity/network/payments.rs +++ b/packages/rs-platform-wallet/src/wallet/identity/network/payments.rs @@ -2011,6 +2011,7 @@ mod tests { //! 3. Reconcile must be idempotent and never clobber an existing //! entry for the same txid. + use dpp::dashcore::crypto::ecdsa::EcdsaSecretKey; use key_wallet::wallet::managed_wallet_info::wallet_info_interface::WalletInfoInterface; use std::collections::BTreeMap; use std::sync::{Arc, Mutex}; @@ -2511,11 +2512,11 @@ mod tests { ) -> Identity { use dpp::identity::identity_public_key::v0::IdentityPublicKeyV0; use dpp::identity::{IdentityPublicKey, SecurityLevel}; - let data = dpp::secp256k1::PublicKey::from_secret_key( - &dpp::secp256k1::SecretKey::from_secret_bytes([0x37u8; 32]).expect("secret"), - ) - .serialize() - .to_vec(); + let data = EcdsaSecretKey::from_bytes(&[0x37u8; 32]) + .expect("secret") + .public_key() + .to_compressed() + .to_vec(); Identity::V0(IdentityV0 { id: Identifier::from(id_bytes), public_keys: [( @@ -11138,12 +11139,12 @@ mod tests { contract_bounds: None, key_type: KeyType::ECDSA_SECP256K1, read_only: false, - data: dpp::secp256k1::PublicKey::from_secret_key( - &dpp::secp256k1::SecretKey::from_secret_bytes([0x24u8; 32]).expect("secret"), - ) - .serialize() - .to_vec() - .into(), + data: EcdsaSecretKey::from_bytes(&[0x24u8; 32]) + .expect("secret") + .public_key() + .to_compressed() + .to_vec() + .into(), disabled_at: None, }); let our_identity = Identity::V0(IdentityV0 { @@ -11406,9 +11407,9 @@ mod tests { let provider = SeedCryptoProvider::from_seed(seed, Network::Testnet); // The contact's encryption keypair (the "sender" of the request). - let contact_secret = dpp::secp256k1::SecretKey::from_secret_bytes([0x42u8; 32]) - .expect("valid contact secret"); - let contact_public = dpp::secp256k1::PublicKey::from_secret_key(&contact_secret); + let contact_secret = + secp256k1::SecretKey::from_secret_bytes([0x42u8; 32]).expect("valid contact secret"); + let contact_public = secp256k1::PublicKey::from_secret_key(&contact_secret); // Our side, through the production provider. let ours = provider @@ -11500,12 +11501,12 @@ mod tests { contract_bounds: None, key_type: KeyType::ECDSA_SECP256K1, read_only: false, - data: dpp::secp256k1::PublicKey::from_secret_key( - &dpp::secp256k1::SecretKey::from_secret_bytes([byte; 32]).expect("secret"), - ) - .serialize() - .to_vec() - .into(), + data: EcdsaSecretKey::from_bytes(&[byte; 32]) + .expect("secret") + .public_key() + .to_compressed() + .to_vec() + .into(), disabled_at: None, }) }; @@ -11677,7 +11678,7 @@ mod tests { async fn ecdh_shared_secret( &self, _path: &key_wallet::bip32::DerivationPath, - _peer: &dpp::secp256k1::PublicKey, + _peer: &secp256k1::PublicKey, ) -> Result, crate::error::PlatformWalletError> { Ok(zeroize::Zeroizing::new([0u8; 32])) @@ -11685,13 +11686,13 @@ mod tests { async fn export_auto_accept_private_key( &self, _path: &key_wallet::bip32::DerivationPath, - ) -> Result { + ) -> Result { unimplemented!("auto-accept QR is a send-path method, not exercised by the drain") } async fn export_invitation_private_key( &self, _path: &key_wallet::bip32::DerivationPath, - ) -> Result { + ) -> Result { unimplemented!( "invitation create is a send-path method, not exercised by the drain" ) diff --git a/packages/rs-platform-wallet/src/wallet/identity/network/sdk_writer.rs b/packages/rs-platform-wallet/src/wallet/identity/network/sdk_writer.rs index 765074e7b7a..9440cd200c5 100644 --- a/packages/rs-platform-wallet/src/wallet/identity/network/sdk_writer.rs +++ b/packages/rs-platform-wallet/src/wallet/identity/network/sdk_writer.rs @@ -117,7 +117,7 @@ pub(crate) struct SendContactRequestParams<'a> { /// secret — the client-side equivalent of the old SdkSide key-id /// guard, so a recipient-key mismatch fails loudly instead of /// silently encrypting with the wrong secret. - pub expected_recipient_pubkey: dpp::secp256k1::PublicKey, + pub expected_recipient_pubkey: secp256k1::PublicKey, /// DashPay receiving-account xpub to share with the recipient, in the /// **69-byte DIP-15 compact form** (`parentFingerprint ‖ chainCode ‖ /// pubKey`) — NOT `ExtendedPubKey::encode()`. The SDK validates len == 69 @@ -222,14 +222,13 @@ impl SdkWriter { // `F`/`Fut` (SdkSide) type params are unused here, so a never-called // `fn` placeholder satisfies their bounds. // Aliased so the annotation stays under the type-complexity lint. - type UnusedSdkSideEcdh = fn( - &IdentityPublicKey, - u32, - ) -> std::future::Ready< - Result, - >; + type UnusedSdkSideEcdh = + fn( + &IdentityPublicKey, + u32, + ) -> std::future::Ready>; let ecdh_provider: EcdhProvider = EcdhProvider::ClientSide { - get_shared_secret: move |peer: &dpp::secp256k1::PublicKey| { + get_shared_secret: move |peer: &secp256k1::PublicKey| { let peer_matches = *peer == expected_recipient_pubkey; async move { if !peer_matches { diff --git a/packages/rs-platform-wallet/src/wallet/identity/network/seed_binding.rs b/packages/rs-platform-wallet/src/wallet/identity/network/seed_binding.rs index 212b901a022..4d77159bca0 100644 --- a/packages/rs-platform-wallet/src/wallet/identity/network/seed_binding.rs +++ b/packages/rs-platform-wallet/src/wallet/identity/network/seed_binding.rs @@ -609,6 +609,7 @@ impl PlatformWallet { #[cfg(test)] mod tests { use super::SeedBindingVerification; + use dpp::dashcore::crypto::ecdsa::EcdsaSecretKey; use std::sync::atomic::{AtomicUsize, Ordering}; use std::sync::Arc; use std::time::{Duration, Instant}; @@ -1753,7 +1754,7 @@ mod tests { async fn ecdh_shared_secret( &self, _path: &key_wallet::bip32::DerivationPath, - _peer: &dpp::secp256k1::PublicKey, + _peer: &secp256k1::PublicKey, ) -> Result, PlatformWalletError> { unreachable!("the gate refuses, so no queue entry is ever derived") } @@ -1761,7 +1762,7 @@ mod tests { async fn export_auto_accept_private_key( &self, _path: &key_wallet::bip32::DerivationPath, - ) -> Result { + ) -> Result { unreachable!("the gate refuses, so no queue entry is ever derived") } diff --git a/packages/rs-platform-wallet/src/wallet/shielded/wallet_drain_tests.rs b/packages/rs-platform-wallet/src/wallet/shielded/wallet_drain_tests.rs index 26d64b47140..9ccd84eb50f 100644 --- a/packages/rs-platform-wallet/src/wallet/shielded/wallet_drain_tests.rs +++ b/packages/rs-platform-wallet/src/wallet/shielded/wallet_drain_tests.rs @@ -44,8 +44,8 @@ fn drain_lock_fixture() -> (TrackedAssetLock, BTreeMap) let keys = OrchardKeySet::from_seed(&[0x42; 32], Network::Testnet, 0) .unwrap() .viewing_keys(); - let secret = dpp::secp256k1::SecretKey::from_secret_bytes([0x11; 32]).unwrap(); - let public = dashcore::PublicKey::new(dpp::secp256k1::PublicKey::from_secret_key(&secret)); + let secret = dpp::dashcore::crypto::ecdsa::EcdsaSecretKey::from_bytes(&[0x11; 32]).unwrap(); + let public = dashcore::PublicKey::new(secret.public_key()); let transaction = Transaction { version: 3, lock_time: 0, diff --git a/packages/rs-scripts/src/bin/register_identity.rs b/packages/rs-scripts/src/bin/register_identity.rs index 7c852c28155..9c67a3a6e73 100644 --- a/packages/rs-scripts/src/bin/register_identity.rs +++ b/packages/rs-scripts/src/bin/register_identity.rs @@ -514,10 +514,9 @@ async fn run() -> Result<(), String> { } else { // FRESH: generate a one-time key, build + Core-sign + broadcast the // asset lock, capturing all recovery credentials BEFORE broadcast. - let mut secp_rng = dpp::secp256k1::rand::rng(); - let one_time_secret = dpp::secp256k1::SecretKey::new(&mut secp_rng); + let one_time_secret = dpp::dashcore::crypto::ecdsa::EcdsaSecretKey::generate(); let one_time_private_key = - PrivateKey::from_byte_array(one_time_secret.as_secret_bytes(), network) + PrivateKey::from_byte_array(&one_time_secret.to_bytes(), network) .map_err(|e| format!("failed to construct asset-lock private key: {e}"))?; let one_time_public_key = one_time_private_key.public_key(); let one_time_key_hash = one_time_public_key.pubkey_hash(); diff --git a/packages/rs-sdk-ffi/Cargo.toml b/packages/rs-sdk-ffi/Cargo.toml index 33f50995ad7..3dc09beade4 100644 --- a/packages/rs-sdk-ffi/Cargo.toml +++ b/packages/rs-sdk-ffi/Cargo.toml @@ -11,6 +11,8 @@ crate-type = ["staticlib", "cdylib", "rlib"] [dependencies] +# Core does not expose the ECDH primitives used at this binding boundary. +secp256k1 = { workspace = true } dash-sdk = { path = "../rs-sdk", features = [ "dpns-contract", "dashpay-contract", diff --git a/packages/rs-sdk-ffi/src/contested_resource/transitions/cast_vote.rs b/packages/rs-sdk-ffi/src/contested_resource/transitions/cast_vote.rs index 6d969b6a2fc..28bfac3bf29 100644 --- a/packages/rs-sdk-ffi/src/contested_resource/transitions/cast_vote.rs +++ b/packages/rs-sdk-ffi/src/contested_resource/transitions/cast_vote.rs @@ -60,10 +60,10 @@ use crate::sdk::SDKWrapper; use crate::types::{FFINetwork, Network, SDKHandle}; use crate::{DashSDKResult, FFIError}; +use dash_sdk::dpp::dashcore::ecdsa::EcdsaSecretKey; use dash_sdk::dpp::dashcore::hashes::{hash160, Hash}; use dash_sdk::dpp::dashcore::ProTxHash; use dash_sdk::dpp::platform_value::{Identifier, Value}; -use dash_sdk::dpp::secp256k1::{PublicKey, SecretKey}; use dash_sdk::dpp::voting::vote_choices::resource_vote_choice::ResourceVoteChoice; use dash_sdk::dpp::voting::vote_polls::contested_document_resource_vote_poll::ContestedDocumentResourceVotePoll; use dash_sdk::dpp::voting::vote_polls::VotePoll; @@ -341,10 +341,10 @@ unsafe fn cast_vote_inner( // `masternode_voting_key.public_key_hash()` to derive the voter // identifier, and `SingleKeySigner::can_sign_with` recomputes the same // hash160 from the private key, so the two agree by construction. - let secret_key = SecretKey::from_secret_bytes(*key_array) + let secret_key = EcdsaSecretKey::from_bytes(&key_array) .map_err(|e| invalid(&format!("Invalid voting private key: {}", e)))?; - let public_key = PublicKey::from_secret_key(&secret_key); - let voting_address = hash160::Hash::hash(&public_key.serialize()).to_byte_array(); + let public_key = secret_key.public_key(); + let voting_address = hash160::Hash::hash(&public_key.to_compressed()).to_byte_array(); // ---- Broadcast, then diagnose only on failure --------------------------- let wrapper = &*(sdk_handle as *const SDKWrapper); diff --git a/packages/rs-sdk-ffi/src/mnemonic_resolver_core_signer.rs b/packages/rs-sdk-ffi/src/mnemonic_resolver_core_signer.rs index 038a089f814..7cf839d71e6 100644 --- a/packages/rs-sdk-ffi/src/mnemonic_resolver_core_signer.rs +++ b/packages/rs-sdk-ffi/src/mnemonic_resolver_core_signer.rs @@ -60,7 +60,6 @@ use std::ffi::c_void; use std::os::raw::c_char; use async_trait::async_trait; -use dash_sdk::dpp::secp256k1; use key_wallet::bip32::{ChildNumber, DerivationPath, ExtendedPrivKey, ExtendedPubKey}; use key_wallet::dashcore::ecdsa::{EcdsaError, EcdsaPublicKey, EcdsaSecretKey, EcdsaSignature}; use key_wallet::dip9::{ diff --git a/packages/rs-sdk/Cargo.toml b/packages/rs-sdk/Cargo.toml index 8ed5f0992dd..39e8764c84c 100644 --- a/packages/rs-sdk/Cargo.toml +++ b/packages/rs-sdk/Cargo.toml @@ -4,6 +4,8 @@ version.workspace = true edition = "2021" [dependencies] +# platform-encryption exposes raw ECDH keys; Core has no typed ECDH API yet. +secp256k1 = { workspace = true } arc-swap = { version = "1.7.1" } chrono = { version = "0.4.38" } diff --git a/packages/rs-sdk/src/platform/dashpay/contact_request.rs b/packages/rs-sdk/src/platform/dashpay/contact_request.rs index 3f528a4bba6..ab7f340b5fe 100644 --- a/packages/rs-sdk/src/platform/dashpay/contact_request.rs +++ b/packages/rs-sdk/src/platform/dashpay/contact_request.rs @@ -5,6 +5,8 @@ use crate::platform::transition::put_document::PutDocument; use crate::platform::Document; use crate::{Error, Sdk}; +use dpp::dashcore::key::rand::rngs::StdRng; +use dpp::dashcore::key::rand::{Rng, RngCore, SeedableRng}; use dpp::data_contract::accessors::v0::DataContractV0Getters; use dpp::data_contract::document_type::accessors::DocumentTypeV0Getters; use dpp::document::DocumentV0; @@ -15,12 +17,10 @@ use dpp::identity::signer::Signer; use dpp::identity::{Identity, IdentityPublicKey}; use dpp::platform_value::{Bytes32, Value}; use dpp::prelude::Identifier; -use dpp::secp256k1::rand::rngs::StdRng; -use dpp::secp256k1::rand::{Rng, RngCore, SeedableRng}; -use dpp::secp256k1::{PublicKey, SecretKey}; use platform_encryption::{ derive_shared_key_ecdh, encrypt_account_label, encrypt_extended_public_key, COMPACT_XPUB_LEN, }; +use secp256k1::{PublicKey, SecretKey}; use std::collections::BTreeMap; /// ECDH provider for contact request encryption @@ -575,8 +575,7 @@ impl Sdk { #[cfg(test)] mod tests { use super::*; - use dpp::secp256k1; - use dpp::secp256k1::rand::{self, RngCore}; + use dpp::dashcore::key::rand::{self, RngCore}; #[test] fn test_ecdh_encryption_produces_correct_size() { diff --git a/packages/rs-sdk/src/platform/dashpay/invitation.rs b/packages/rs-sdk/src/platform/dashpay/invitation.rs index 23f29a33744..1ac9bc91769 100644 --- a/packages/rs-sdk/src/platform/dashpay/invitation.rs +++ b/packages/rs-sdk/src/platform/dashpay/invitation.rs @@ -67,8 +67,10 @@ //! emit it. use std::collections::BTreeMap; +use zeroize::Zeroize; use dpp::dashcore::consensus::Decodable; +use dpp::dashcore::crypto::ecdsa::EcdsaSecretKey as SecretKey; use dpp::dashcore::transaction::special_transaction::TransactionPayload; use dpp::dashcore::{InstantLock, Network, OutPoint, PrivateKey, ScriptBuf, Transaction, TxOut}; use dpp::identity::accessors::IdentityGettersV0; @@ -81,7 +83,6 @@ use dpp::identity::state_transition::asset_lock_proof::InstantAssetLockProof; use dpp::identity::v0::IdentityV0; use dpp::identity::{Identity, IdentityPublicKey, KeyID, Purpose, SecurityLevel}; use dpp::prelude::{AssetLockProof, Identifier}; -use dpp::secp256k1::{PublicKey, SecretKey}; use crate::core::FetchedCoreTransaction; use crate::platform::transition::asset_lock_submission::{ @@ -252,7 +253,7 @@ impl Drop for ParsedInvitation { /// Scrub the voucher scalar on drop — it is literal bearer money. Mirrors /// the resolver signer's key hygiene (`WipingSecretKey`). fn drop(&mut self) { - self.voucher_key.non_secure_erase(); + self.voucher_key.zeroize(); } } @@ -276,7 +277,7 @@ fn invalid(msg: impl Into) -> InvitationError { /// The P2PKH script the voucher key controls (compressed-pubkey hash160). This /// is the selector that binds the voucher key to its funded credit output. fn voucher_credit_script(voucher_key: &SecretKey) -> ScriptBuf { - let pubkey = PublicKey::from_secret_key(voucher_key); + let pubkey = voucher_key.public_key(); let hash = dpp::dashcore::PublicKey::new(pubkey).pubkey_hash(); ScriptBuf::new_p2pkh(&hash) } @@ -423,7 +424,7 @@ pub fn encode_invitation_uri( }; // WIF, compressed (the default for `PrivateKey::new`), network-correct. - let private_key = PrivateKey::from_byte_array(&voucher_key.to_secret_bytes(), network) + let private_key = PrivateKey::from_byte_array(&voucher_key.to_bytes(), network) .map_err(|e| invalid(format!("invalid invitation voucher key: {e}")))?; let mut wif = String::with_capacity(52); let wif_result = private_key.fmt_wif(&mut wif); @@ -561,7 +562,7 @@ pub fn parse_invitation_uri(uri: &str) -> Result SecretKey { - SecretKey::from_secret_bytes([0x11u8; 32]).expect("valid scalar") + SecretKey::from_bytes(&[0x11u8; 32]).expect("valid scalar") } fn inviter_info() -> InviterInfo { @@ -1330,7 +1331,7 @@ mod tests { /// Build an asset-lock tx whose credit output at `index` pays the voucher /// key (and `index` decoy outputs before it that do not). fn asset_lock_tx_paying_voucher_at(key: &SecretKey, index: usize) -> Transaction { - let decoy = SecretKey::from_secret_bytes([0x22u8; 32]).unwrap(); + let decoy = SecretKey::from_bytes(&[0x22u8; 32]).unwrap(); let mut credit_outputs = Vec::new(); for _ in 0..index { credit_outputs.push(TxOut { @@ -1364,13 +1365,13 @@ mod tests { #[test] fn should_round_trip_a_wif_keeping_compression_and_network() { for (network, first_byte) in [(Network::Mainnet, 204u8), (Network::Testnet, 239u8)] { - let wif = PrivateKey::from_byte_array(&voucher().to_secret_bytes(), network) + let wif = PrivateKey::from_byte_array(&voucher().to_bytes(), network) .expect("valid voucher") .to_wif(); let decoded = PrivateKey::from_wif(&wif).expect("wif decodes"); assert!(decoded.compressed, "voucher WIF must be compressed"); assert_eq!(decoded.network, network, "network preserved"); - assert_eq!(*decoded.inner.to_bytes(), voucher().to_secret_bytes()); + assert_eq!(decoded.inner.to_bytes(), voucher().to_bytes()); // Network byte matches bitcoinj/legacy (0xCC mainnet, 0xEF testnet). let raw = dpp::dashcore::base58::decode(&wif).unwrap(); assert_eq!(raw[0], first_byte); @@ -1386,10 +1387,7 @@ mod tests { assert!(uri.starts_with("dashpay://invite?")); let parsed = parse_invitation_uri(&uri).expect("parse"); - assert_eq!( - parsed.voucher_key.to_secret_bytes(), - voucher().to_secret_bytes() - ); + assert_eq!(parsed.voucher_key.to_bytes(), voucher().to_bytes()); assert_eq!(parsed.inviter, Some(info)); assert!(parsed.islock_hex.is_some()); // The parsed txid matches the proof's transaction id (big-endian). @@ -1414,7 +1412,7 @@ mod tests { /// byte-level, interop — the two legacy wallets differ in order). #[test] fn should_parse_a_link_regardless_of_field_order() { - let wif = PrivateKey::from_byte_array(&voucher().to_secret_bytes(), Network::Testnet) + let wif = PrivateKey::from_byte_array(&voucher().to_bytes(), Network::Testnet) .expect("valid voucher") .to_wif(); let uri = format!("dashpay://invite?islock=deadbeef&pk={wif}&du=bob&assetlocktx=aabbcc"); @@ -1431,7 +1429,7 @@ mod tests { /// first-class alternative to the custom scheme (iOS emits it). #[test] fn should_parse_a_link_on_the_applink_host() { - let wif = PrivateKey::from_byte_array(&voucher().to_secret_bytes(), Network::Testnet) + let wif = PrivateKey::from_byte_array(&voucher().to_bytes(), Network::Testnet) .expect("valid voucher") .to_wif(); let uri = format!( @@ -1449,7 +1447,7 @@ mod tests { /// accepted over cleartext `http`. Neither mobile wallet emits an `http` link. #[test] fn should_reject_an_applink_over_plain_http() { - let wif = PrivateKey::from_byte_array(&voucher().to_secret_bytes(), Network::Testnet) + let wif = PrivateKey::from_byte_array(&voucher().to_bytes(), Network::Testnet) .expect("valid voucher") .to_wif(); let uri = @@ -1465,7 +1463,7 @@ mod tests { /// (a ChainLock-confirmed invite Android's own validator accepts). #[test] fn should_parse_an_islock_that_is_present_absent_or_null() { - let wif = PrivateKey::from_byte_array(&voucher().to_secret_bytes(), Network::Testnet) + let wif = PrivateKey::from_byte_array(&voucher().to_bytes(), Network::Testnet) .expect("valid voucher") .to_wif(); let present = format!("dashpay://invite?assetlocktx=aa&pk={wif}&islock=00aa11"); @@ -1490,7 +1488,7 @@ mod tests { /// A `du`-less link still parses (iOS accepts du-less links). #[test] fn should_parse_a_link_without_a_du_field() { - let wif = PrivateKey::from_byte_array(&voucher().to_secret_bytes(), Network::Testnet) + let wif = PrivateKey::from_byte_array(&voucher().to_bytes(), Network::Testnet) .expect("valid voucher") .to_wif(); let uri = format!("dashpay://invite?assetlocktx=aa&pk={wif}&islock=bb"); @@ -1500,7 +1498,7 @@ mod tests { #[test] fn should_reject_a_link_missing_pk_or_assetlocktx() { - let wif = PrivateKey::from_byte_array(&voucher().to_secret_bytes(), Network::Testnet) + let wif = PrivateKey::from_byte_array(&voucher().to_bytes(), Network::Testnet) .expect("valid voucher") .to_wif(); // No pk. @@ -1519,9 +1517,8 @@ mod tests { #[test] fn should_reject_an_uncompressed_wif() { - let mut private_key = - PrivateKey::from_byte_array(&voucher().to_secret_bytes(), Network::Testnet) - .expect("valid voucher"); + let mut private_key = PrivateKey::from_byte_array(&voucher().to_bytes(), Network::Testnet) + .expect("valid voucher"); private_key.compressed = false; let uncompressed = private_key.to_wif(); let uri = format!("dashpay://invite?assetlocktx=aa&pk={uncompressed}"); @@ -1546,7 +1543,7 @@ mod tests { /// display-name + avatar-url) parses to the right fields. #[test] fn should_parse_an_android_style_link() { - let wif = PrivateKey::from_byte_array(&voucher().to_secret_bytes(), Network::Mainnet) + let wif = PrivateKey::from_byte_array(&voucher().to_bytes(), Network::Mainnet) .expect("valid voucher") .to_wif(); // Android order: du, assetlocktx, pk, islock, display-name, avatar-url. @@ -1594,7 +1591,7 @@ mod tests { #[test] fn should_reject_a_funding_tx_with_no_output_paying_the_voucher() { let key = voucher(); - let other = SecretKey::from_secret_bytes([0x33u8; 32]).unwrap(); + let other = SecretKey::from_bytes(&[0x33u8; 32]).unwrap(); let tx = asset_lock_tx_paying_voucher_at(&other, 0); let err = voucher_output_index(&tx, &key).unwrap_err(); assert!(err.to_string().contains("does not control")); @@ -1617,7 +1614,7 @@ mod tests { /// surface them (the reference wallets emit those independently of `du`). #[test] fn should_keep_inviter_metadata_when_the_du_field_is_missing() { - let wif = PrivateKey::from_byte_array(&voucher().to_secret_bytes(), Network::Testnet) + let wif = PrivateKey::from_byte_array(&voucher().to_bytes(), Network::Testnet) .expect("valid voucher") .to_wif(); let uri = format!( @@ -1634,7 +1631,7 @@ mod tests { /// first) — reject rather than claim a wallet-dependent key. #[test] fn should_reject_a_link_with_duplicate_required_keys() { - let wif = PrivateKey::from_byte_array(&voucher().to_secret_bytes(), Network::Testnet) + let wif = PrivateKey::from_byte_array(&voucher().to_bytes(), Network::Testnet) .expect("valid voucher") .to_wif(); let other = PrivateKey::from_byte_array(&[0x44u8; 32], Network::Testnet) @@ -1659,7 +1656,7 @@ mod tests { /// (with a `pk`/`assetlocktx`) would be parsed. #[test] fn should_reject_a_link_with_a_decoy_scheme_or_host() { - let wif = PrivateKey::from_byte_array(&voucher().to_secret_bytes(), Network::Testnet) + let wif = PrivateKey::from_byte_array(&voucher().to_bytes(), Network::Testnet) .expect("valid voucher") .to_wif(); // Suffixed authority — not exactly `invite`. @@ -1810,7 +1807,7 @@ mod tests { #[test] fn should_derive_the_prospective_id_from_the_selected_credit_output() { let key = voucher(); - let decoy = SecretKey::from_secret_bytes([0x22u8; 32]).unwrap(); + let decoy = SecretKey::from_bytes(&[0x22u8; 32]).unwrap(); let payload = AssetLockPayload { version: 1, credit_outputs: vec![ diff --git a/packages/rs-sdk/src/platform/dashpay/profile.rs b/packages/rs-sdk/src/platform/dashpay/profile.rs index e0469af7f03..dcf8511853b 100644 --- a/packages/rs-sdk/src/platform/dashpay/profile.rs +++ b/packages/rs-sdk/src/platform/dashpay/profile.rs @@ -13,6 +13,8 @@ use crate::platform::transition::waitable::wait_for_document_and_owner_balance_w use crate::platform::FetchMany; use crate::{Error, Sdk}; use dapi_grpc::platform::v0::ResponseMetadata; +use dpp::dashcore::key::rand::rngs::StdRng; +use dpp::dashcore::key::rand::{Rng, SeedableRng}; use dpp::data_contract::accessors::v0::DataContractV0Getters; use dpp::data_contract::document_type::methods::DocumentTypeV0Methods; use dpp::data_contract::DataContract; @@ -22,8 +24,6 @@ use dpp::identity::signer::Signer; use dpp::identity::IdentityPublicKey; use dpp::platform_value::{platform_value, Value}; use dpp::prelude::Identifier; -use dpp::secp256k1::rand::rngs::StdRng; -use dpp::secp256k1::rand::{Rng, SeedableRng}; use dpp::state_transition::StateTransition; use drive::query::{OrderClause, WhereClause, WhereOperator}; use std::collections::{BTreeMap, BTreeSet}; diff --git a/packages/rs-sdk/src/platform/dpns_usernames/mod.rs b/packages/rs-sdk/src/platform/dpns_usernames/mod.rs index d4677138e99..2bc053b6047 100644 --- a/packages/rs-sdk/src/platform/dpns_usernames/mod.rs +++ b/packages/rs-sdk/src/platform/dpns_usernames/mod.rs @@ -15,6 +15,8 @@ use crate::platform::{DataContract, Document, Fetch, FetchMany}; use crate::{Error, Sdk}; use dapi_grpc::platform::v0::ResponseMetadata; use dash_context_provider::ContextProvider; +use dpp::dashcore::key::rand::rngs::StdRng; +use dpp::dashcore::key::rand::{Rng, SeedableRng}; use dpp::data_contract::accessors::v0::DataContractV0Getters; use dpp::data_contract::document_type::accessors::DocumentTypeV2Getters; use dpp::data_contract::document_type::{DocumentType, DocumentTypeRef, LookupHashKey}; @@ -25,8 +27,6 @@ use dpp::identity::signer::Signer; use dpp::identity::{Identity, IdentityPublicKey}; use dpp::platform_value::Value; use dpp::prelude::Identifier; -use dpp::secp256k1::rand::rngs::StdRng; -use dpp::secp256k1::rand::{Rng, SeedableRng}; use dpp::state_transition::batch_transition::methods::StateTransitionCreationOptions; use drive::query::{SelectProjection, WhereClause, WhereOperator}; use std::collections::BTreeMap; diff --git a/packages/rs-sdk/src/platform/encrypted_for.rs b/packages/rs-sdk/src/platform/encrypted_for.rs index c7c37818512..74118019e3b 100644 --- a/packages/rs-sdk/src/platform/encrypted_for.rs +++ b/packages/rs-sdk/src/platform/encrypted_for.rs @@ -26,6 +26,8 @@ //! which a wrong key passes about once in 256 attempts and then returns garbage; a caller that //! must tell the two apart has to recognise its plaintext. +use dpp::dashcore::key::rand::rngs::StdRng; +use dpp::dashcore::key::rand::{RngCore, SeedableRng}; use dpp::data_contract::document_type::accessors::DocumentTypeV0Getters; use dpp::data_contract::document_type::{ DocumentPropertyReferenceTarget, DocumentPropertyType, DocumentTypeRef, EncryptedFor, @@ -40,10 +42,8 @@ use dpp::platform_value::btreemap_extensions::{ BTreeValueMapInsertionPathHelper, BTreeValueMapPathHelper, }; use dpp::platform_value::{Identifier, Value}; -use dpp::secp256k1::rand::rngs::StdRng; -use dpp::secp256k1::rand::{RngCore, SeedableRng}; -use dpp::secp256k1::{PublicKey, SecretKey}; use platform_encryption::{decrypt_aes_256_cbc, derive_shared_key_ecdh, encrypt_aes_256_cbc}; +use secp256k1::{PublicKey, SecretKey}; use std::collections::BTreeMap; use std::fmt; diff --git a/packages/rs-sdk/src/platform/moderation_charters/requests.rs b/packages/rs-sdk/src/platform/moderation_charters/requests.rs index bdb5087de94..a7196c7d90a 100644 --- a/packages/rs-sdk/src/platform/moderation_charters/requests.rs +++ b/packages/rs-sdk/src/platform/moderation_charters/requests.rs @@ -3,6 +3,8 @@ use crate::platform::encrypted_for::encrypt_property_for; use crate::platform::{DataContract, Document, Fetch, Identity}; use crate::{Error, Sdk}; +use dpp::dashcore::key::rand::rngs::StdRng; +use dpp::dashcore::key::rand::{Rng, SeedableRng}; use dpp::data_contract::accessors::v0::DataContractV0Getters; use dpp::data_contract::document_type::methods::DocumentTypeBasicMethods; use dpp::document::{DocumentV0, DocumentV0Getters, INITIAL_REVISION}; @@ -12,9 +14,7 @@ use dpp::moderation_charter::{ RESIGNATION_REQUEST_DOCUMENT_TYPE_NAME, SUBMITTED_CHARTER_DOCUMENT_TYPE_NAME, }; use dpp::platform_value::{Bytes32, Identifier, Value}; -use dpp::secp256k1::rand::rngs::StdRng; -use dpp::secp256k1::rand::{Rng, SeedableRng}; -use dpp::secp256k1::SecretKey; +use secp256k1::SecretKey; use std::collections::BTreeMap; /// The property of both request types that carries the message, declared `encryptedFor` the @@ -255,9 +255,9 @@ mod tests { use dpp::identity::{IdentityPublicKey, KeyType, Purpose, SecurityLevel}; use dpp::moderation_charter::MODERATION_CHARTERS_CONTRACT_ID; use dpp::platform_value::BinaryData; - use dpp::secp256k1::PublicKey; use dpp::system_data_contracts::{load_system_data_contract, SystemDataContract}; use dpp::version::PlatformVersion; + use secp256k1::PublicKey; fn key_pair(scalar: u8) -> (SecretKey, PublicKey) { let secret_key = SecretKey::from_secret_bytes([scalar; 32]).expect("a valid scalar"); diff --git a/packages/rs-sdk/src/platform/transition/put_document.rs b/packages/rs-sdk/src/platform/transition/put_document.rs index 6b35a67ee32..e5763c02923 100644 --- a/packages/rs-sdk/src/platform/transition/put_document.rs +++ b/packages/rs-sdk/src/platform/transition/put_document.rs @@ -8,6 +8,8 @@ use crate::platform::documents::contest_fund::with_contest_fund_to_join; use crate::platform::transition::put_settings::PutSettings; use crate::{Error, Sdk}; use dapi_grpc::platform::v0::ResponseMetadata; +use dpp::dashcore::key::rand::rngs::StdRng; +use dpp::dashcore::key::rand::{Rng, SeedableRng}; use dpp::data_contract::document_type::accessors::{DocumentTypeV0Getters, DocumentTypeV2Getters}; use dpp::data_contract::document_type::methods::DocumentTypeV0Methods; use dpp::data_contract::document_type::DocumentType; @@ -16,8 +18,6 @@ use dpp::fee::Credits; use dpp::identity::signer::Signer; use dpp::identity::IdentityPublicKey; use dpp::prelude::Identifier; -use dpp::secp256k1::rand::rngs::StdRng; -use dpp::secp256k1::rand::{Rng, SeedableRng}; use dpp::state_transition::batch_transition::methods::v0::DocumentsBatchTransitionMethodsV0; use dpp::state_transition::batch_transition::BatchTransition; use dpp::state_transition::StateTransition; diff --git a/packages/simple-signer/Cargo.toml b/packages/simple-signer/Cargo.toml index d09a1910d2a..0eeebca6cfe 100644 --- a/packages/simple-signer/Cargo.toml +++ b/packages/simple-signer/Cargo.toml @@ -24,10 +24,14 @@ bincode = { workspace = true, features = ["serde"] } base64 = { version = "0.22.1" } hex = { version = "0.4.3" } # rand 0.8 `RngCore`, the RNG type strategy-tests/drive-abci pass in; the -# secp256k1 re-export is rand 0.9. +# Core key RNG re-export is rand 0.9. rand = { version = "0.8", default-features = false } tracing = "0.1.41" zeroize = "1" [package.metadata.cargo-machete] ignored = ["bincode"] + +[dev-dependencies] +secp256k1 = { workspace = true } +rand = { version = "0.8", features = ["std_rng"] } diff --git a/packages/simple-signer/src/signer.rs b/packages/simple-signer/src/signer.rs index 3a10d345941..f25f0a46d46 100644 --- a/packages/simple-signer/src/signer.rs +++ b/packages/simple-signer/src/signer.rs @@ -5,14 +5,14 @@ use dpp::address_funds::{AddressWitness, PlatformAddress}; use dpp::bincode::{Decode, Encode}; use dpp::bls; +use dpp::dashcore::crypto::ecdsa::EcdsaSecretKey; +use dpp::dashcore::key::rand::{RngCore as EcdsaRngCore, SeedableRng}; use dpp::dashcore::signer; use dpp::ed25519_dalek::Signer as BlsSigner; use dpp::identity::identity_public_key::accessors::v0::IdentityPublicKeyGettersV0; use dpp::identity::signer::Signer; use dpp::identity::{IdentityPublicKey, KeyType}; use dpp::platform_value::BinaryData; -use dpp::secp256k1::rand::SeedableRng; -use dpp::secp256k1::{PublicKey, SecretKey}; use dpp::state_transition::errors::InvalidIdentityPublicKeyTypeError; use dpp::util::hash::ripemd160_sha256; use dpp::{ed25519_dalek, ProtocolError}; @@ -100,19 +100,25 @@ impl SimpleSigner { // Generate a valid secp256k1 secret key from random bytes let mut seed = [0u8; 32]; rng.fill_bytes(&mut seed); - let mut ecdsa_rng = dpp::secp256k1::rand::rngs::StdRng::from_seed(seed); - let secret_key = SecretKey::new(&mut ecdsa_rng); + let mut ecdsa_rng = dpp::dashcore::key::rand::rngs::StdRng::from_seed(seed); + let secret_key = loop { + let mut bytes = [0; 32]; + EcdsaRngCore::fill_bytes(&mut ecdsa_rng, &mut bytes); + if let Ok(key) = EcdsaSecretKey::from_bytes(&bytes) { + break key; + } + }; // Derive compressed public key - let public_key = PublicKey::from_secret_key(&secret_key); - let pubkey_ser = public_key.serialize(); // 33-byte compressed + let public_key = secret_key.public_key(); + let pubkey_ser = public_key.to_compressed(); // 33-byte compressed let address_hash = ripemd160_sha256(&pubkey_ser); // Store private key so this signer can later sign for this address // (use *_in_creation to mirror your identity key behavior) self.address_private_keys_in_creation - .insert(address_hash, secret_key.to_secret_bytes()); + .insert(address_hash, *secret_key.to_bytes()); PlatformAddress::P2pkh(address_hash) } @@ -260,3 +266,33 @@ impl Signer for SimpleSigner { } } } + +#[cfg(test)] +mod tests { + use super::*; + use rand::{rngs::StdRng, SeedableRng}; + use secp256k1::rand::{rngs::StdRng as LegacyRng, SeedableRng as _}; + + #[test] + fn should_preserve_seeded_address_key_generation() { + for seed in 0..64 { + let mut rng = StdRng::seed_from_u64(seed); + let mut expected_rng = rng.clone(); + let mut seed = [0; 32]; + expected_rng.fill_bytes(&mut seed); + let expected_key = secp256k1::SecretKey::new(&mut LegacyRng::from_seed(seed)); + let expected_public = secp256k1::PublicKey::from_secret_key(&expected_key).serialize(); + let expected_hash = ripemd160_sha256(&expected_public); + let mut signer = SimpleSigner::default(); + assert_eq!( + signer.add_random_address_key(&mut rng), + PlatformAddress::P2pkh(expected_hash) + ); + assert_eq!( + signer.address_private_keys_in_creation[&expected_hash], + expected_key.to_secret_bytes() + ); + assert_eq!(rng.next_u64(), expected_rng.next_u64()); + } + } +} diff --git a/packages/strategy-tests/src/transitions.rs b/packages/strategy-tests/src/transitions.rs index 751b4f28b89..f16c2af2a83 100644 --- a/packages/strategy-tests/src/transitions.rs +++ b/packages/strategy-tests/src/transitions.rs @@ -32,6 +32,7 @@ //! each action. use dpp::address_funds::PlatformAddress; +use dpp::dashcore::crypto::ecdsa::EcdsaSecretKey as SecretKey; use dpp::dashcore::{ bls_sig_utils::BLSSignature, hash_types::CycleHash, InstantLock, OutPoint, ScriptBuf, Transaction, TxIn, TxOut, Txid, @@ -49,7 +50,6 @@ use dpp::identity::Purpose::{AUTHENTICATION, TRANSFER}; use dpp::identity::SecurityLevel::{CRITICAL, MASTER}; use dpp::identity::{Identity, IdentityPublicKey, KeyID, KeyType, Purpose, SecurityLevel}; use dpp::prelude::AssetLockProof; -use dpp::secp256k1::SecretKey; use dpp::state_transition::identity_create_transition::methods::IdentityCreateTransitionMethodsV0; use dpp::state_transition::identity_create_transition::IdentityCreateTransition; use dpp::state_transition::identity_credit_transfer_transition::v0::IdentityCreditTransferTransitionV0; @@ -1212,9 +1212,9 @@ where let (_, pk) = ECDSA_SECP256K1 .random_public_and_private_key_data(rng, platform_version) .unwrap(); - let secret_key = SecretKey::from_str(hex::encode(pk).as_str()).unwrap(); + let secret_key = SecretKey::from_bytes(&pk).unwrap(); let asset_lock_proof = instant_asset_lock_proof_fixture_with_dynamic_range( - PrivateKey::from_byte_array(secret_key.as_secret_bytes(), Network::Mainnet) + PrivateKey::from_byte_array(&secret_key.to_bytes(), Network::Mainnet) .expect("valid test secret key"), amount_range, rng, diff --git a/packages/wasm-dpp2/src/public_key.rs b/packages/wasm-dpp2/src/public_key.rs index 52a1a421cc6..fcc8135b337 100644 --- a/packages/wasm-dpp2/src/public_key.rs +++ b/packages/wasm-dpp2/src/public_key.rs @@ -1,8 +1,8 @@ use crate::error::{WasmDppError, WasmDppResult}; use crate::impl_wasm_type_info; use dpp::dashcore::PublicKey; +use dpp::dashcore::ecdsa::EcdsaPublicKey; use dpp::dashcore::key::constants; -use dpp::secp256k1; use std::convert::TryInto; use wasm_bindgen::prelude::wasm_bindgen; @@ -40,7 +40,7 @@ impl PublicKeyWasm { public_key_bytes.try_into().map_err(|_| { WasmDppError::invalid_argument("compressed public key must contain 33 bytes") })?; - secp256k1::PublicKey::from_byte_array_compressed(bytes) + EcdsaPublicKey::from_bytes(&bytes) } else { if public_key_bytes.len() != constants::UNCOMPRESSED_PUBLIC_KEY_SIZE { return Err(WasmDppError::invalid_argument(format!( @@ -54,14 +54,11 @@ impl PublicKeyWasm { WasmDppError::invalid_argument("uncompressed public key must contain 65 bytes") })?; - secp256k1::PublicKey::from_byte_array_uncompressed(bytes) + EcdsaPublicKey::from_bytes(&bytes) } .map_err(|err| WasmDppError::invalid_argument(err.to_string()))?; - Ok(PublicKeyWasm(PublicKey { - compressed, - inner: inner.into(), - })) + Ok(PublicKeyWasm(PublicKey { compressed, inner })) } #[wasm_bindgen(getter = "compressed")] @@ -91,9 +88,8 @@ impl PublicKeyWasm { })?; self.0.compressed = true; - self.0.inner = secp256k1::PublicKey::from_byte_array_compressed(bytes) - .map_err(|err| WasmDppError::invalid_argument(err.to_string()))? - .into(); + self.0.inner = EcdsaPublicKey::from_bytes(&bytes) + .map_err(|err| WasmDppError::invalid_argument(err.to_string()))?; } else { if inner.len() != constants::UNCOMPRESSED_PUBLIC_KEY_SIZE { return Err(WasmDppError::invalid_argument(format!( @@ -108,9 +104,8 @@ impl PublicKeyWasm { })?; self.0.compressed = false; - self.0.inner = secp256k1::PublicKey::from_byte_array_uncompressed(bytes) - .map_err(|err| WasmDppError::invalid_argument(err.to_string()))? - .into(); + self.0.inner = EcdsaPublicKey::from_bytes(&bytes) + .map_err(|err| WasmDppError::invalid_argument(err.to_string()))?; } Ok(()) @@ -136,3 +131,34 @@ impl PublicKeyWasm { } impl_wasm_type_info!(PublicKeyWasm, PublicKey); + +#[cfg(test)] +mod tests { + use super::*; + use dpp::dashcore::ecdsa::EcdsaSecretKey; + + #[test] + fn should_preserve_public_key_parser_encoding_contracts() { + let key = EcdsaSecretKey::from_bytes(&[1; 32]) + .expect("valid scalar") + .public_key(); + let compressed = key.to_compressed(); + let uncompressed = key.to_uncompressed(); + let mut hybrid = uncompressed; + hybrid[0] = 6 | (hybrid[64] & 1); + + let parsed = PublicKeyWasm::constructor(true, compressed.to_vec()).expect("compressed key"); + assert_eq!(parsed.inner(), compressed); + assert!(PublicKeyWasm::constructor(true, uncompressed.to_vec()).is_err()); + for bytes in [uncompressed, hybrid] { + let mut parsed = PublicKeyWasm::constructor(false, bytes.to_vec()).expect("SEC1 key"); + assert_eq!(parsed.inner(), uncompressed); + parsed.set_inner(bytes.to_vec()).expect("SEC1 setter"); + assert_eq!(parsed.inner(), uncompressed); + } + // The Core wire parser is stricter than the raw SEC1 constructor/setter. + assert!(PublicKeyWasm::from_bytes(hybrid.to_vec()).is_err()); + hybrid[0] ^= 1; + assert!(PublicKeyWasm::constructor(false, hybrid.to_vec()).is_err()); + } +} diff --git a/packages/wasm-sdk/Cargo.toml b/packages/wasm-sdk/Cargo.toml index 153fe020896..9d0e65a5aa7 100644 --- a/packages/wasm-sdk/Cargo.toml +++ b/packages/wasm-sdk/Cargo.toml @@ -60,6 +60,8 @@ moderation-charters-contract = [ token_reward_explanations = ["dash-sdk/token_reward_explanations"] [dependencies] +# Core does not expose the ECDH primitives used at this binding boundary. +secp256k1 = { workspace = true } dash-sdk = { path = "../rs-sdk", features = [ "serde", "core_key_wallet", diff --git a/packages/wasm-sdk/src/encrypted_for.rs b/packages/wasm-sdk/src/encrypted_for.rs index b4a8f5330a2..fe93e626d26 100644 --- a/packages/wasm-sdk/src/encrypted_for.rs +++ b/packages/wasm-sdk/src/encrypted_for.rs @@ -13,11 +13,11 @@ use dash_sdk::dpp::document::DocumentV0Getters; use dash_sdk::dpp::identity::identity_public_key::accessors::v0::IdentityPublicKeyGettersV0; use dash_sdk::dpp::identity::{IdentityPublicKey, KeyType}; use dash_sdk::dpp::platform_value::Value; -use dash_sdk::dpp::secp256k1::{PublicKey, SecretKey}; use dash_sdk::platform::encrypted_for::{ decrypt_property, encrypt_property, EncryptedPropertyEnvelope, EncryptionKeys, }; use dash_sdk::platform::{Document, Identifier}; +use secp256k1::{PublicKey, SecretKey}; use std::collections::BTreeMap; use wasm_bindgen::prelude::wasm_bindgen; use wasm_bindgen::JsValue; diff --git a/packages/wasm-sdk/src/state_transitions/contract/cache_tests.rs b/packages/wasm-sdk/src/state_transitions/contract/cache_tests.rs index 7fc146e8d00..333b3cf91da 100644 --- a/packages/wasm-sdk/src/state_transitions/contract/cache_tests.rs +++ b/packages/wasm-sdk/src/state_transitions/contract/cache_tests.rs @@ -9,6 +9,7 @@ use dapi_grpc::platform::v0::{ WaitForStateTransitionResultResponse, }; use dash_sdk::dpp::address_funds::AddressWitness; +use dash_sdk::dpp::dashcore::ecdsa::EcdsaSecretKey; use dash_sdk::dpp::dashcore::{signer, Network}; use dash_sdk::dpp::data_contract::accessors::v0::DataContractV0Setters; use dash_sdk::dpp::data_contract::conversion::value::v0::DataContractValueConversionMethodsV0; @@ -17,7 +18,6 @@ use dash_sdk::dpp::document::{DocumentV0, DocumentV0Setters}; use dash_sdk::dpp::identity::identity_public_key::v0::IdentityPublicKeyV0; use dash_sdk::dpp::identity::{KeyType, PartialIdentity, Purpose, SecurityLevel}; use dash_sdk::dpp::platform_value::{platform_value, BinaryData, Value}; -use dash_sdk::dpp::secp256k1; use dash_sdk::dpp::state_transition::batch_transition::methods::v0::DocumentsBatchTransitionMethodsV0; use dash_sdk::dpp::state_transition::batch_transition::BatchTransition; use dash_sdk::dpp::state_transition::StateTransition; @@ -147,12 +147,12 @@ fn identity_key_with_seed(seed: u8) -> IdentityPublicKey { purpose: Purpose::AUTHENTICATION, security_level: SecurityLevel::CRITICAL, key_type: KeyType::ECDSA_SECP256K1, - data: secp256k1::PublicKey::from_secret_key( - &secp256k1::SecretKey::from_secret_bytes([seed; 32]).expect("identity secret"), - ) - .serialize() - .to_vec() - .into(), + data: EcdsaSecretKey::from_bytes(&[seed; 32]) + .expect("identity secret") + .public_key() + .to_compressed() + .to_vec() + .into(), ..Default::default() }) } diff --git a/packages/wasm-sdk/src/wallet/dip14.rs b/packages/wasm-sdk/src/wallet/dip14.rs index d898e7c2acb..db0b250ba24 100644 --- a/packages/wasm-sdk/src/wallet/dip14.rs +++ b/packages/wasm-sdk/src/wallet/dip14.rs @@ -8,7 +8,6 @@ use dash_sdk::dpp::dashcore::hashes::{sha256, Hash}; use dash_sdk::dpp::dashcore::Network; use dash_sdk::dpp::key_wallet; use dash_sdk::dpp::key_wallet::bip32::{ExtendedPrivKey, ExtendedPubKey}; -use dash_sdk::dpp::secp256k1::{self, Scalar, SecretKey}; use hmac::{Hmac, Mac}; use sha2::Sha512; use std::convert::TryInto; @@ -120,31 +119,15 @@ impl Dip14ExtendedPrivKey { // Perform scalar addition: child_key = IL + parent_key (mod n) // This is the core of BIP32/DIP14 child key derivation - // First, try to create a secret key from IL - let il_scalar = match <[u8; 32]>::try_from(il_bytes) - .map_err(|_| secp256k1::Error::InvalidSecretKey) - .and_then(SecretKey::from_secret_bytes) - { - Ok(key) => key, - Err(_) => { - return Err(Dip14Error::DerivationFailed( - "Invalid IL bytes (IL >= n)".to_string(), - )) - } - }; - - // Add parent key to IL - // In secp256k1, we perform scalar addition: child_key = parent_key + IL (mod n) - // Convert IL to a Scalar for the tweak operation - let il_scalar_bytes = il_scalar.to_secret_bytes(); - let tweak = Scalar::from_be_bytes(il_scalar_bytes).map_err(|_| { - Dip14Error::DerivationFailed("Failed to convert IL to scalar".to_string()) - })?; + let il_bytes: &[u8; 32] = il_bytes.try_into().map_err(|_| Dip14Error::InvalidKey)?; + // Retain rejection of a zero IL as well as out-of-range scalars. + let il_scalar = EcdsaSecretKey::from_bytes(il_bytes) + .map_err(|_| Dip14Error::DerivationFailed("Invalid IL bytes (IL >= n)".to_string()))?; // Perform scalar addition: child_key = parent_key + IL (mod n) let child_key = self .private_key - .add_tweak(&tweak.to_be_bytes()) + .add_tweak(&il_scalar.to_bytes()) .map_err(|e| Dip14Error::DerivationFailed(format!("Failed to add tweak: {}", e)))?; // Calculate parent fingerprint (first 4 bytes of parent pubkey hash160) diff --git a/packages/wasm-sdk/src/wallet/key_generation.rs b/packages/wasm-sdk/src/wallet/key_generation.rs index 82a366c81ca..fc275d6fb00 100644 --- a/packages/wasm-sdk/src/wallet/key_generation.rs +++ b/packages/wasm-sdk/src/wallet/key_generation.rs @@ -7,7 +7,6 @@ use crate::impl_wasm_serde_conversions; use crate::sdk::WasmSdk; use dash_sdk::dpp::dashcore::hashes::{sha256, Hash}; use dash_sdk::dpp::dashcore::{Address, Network, PrivateKey, PublicKey}; -use dash_sdk::dpp::secp256k1::SecretKey; use serde::{Deserialize, Serialize}; use std::str::FromStr; use wasm_bindgen::prelude::*; @@ -94,10 +93,6 @@ impl WasmSdk { let private_key = PrivateKey::from_byte_array(&key_bytes, net) .map_err(|e| WasmSdkError::generic(format!("Failed to create private key: {}", e)))?; - // Ensure secret key is valid before building info - SecretKey::from_secret_bytes(key_bytes) - .map_err(|e| WasmSdkError::invalid_argument(format!("Invalid secret key: {}", e)))?; - let key_pair = Self::build_key_pair(&private_key, net, network_wasm.as_str())?; Ok(KeyPairWasm::from(key_pair)) } @@ -219,14 +214,14 @@ impl WasmSdk { let message_bytes = message.as_bytes(); let hash = sha256::Hash::hash(message_bytes); - // Sign the hash - let secret_key = SecretKey::from_secret_bytes(*private_key.inner.to_bytes()) - .map_err(|e| WasmSdkError::invalid_argument(format!("Invalid secret key: {}", e)))?; - - let message_hash = dash_sdk::dpp::secp256k1::Message::from_digest(hash.to_byte_array()); - let signature = secret_key.sign_ecdsa(message_hash); + // Preserve deterministic, non-grinding compact signature bytes. + let signature = private_key + .inner + .sign_recoverable(&hash.to_byte_array()) + .signature() + .map_err(|e| WasmSdkError::generic(format!("Failed to encode signature: {}", e)))?; - Ok(hex::encode(signature.serialize_compact())) + Ok(hex::encode(signature.to_bytes())) } /// Generate deterministic test identity keys for SDK functional tests. @@ -294,3 +289,31 @@ impl WasmSdk { Ok(to_object(&result)?) } } + +#[cfg(test)] +mod tests { + use super::*; + use secp256k1::{Message, SecretKey}; + + #[test] + fn should_preserve_message_signature_bytes_for_both_wif_encodings() { + let scalar = [1; 32]; + let raw = SecretKey::from_secret_bytes(scalar).expect("valid scalar"); + let mut private_key = + PrivateKey::from_byte_array(&scalar, Network::Testnet).expect("valid scalar"); + for compressed in [true, false] { + private_key.compressed = compressed; + for i in 0..32 { + let message = format!("message {i}"); + let digest = sha256::Hash::hash(message.as_bytes()).to_byte_array(); + let expected = raw + .sign_ecdsa(Message::from_digest(digest)) + .serialize_compact(); + assert_eq!( + WasmSdk::sign_message(&message, &private_key.to_wif()).expect("signature"), + hex::encode(expected) + ); + } + } + } +}