Struct PrivateKey 

pub struct PrivateKey {
    scalar: Scalar,
    public_key: PublicKey,
}

Private key - load using PrivateKey::from_hex or generate with PrivateKey::random.

Caches the associated PublicKey, which means that loading a PrivateKey involves a base point multiplication.

Fields

scalar: Scalar

underlying scalar

public_key: PublicKey

associated public key, stored for efficiency

Implementations

impl PrivateKey

pub fn as_scalar(&self) -> &Scalar

Returns reference to underlying scalar.

pub fn random() -> Self

pub fn public_key(&self) -> &PublicKey

pub fn scale(&self, pk: &PublicKey) -> PublicKey

Computes the PublicKey associated with the product of two PrivateKeys given only one private key.

pub fn shared_secret(&self, pk: &PublicKey) -> SharedSecret

Creates a Diffie-Hellman-type shared secret between this PrivateKey and the PublicKey.

Trait Implementations

impl Clone for PrivateKey

fn clone(&self) -> PrivateKey

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PrivateKey

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PrivateKey

fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl DigestibleSecret for PrivateKey

fn as_bytes(&self) -> &[u8]

fn update_digest<D: Digest>(&self, d: D, domain: impl AsRef<str>) -> D

Inserts this secret in the given digest

fn derive_scalar<D>(&self, d: D, domain: impl AsRef<str>) -> Scalar

where D: Digest<OutputSize = U64>,

Creates a Scalar from this secret

fn derive_bytes<D>(&self, d: D, domain: impl AsRef<str>) -> Vec<u8>

where D: Digest,

Creates Vec<u8> from this secret.

fn derive_id<D>(&self, d: D, domain: impl AsRef<str>) -> Id

where D: Digest<OutputSize = U32>,

Creates an Id from this secret.

fn derive_hs256<D>(&self, d: D, domain: impl AsRef<str>) -> HS256

where D: Digest,

Creates a HS256 from this secret.

fn derive_sealing_key<D>(&self, d: D, domain: impl AsRef<str>) -> SealingKey

where D: Digest<OutputSize = U32>,

Creates a (256-bit) crate::misc::crypto::SealingKey from this secret.

impl Encoding<32> for PrivateKey

fn from_bytes(bytes: [u8; 32]) -> Option<PrivateKey>

Decodes Some(object) from bytes if bytes encodes some object of type Self; otherwise returns None.

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

Encodes self as [u8; N].

fn from_slice(slice: &[u8]) -> Option<Self>

Like Self::from_bytes, but reads [u8; N] from slice. Returns None if slice.len()!=N or when the slice is not a valid encoding.

fn copy_to_slice(&self, slice: &mut [u8]) -> Option<()>

Copies the encoding of self into slice. Returns None when slice.len()!=N.

fn from_hex(hex: &str) -> Option<Self>

Like Self::from_bytes, but reads the [u8; N] from the 2*N-digit hex string hex. The case of the hex digits is ignored.

fn to_hex(&self) -> String

Returns the 2*N-digit lower-case hex representation of self.

unsafe fn from_ptr(ptr: *const u8) -> Option<Self>

Loads object from the N-byte buffer pointed to by ptr.

unsafe fn copy_to_ptr(self, ptr: *mut u8)

Writes the N-byte representation of this object to the memory location ptr.

impl From<Scalar> for PrivateKey

fn from(scalar: Scalar) -> Self

Converts to this type from the input type.

impl PartialEq for PrivateKey

fn eq(&self, other: &PrivateKey) -> 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<'de> Serialize for PrivateKey

fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl Eq for PrivateKey

impl StructuralPartialEq for PrivateKey