Struct Gcm 

pub struct Gcm<B: BlockCipher + Zeroize + ZeroizeOnDrop> { /* private fields */ }

GCM mode implementation

Implementations

impl<B: BlockCipher + Zeroize + ZeroizeOnDrop> Gcm<B>

pub fn new(cipher: B) -> Result<Self>

Creates a key-only GCM instance with a fixed 16-byte tag.

The nonce is deliberately supplied to each encrypt/decrypt operation; retaining it in this reusable object made accidental nonce reuse easy.

pub fn new_with_tag_len(cipher: B, tag_len: usize) -> Result<Self>

Creates a new GCM mode instance with specified tag length (in bytes).

Truncated tags are supported only from 12 through 16 bytes.

pub fn internal_encrypt<const N: usize>( &self, nonce: &Nonce<N>, plaintext: &[u8], associated_data: Option<&[u8]>, ) -> Result<Vec<u8>>

where Nonce<N>: AesGcmCompatible,

Internal encrypt method - exposed for testing

pub fn internal_decrypt<const N: usize>( &self, nonce: &Nonce<N>, ciphertext: &[u8], associated_data: Option<&[u8]>, ) -> Result<Vec<u8>>

where Nonce<N>: AesGcmCompatible,

Internal decrypt method; exposed for testing.

pub fn internal_decrypt_protected<const N: usize>( &self, nonce: &Nonce<N>, ciphertext: &[u8], associated_data: Option<&[u8]>, ) -> Result<ZeroizingBytes>

where Nonce<N>: AesGcmCompatible,

Decrypt into exact-size storage that clears itself on all internal error and drop paths. Callers should use this for intermediate plaintext that has not yet crossed a public output boundary.

Trait Implementations

impl<B: BlockCipher + Zeroize + ZeroizeOnDrop> AuthenticatedCipher for Gcm<B>

const TAG_SIZE: usize = GCM_TAG_SIZE

Authentication tag size in bytes

const ALGORITHM_ID: &'static str = "GCM"

Static algorithm identifier for compile-time checking

fn name() -> String

Returns the authenticated cipher algorithm name

impl<B: Clone + BlockCipher + Zeroize + ZeroizeOnDrop> Clone for Gcm<B>

fn clone(&self) -> Gcm<B>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, B> DecryptOperation<'a, Gcm<B>> for GcmDecryptOperation<'a, B>

where B: BlockCipher + Zeroize + ZeroizeOnDrop, B::Key: GcmKey,

fn with_nonce(self, nonce: &'a <Gcm<B> as SymmetricCipher>::Nonce) -> Self

Set the nonce for decryption

fn with_aad(self, aad: &'a [u8]) -> Self

Set associated data for authenticated decryption

fn decrypt( self, ciphertext: &'a <Gcm<B> as SymmetricCipher>::Ciphertext, ) -> Result<Vec<u8>, CoreError>

Set ciphertext and execute decryption

impl<B: BlockCipher + Zeroize + ZeroizeOnDrop> Drop for Gcm<B>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<'a, B> EncryptOperation<'a, Gcm<B>> for GcmEncryptOperation<'a, B>

where B: BlockCipher + Zeroize + ZeroizeOnDrop, B::Key: GcmKey,

fn with_nonce(self, nonce: &'a <Gcm<B> as SymmetricCipher>::Nonce) -> Self

Set the nonce for encryption

fn with_aad(self, aad: &'a [u8]) -> Self

Set associated data for authenticated encryption

fn encrypt(self, plaintext: &'a [u8]) -> Result<Ciphertext, CoreError>

Set plaintext and execute encryption

impl<B> SymmetricCipher for Gcm<B>

where B: BlockCipher + Zeroize + ZeroizeOnDrop, B::Key: GcmKey,

type Key = <B as BlockCipher>::Key

Key type with appropriate algorithm binding

type Nonce = Nonce<12>

Nonce type with appropriate size constraint

type Ciphertext = Ciphertext

Ciphertext output type

type EncryptOperation<'a> = GcmEncryptOperation<'a, B> where Self: 'a

Operation type for encryption operations

type DecryptOperation<'a> = GcmDecryptOperation<'a, B> where Self: 'a

Operation type for decryption operations

fn name() -> &'static str

Returns the symmetric cipher algorithm name

fn encrypt(&self) -> <Self as SymmetricCipher>::EncryptOperation<'_>

Begin encryption operation

fn decrypt(&self) -> <Self as SymmetricCipher>::DecryptOperation<'_>

Begin decryption operation

fn generate_key<R: RngCore + CryptoRng>( rng: &mut R, ) -> Result<<Self as SymmetricCipher>::Key, CoreError>

Generate a new random key

fn generate_nonce<R: RngCore + CryptoRng>( rng: &mut R, ) -> Result<<Self as SymmetricCipher>::Nonce, CoreError>

Generate a new random nonce

fn derive_key_from_bytes( bytes: &[u8], ) -> Result<<Self as SymmetricCipher>::Key, CoreError>

Derive a key from arbitrary bytes

impl<B: BlockCipher + Zeroize + ZeroizeOnDrop> Zeroize for Gcm<B>

fn zeroize(&mut self)

impl<B: BlockCipher + Zeroize + ZeroizeOnDrop> ZeroizeOnDrop for Gcm<B>