Struct blsttc::SecretKey

pub struct SecretKey(_);

A secret key; wraps a single prime field element. The field element is heap allocated to avoid any stack copying that result when passing SecretKeys between stack frames.

Serde integration

SecretKey implements Deserialize but not Serialize to avoid accidental serialization in insecure contexts. To enable both use the ::serde_impl::SerdeSecret wrapper which implements both Deserialize and Serialize.

Implementations

impl SecretKey

pub fn from_mut(fr: &mut Fr) -> Self

Creates a new SecretKey from a mutable reference to a field element. This constructor takes a reference to avoid any unnecessary stack copying/moving of secrets (i.e. the field element). The field element is copied bytewise onto the heap, the resulting Box is stored in the returned SecretKey.

WARNING this constructor will overwrite the referenced Fr element with zeros after it has been copied onto the heap.

pub fn random() -> Self

Creates a new random instance of SecretKey.

If you want to use/define your own random number generator, you should use the constructor: SecretKey::sample(). If you do not need to specify your own RNG, you should use the SecretKey::random() constructor, which uses rand::thread_rng() internally as its RNG.

pub fn public_key(&self) -> PublicKey

Returns the matching public key.

pub fn sign_g2<H: Into<G2Affine>>(&self, hash: H) -> Signature

Signs the given element of G2.

pub fn sign<M: AsRef<[u8]>>(&self, msg: M) -> Signature

Signs the given message.

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

Converts the secret key to big endian bytes

pub fn from_bytes(bytes: [u8; 32]) -> Result<Self>

Deserialize from big endian bytes

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

Deserialize a hex-encoded representation of a SecretKey to a SecretKey instance.

pub fn to_hex(&self) -> String

Serialize this SecretKey instance to a hex-encoded String.

pub fn decrypt(&self, ct: &Ciphertext) -> Option<Vec<u8>>

Returns the decrypted text, or None, if the ciphertext isn’t valid.

pub fn reveal(&self) -> String

Generates a non-redacted debug string. This method differs from the Debug implementation in that it does leak the secret prime field element.

pub fn derive_child(&self, index: &[u8]) -> Self

Derives a child secret key for a given index.

Trait Implementations

impl Clone for SecretKey

fn clone(&self) -> SecretKey

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SecretKey

A debug statement where the secret prime field element is redacted.

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

Formats the value using the given formatter.

impl Default for SecretKey

Creates a SecretKey containing the zero prime field element.

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for SecretKey

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

Deserialize this value from the given Serde deserializer.

impl Distribution<SecretKey> for Standard

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> SecretKey

Creates a new random instance of SecretKey. If you do not need to specify your own RNG, you should use the SecretKey::random() constructor, which uses rand::thread_rng() internally as its RNG.

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>where
    R: Rng,
    Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>where
    F: Fn(T) -> S,
    Self: Sized,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F

impl Drop for SecretKey

fn drop(&mut self)

Executes the destructor for this type.

impl From<SecretKey> for Scalar

Utility to convert blsttc to blst types

fn from(item: SecretKey) -> Self

Converts to this type from the input type.

impl PartialEq<Scalar> for SecretKey

Utility to compare between blsttc and blst types

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<SecretKey> for SecretKey

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

This method tests for self and other values to be equal, and is used by ==.

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

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

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

impl StructuralEq for SecretKey

impl StructuralPartialEq for SecretKey