ckb_crypto/secp/
privkey.rs

1use super::error::Error;
2use super::signature::Signature;
3use super::{Message, Pubkey, SECP256K1};
4use ckb_fixed_hash::H256;
5use secp256k1::Message as SecpMessage;
6use secp256k1::{PublicKey, SecretKey};
7use std::str::FromStr;
8use std::{ptr, sync::atomic};
9
10/// Wrapped private 256-bit key used as x in an ECDSA signature
11#[derive(Clone, Eq, PartialEq)]
12pub struct Privkey {
13    /// ECDSA key.
14    inner: H256,
15}
16
17impl Privkey {
18    /// Constructs a signature for message using the Privkey and RFC6979 nonce Requires a signing-capable context.
19    pub fn sign_recoverable(&self, message: &Message) -> Result<Signature, Error> {
20        let context = &SECP256K1;
21        let message = message.as_ref();
22        let privkey = SecretKey::from_slice(self.inner.as_bytes())?;
23        let message = SecpMessage::from_digest_slice(message)?;
24        let data = context.sign_ecdsa_recoverable(&message, &privkey);
25        let (rec_id, data) = data.serialize_compact();
26        Ok(Signature::from_compact(rec_id, data))
27    }
28
29    /// Creates a new Pubkey from a Privkey.
30    pub fn pubkey(&self) -> Result<Pubkey, Error> {
31        let context = &SECP256K1;
32        let privkey = SecretKey::from_slice(self.inner.as_bytes())?;
33        let pubkey = PublicKey::from_secret_key(context, &privkey);
34        Ok(Pubkey::from(pubkey))
35    }
36
37    /// Creates a new Privkey from a slice
38    ///
39    /// # Panics
40    ///
41    /// This function will panic if the key slice length is not equal 32 .
42    pub fn from_slice(key: &[u8]) -> Self {
43        assert_eq!(32, key.len(), "should provide 32-byte length slice");
44
45        let mut h = [0u8; 32];
46        h.copy_from_slice(&key[0..32]);
47        Privkey { inner: h.into() }
48    }
49
50    // uses core::ptr::write_volatile and core::sync::atomic memory fences to zeroing
51    pub(crate) fn zeroize(&mut self) {
52        for elem in self.inner.0.iter_mut() {
53            volatile_write(elem, Default::default());
54            atomic_fence();
55        }
56    }
57}
58
59impl From<H256> for Privkey {
60    fn from(key: H256) -> Self {
61        Privkey { inner: key }
62    }
63}
64
65impl FromStr for Privkey {
66    type Err = Error;
67
68    fn from_str(s: &str) -> Result<Self, Self::Err> {
69        Ok(H256::from_str(s)
70            .map_err(|e| Error::Other(format!("{e:?}")))?
71            .into())
72    }
73}
74
75impl From<SecretKey> for Privkey {
76    fn from(key: SecretKey) -> Self {
77        let mut h = [0u8; 32];
78        h.copy_from_slice(&key[0..32]);
79        Privkey { inner: h.into() }
80    }
81}
82
83#[inline]
84fn atomic_fence() {
85    atomic::compiler_fence(atomic::Ordering::SeqCst);
86}
87
88#[inline]
89fn volatile_write<T: Copy + Sized>(dst: &mut T, src: T) {
90    unsafe { ptr::write_volatile(dst, src) }
91}
92
93impl Drop for Privkey {
94    fn drop(&mut self) {
95        self.zeroize()
96    }
97}
ckb_crypto/secp/privkey.rs

ckb_crypto/secp/
privkey.rs
