Struct GroupKey 

pub struct GroupKey<CS> { /* private fields */ }

Key material used to derive per-event encryption keys.

Implementations

impl<CS: CipherSuite> GroupKey<CS>

pub const OVERHEAD: usize

The size in bytes of the overhead added to plaintexts encrypted with seal.

pub fn new<R: Csprng>(rng: &mut R) -> Self

Creates a new, random GroupKey.

pub fn id(&self) -> Result<GroupKeyId, IdError>

Uniquely identifies the GroupKey.

Two keys with the same ID are the same key.

pub const fn overhead(&self) -> usize

Returns the size in bytes of the overhead added to plaintexts encrypted with seal.

Same as OVERHEAD.

pub fn seal<R: Csprng>( &self, rng: &mut R, dst: &mut [u8], plaintext: &[u8], ctx: Context<'_, CS>, ) -> Result<(), Error>

Encrypts and authenticates plaintext in a particular context.

The resulting ciphertext is written to dst, which must be at least overhead bytes longer than plaintext.len().

Example

use aranya_crypto::{
    Context, GroupKey, Rng, SigningKey,
    default::{DefaultCipherSuite, DefaultEngine},
    policy::CmdId,
};

const MESSAGE: &[u8] = b"hello, world!";
const LABEL: &str = "doc test";
const PARENT: CmdId = CmdId::default();
let author = SigningKey::<DefaultCipherSuite>::new(&mut Rng)
    .public()
    .expect("signing key should be valid");

let key = GroupKey::new(&mut Rng);

let ciphertext = {
    let mut dst = vec![0u8; MESSAGE.len() + key.overhead()];
    key.seal(
        &mut Rng,
        &mut dst,
        MESSAGE,
        Context {
            label: LABEL,
            parent: PARENT,
            author_sign_pk: &author,
        },
    )
    .expect("should not fail");
    dst
};
let plaintext = {
    let mut dst = vec![0u8; ciphertext.len() - key.overhead()];
    key.open(
        &mut dst,
        &ciphertext,
        Context {
            label: LABEL,
            parent: PARENT,
            author_sign_pk: &author,
        },
    )
    .expect("should not fail");
    dst
};
assert_eq!(&plaintext, MESSAGE);

pub fn open( &self, dst: &mut [u8], ciphertext: &[u8], ctx: Context<'_, CS>, ) -> Result<(), Error>

Decrypts and authenticates ciphertext in a particular context.

The resulting plaintext is written to dst, which must be at least as long as the original plaintext (i.e., ciphertext.len() - overhead bytes long).

Trait Implementations

impl<CS> Clone for GroupKey<CS>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<CS: CipherSuite> ConstantTimeEq for GroupKey<CS>

fn ct_eq(&self, other: &Self) -> Choice

Determine if two items are equal.

fn ct_ne(&self, other: &Self) -> Choice

Determine if two items are NOT equal.

impl<CS> Drop for GroupKey<CS>

fn drop(&mut self)

Executes the destructor for this type.

impl<CS: CipherSuite> Identified for GroupKey<CS>

type Id = Id<GroupKeyIdTag>

Uniquely identifies the object.

fn id(&self) -> Result<Self::Id, IdError>

Uniquely identifies the object.

impl<CS: CipherSuite> UnwrappedKey<CS> for GroupKey<CS>

const ID: AlgId

The key’s algorithm identifier.

fn into_secret(self) -> Secret<CS>

Converts itself into the underlying Secret.

fn try_from_secret(key: UnwrappedSecret<CS>) -> Result<Self, WrongKeyType>

Converts itself from a UnwrappedSecret.

impl<CS> ZeroizeOnDrop for GroupKey<CS>