Struct TopicKey 

pub struct TopicKey<CS: CipherSuite> { /* private fields */ }

Available on crate feature apq only.

A symmetric key used to encrypt queue messages for a particular topic.

Implementations

impl<CS: CipherSuite> TopicKey<CS>

pub const OVERHEAD: usize

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

pub fn new<R: Csprng>( rng: R, version: Version, topic: &Topic, ) -> Result<Self, Error>

Creates a new, random TopicKey.

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

Uniquely identifies the TopicKey.

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 when encrypted.

Same as OVERHEAD.

pub fn seal_message<R: Csprng>( &self, rng: R, dst: &mut [u8], plaintext: &[u8], version: Version, topic: &Topic, ident: &Sender<'_, CS>, ) -> Result<(), Error>

Encrypts and authenticates plaintext.

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

Example

use aranya_crypto::{
    BaseId, DeviceId, Rng,
    apq::{Sender, SenderSecretKey, SenderSigningKey, Topic, TopicKey, Version},
    default::{DefaultCipherSuite, DefaultEngine},
};

const VERSION: Version = Version::new(1);
let topic = Topic::new("SomeTopic");
const MESSAGE: &[u8] = b"hello, world!";

let ident = Sender {
    enc_key: &SenderSecretKey::<DefaultCipherSuite>::new(Rng)
        .public()
        .expect("sender encryption key should be valid"),
    sign_key: &SenderSigningKey::<DefaultCipherSuite>::new(Rng)
        .public()
        .expect("sender signing key should be valid"),
};

let key = TopicKey::new(Rng, VERSION, &topic).expect("should not fail");

let ciphertext = {
    let mut dst = vec![0u8; MESSAGE.len() + key.overhead()];
    key.seal_message(Rng, &mut dst, MESSAGE, VERSION, &topic, &ident)
        .expect("should not fail");
    dst
};
let plaintext = {
    let mut dst = vec![0u8; ciphertext.len() - key.overhead()];
    key.open_message(&mut dst, &ciphertext, VERSION, &topic, &ident)
        .expect("should not fail");
    dst
};
assert_eq!(&plaintext, MESSAGE);

pub fn open_message( &self, dst: &mut [u8], ciphertext: &[u8], version: Version, topic: &Topic, ident: &Sender<'_, CS>, ) -> Result<(), Error>

Decrypts and authenticates ciphertext.

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: CipherSuite> Clone for TopicKey<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> Drop for TopicKey<CS>

fn drop(&mut self)

Executes the destructor for this type.

impl<CS: CipherSuite> ZeroizeOnDrop for TopicKey<CS>