Struct SecretKey 

pub struct SecretKey { /* private fields */ }

Secret pair of a and b defining a SecretKey

Safety

To ensure that no secret information lingers in memory after the variable goes out of scope, we advice calling zeroize before the variable goes out of scope.

Examples

Generate a random SecretKey:

use phoenix_core::SecretKey;
use rand::rngs::StdRng;
use rand::SeedableRng;
use zeroize::Zeroize;

let mut rng = StdRng::seed_from_u64(12345);
let mut sk = SecretKey::random(&mut rng);

// do something with the sk

sk.zeroize();

Note

Implementing ZeroizeOnDrop seems like an excellent way to lift the burden of manually zeroizing after use off the user, but unfortunately it doesn’t delete the memory reliably. See #244

Implementations

impl SecretKey

pub fn new(a: Fr, b: Fr) -> SecretKey

This method is used to construct a new SecretKey from the given secret pair of a and b.

pub fn a(&self) -> &Fr

Gets a

pub fn b(&self) -> &Fr

Gets b

pub fn random<R>(rng: &mut R) -> SecretKey

where R: RngCore + CryptoRng,

Deterministically create a new SecretKey from a random number generator

pub fn gen_note_sk(&self, stealth: &StealthAddress) -> SecretKey

Generates a NoteSecretKey using the R of the given StealthAddress. With the formula: note_sk = H(a · R) + b

pub fn owns(&self, stealth_address: &StealthAddress) -> bool

Checks if note_pk ?= (H(R · a) + b) · G

Trait Implementations

impl Archive for SecretKey

where Fr: Archive,

type Archived = ArchivedSecretKey

The archived representation of this type.

type Resolver = SecretKeyResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

unsafe fn resolve( &self, pos: usize, resolver: <SecretKey as Archive>::Resolver, out: *mut <SecretKey as Archive>::Archived, )

Creates the archived version of this value at the given position and writes it to the given output.

impl Clone for SecretKey

fn clone(&self) -> SecretKey

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl ConstantTimeEq for SecretKey

fn ct_eq(&self, other: &SecretKey) -> Choice

Determine if two items are equal.

fn ct_ne(&self, other: &Self) -> Choice

Determine if two items are NOT equal.

impl Debug for SecretKey

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<__D> Deserialize<SecretKey, __D> for <SecretKey as Archive>::Archived

where __D: Fallible + ?Sized, Fr: Archive, <Fr as Archive>::Archived: Deserialize<Fr, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<SecretKey, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl From<&SecretKey> for PublicKey

fn from(sk: &SecretKey) -> PublicKey

Converts to this type from the input type.

impl From<&SecretKey> for ViewKey

fn from(sk: &SecretKey) -> ViewKey

Converts to this type from the input type.

impl PartialEq for SecretKey

fn eq(&self, other: &SecretKey) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serializable<64> for SecretKey

type Error = Error

The type returned in the event of a conversion error.

fn to_bytes(&self) -> [u8; 64]

Serialize Self into a [[u8; N]].

fn from_bytes( buf: &[u8; 64], ) -> Result<SecretKey, <SecretKey as Serializable<64>>::Error>

Deserialize a [&[u8; N]] into Self, it might be fail.

const SIZE: usize = N

The size of

impl<__S> Serialize<__S> for SecretKey

where __S: Fallible + ?Sized, Fr: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<SecretKey as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl Zeroize for SecretKey

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.

impl Eq for SecretKey