Struct core_crypto::Keypair

pub struct Keypair<Kp: KeyPairSchema>(pub Kp);

It represents an asymmetric private/public encryption key.

Implementations

impl<Kp: KeyPairSchema> Keypair<Kp>

pub fn random() -> Self

Generate a Keypair random.

Example

use symbol_crypto_core::prelude::{Keypair, Sym};
let keypair = Keypair::<Sym>::random();

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

Construct a Keypair from the bytes of a PublicKey and PrivateKey.

Inputs

• bytes: an &[u8] representing the PublicKey and PrivateKey as bytes.

Returns

A Result whose okay value is a Keypair or whose error value is an describing the error that occurred.

pub fn from_hex_private_key<S: AsRef<str>>(hex: S) -> Result<Self>

Construct a Keypair from a hex encoded private key string.

Inputs

• hex: an S representing the hex private key (String or &str).

Example

use symbol_crypto_core::prelude::{Keypair, Sym};
let private_key_hex: &str =
"7D3E959EB0CD66CC1DB6E9C62CB81EC52747AB56FA740CF18AACB5003429AD2E";
let keypair = Keypair::<Sym>::from_hex_private_key(private_key_hex);

Returns

A Result whose okay value is an Keypair or whose error value is an failure::Error describing the error that occurred.

pub fn from_private_key(private_key: PrivateKey) -> Self

Construct a Keypair PrivateKey type.

Inputs

• private_key: representing the PrivateKey type.

Example

use symbol_crypto_core::prelude::{Keypair, PrivateKey, Sym};
let private_key_hex: &str = "7D3E959EB0CD66CC1DB6E9C62CB81EC52747AB56FA740CF18AACB5003429AD2E";
let private_key = PrivateKey::from_str(private_key_hex).unwrap();
let keypair = Keypair::<Sym>::from_private_key(private_key);

Returns

A Keypair

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

Convert this keypair to bytes.

Returns

An array of bytes, [u8; KEYPAIR_LENGTH]. The first KEY_BYTES_SIZE of bytes is the PrivateKey, and the next KEY_BYTES_SIZE bytes is the PublicKey.

pub fn sign(&self, data: &[u8]) -> Signature

Signs a data bytes with a Keypair.

Inputs

• data: an &[u8] representing the data to sign.

Example

use symbol_crypto_core::prelude::{Keypair, Sym};
let keypair = Keypair::<Sym>::random();
let data = b"8ce03cd60514233b86789729102ea09e867fc6d964dea8c2018ef7d0a2e0e24bf7e348e917116690b9";

let signature = keypair.sign(data.as_ref());

Returns

A Signature the signature hash.

pub fn verify(&self, data: &[u8], signature: Signature) -> Result<()>

Verify a Signature on a data with this Keypair public key.

Inputs

• data: an &[u8] the data to verify.

• signature: an Signature the signature hash.

Returns

Returns Ok if the Signature was a valid signature created by this Keypair

pub fn private_key(&self) -> PrivateKey

pub fn public_key(&self) -> PublicKey

pub fn encrypt_message(
    &self,
    receiver_pk: &[u8; 32],
    msg: &[u8]
) -> Result<Vec<u8>>

Encode a message text using the signer’s PrivateKey of this Keypair and receiver’s PublicKey.

Inputs

• receiver_pk: The receiver’s public key.

• msg: Message to encrypt.

Example

use symbol_crypto_core::prelude::{Keypair, Sym, PublicKey};


let message = b"Symbol is awesome from Rust!";

let encrypt_text = signer_kp.encrypt_message(receiver_pk.as_fixed_bytes(), message).unwrap();

Returns

A Result whose okay value is an encrypt message Vec<u8> or whose error value is an failure::Error describing the error that occurred.

pub fn decrypt_message(
    &self,
    signer_pk: &[u8; 32],
    enc_msg: &[u8]
) -> Result<Vec<u8>>

Decrypt a message text using the receiver’s the PrivateKey of this Keypair and signer’s PublicKey.

Inputs

• signer_pk: The signer’s public key.

• enc_msg: Message encrypted.

Example

use symbol_crypto_core::prelude::{Keypair, Sym, PublicKey};

let receiver_kp = Keypair::<Sym>::from_hex_private_key("A22A4BBF126A2D7D7ECE823174DFD184C5DE0FDE4CB2075D30CFA409F7EF8908").unwrap();
let signer_pk = PublicKey::from_str("3FD283D8543C12B81917C154CDF4EFD3D48E553E6D7BC77E29CB168138CED17D").unwrap();

let encrypt_text_vec = [
    125, 59, 126, 248, 124, 129, 157, 100, 111, 84, 49, 163, 111, 68, 22, 137, 75, 132, 135,
    217, 251, 158, 115, 74, 226, 172, 200, 208, 33, 183, 110, 103, 107, 170, 52, 174, 192, 110,
    164, 44, 77, 69, 203, 48, 43, 17, 206, 143, 154, 155, 231, 72, 28, 24, 20, 241, 234, 202,
    184, 66,
];

let decrypted_text = receiver_kp.decrypt_message( signer_pk.as_fixed_bytes(), &encrypt_text_vec).unwrap();

Returns

A Result whose okay value is an decrypted message Vec<u8> or whose error value is an failure::Error describing the error that occurred.

Trait Implementations

impl<C: KeyPairSchema> AsRef<C> for Keypair<C>

fn as_ref(&self) -> &C

Performs the conversion.

impl<Kp: Clone + KeyPairSchema> Clone for Keypair<Kp>

fn clone(&self) -> Keypair<Kp>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Kp: Debug + KeyPairSchema> Debug for Keypair<Kp>

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

Formats the value using the given formatter.

impl<C: KeyPairSchema> Display for Keypair<C>

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

Formats the value using the given formatter.

impl<Kp: Hash + KeyPairSchema> Hash for Keypair<Kp>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<Kp: PartialEq + KeyPairSchema> PartialEq<Keypair<Kp>> for Keypair<Kp>

fn eq(&self, other: &Keypair<Kp>) -> bool

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

fn ne(&self, other: &Keypair<Kp>) -> bool

This method tests for !=.

impl<Kp: Copy + KeyPairSchema> Copy for Keypair<Kp>

impl<Kp: KeyPairSchema> StructuralPartialEq for Keypair<Kp>