Struct recrypt::api_480::Api480

pub struct Api480<H, S, R> { /* fields omitted */ }

Recrypt public API - 480-bit If you are looking better performance, you might consider the 256-bit API in api.rs

Methods

impl Api480<Sha256, Ed25519, RandomBytes<ThreadRng>>

pub fn new() -> Api480<Sha256, Ed25519, RandomBytes<ThreadRng>>

impl<CR: CryptoRng + RngCore> Api480<Sha256, Ed25519, RandomBytes<CR>>

pub fn new_with_rand(r: CR) -> Api480<Sha256, Ed25519, RandomBytes<CR>>

Trait Implementations

impl<H: Sha256Hashing, S, CR: RngCore + CryptoRng> SchnorrOps for Api480<H, S, RandomBytes<CR>>

fn schnorr_sign<A: Hashable>(
    &mut self,
    priv_key: &PrivateKey,
    pub_key: PublicKey,
    message: &A
) -> SchnorrSignature

Create a signature for the message using priv_key. - priv_key - The private key which is used to generate the signature. - pub_key the public key which will be used to validate the signature. - message the message to sign.

fn schnorr_verify<A: Hashable>(
    &self,
    pub_key: PublicKey,
    augmenting_priv_key: Option<&PrivateKey>,
    message: &A,
    signature: SchnorrSignature
) -> bool

Verify that the message was signed by the matching private key to pub_key. Note that if pub_key was augmented the private key used in the augmentation should be passed in as augmenting_priv_key. - pub_key - The pub_key that was used in the signing process. - augmenting_priv_key - If the pub_key was augmented, pass the private key that was used to augment. None if no augmentation was done. - message - Message that was signed. - signature - The signature that was generated from schnorr_sign.

impl<H, S, CR: RngCore + CryptoRng> Ed25519Ops for Api480<H, S, RandomBytes<CR>>

fn generate_ed25519_key_pair(&mut self) -> SigningKeypair

Generate a signing key pair for use with the Ed25519Signing trait using the random number generator used to back the RandomBytes struct.

impl<R: RandomBytesGen, H: Sha256Hashing, S: Ed25519Signing> KeyGenOps for Api480<H, S, R>

fn compute_public_key(
    &self,
    private_key: &PrivateKey
) -> Result<PublicKey, ApiErr>

Compute a PublicKey given a PrivateKey

fn random_private_key(&mut self) -> PrivateKey

Generate a random private key.

fn generate_key_pair(&mut self) -> Result<(PrivateKey, PublicKey), ApiErr>

Generate a public/private keypair.

fn generate_transform_key(
    &mut self,
    from_private_key: &PrivateKey,
    to_public_key: PublicKey,
    signing_keypair: &SigningKeypair
) -> Result<TransformKey, ApiErr>

Generate a transform key which is used to delegate to the to_public_key from the from_private_key.

impl<R: RandomBytesGen, H: Sha256Hashing, S: Ed25519Signing> CryptoOps for Api480<H, S, R>

fn gen_plaintext(&mut self) -> Plaintext

Using the random_bytes, generate a random element of G_T, which is one of the rth roots of unity in FP12.

fn derive_symmetric_key(
    &self,
    decrypted_value: &Plaintext
) -> DerivedSymmetricKey

Convert our plaintext into a DecryptedSymmetricKey by hashing it.

fn hash_256<T: Hashable>(&self, to_hash: &T) -> [u8; 32]

Compute the stable hash of a value. This can be used to hash a Plaintext into a symmetric key or to generate a PrivateKey from a Plaintext which you're encrypting to someone else.

fn encrypt(
    &mut self,
    plaintext: &Plaintext,
    to_public_key: PublicKey,
    signing_keypair: &SigningKeypair
) -> Result<EncryptedValue, ApiErr>

Encrypt the plaintext to the to_public_key.

fn decrypt(
    &self,
    encrypted_value: EncryptedValue,
    private_key: &PrivateKey
) -> Result<Plaintext, ApiErr>

Decrypt the value using private_key.

fn transform(
    &mut self,
    encrypted_value: EncryptedValue,
    transform_key: TransformKey,
    signing_keypair: &SigningKeypair
) -> Result<EncryptedValue, ApiErr>

Transform the value encrypted_value using the transform_key. The returned value can be decrypted by the private key associated to the to_public_key in the transform_key.

impl Default for Api480<Sha256, Ed25519, RandomBytes<ThreadRng>>

fn default() -> Self

Returns the "default value" for a type.

impl<H: Debug, S: Debug, R: Debug> Debug for Api480<H, S, R>

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

Formats the value using the given formatter.