Struct recrypt::api_480::Recrypt480

pub struct Recrypt480<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 Recrypt480<Sha256, Ed25519, RandomBytes<DefaultRng>>

pub fn new() -> Recrypt480<Sha256, Ed25519, RandomBytes<DefaultRng>>

Construct a new Recrypt480 with pre-selected CSPRNG implementation.

The RNG will periodically reseed itself from the system's best entropy source.

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

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

Construct a Recrypt480 with the given RNG. Unless you have specific needs using new() is recommended.

Trait Implementations

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

fn schnorr_sign<A: Hashable>(
    &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 Recrypt480<H, S, RandomBytes<CR>>

fn generate_ed25519_key_pair(&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 Recrypt480<H, S, R>

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

Compute a PublicKey given a PrivateKey

fn random_private_key(&self) -> PrivateKey

Generate a random private key.

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

Generate a public/private keypair.

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

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 Recrypt480<H, S, R>

fn gen_plaintext(&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. Typically you either use derive_private_key or derive_symmetric_key but not both.

fn derive_private_key(&self, plaintext: &Plaintext) -> PrivateKey

Derive a private key for a plaintext by hashing it twice (with known leading bytes) and modding it by the prime. Typically you either use derive_private_key or derive_symmetric_key but not both.

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

Encrypt the plaintext to the to_public_key.

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

Decrypt the value using private_key.

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

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 Recrypt480<Sha256, Ed25519, RandomBytes<DefaultRng>>

fn default() -> Self

Returns the "default value" for a type.

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

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

Formats the value using the given formatter.