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<const N: usize>(cipher: B, nonce: &Nonce<N>) -> Result<Self>

where Nonce<N>: AesGcmCompatible,

Creates a new GCM mode instance with default (16-byte) tag.

pub fn new_with_tag_len<const N: usize>( cipher: B, nonce: &Nonce<N>, tag_len: usize, ) -> Result<Self>

where Nonce<N>: AesGcmCompatible,

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

tag_len must be between 1 and 16 (inclusive).

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

Internal encrypt method - exposed for testing

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

Internal decrypt method with improved constant-time implementation - exposed for testing

Trait Implementations

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

const TAG_SIZE: usize = 16usize

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: BlockCipher + Zeroize + ZeroizeOnDrop> DecryptOperation<'a, Gcm<B>> for GcmDecryptOperation<'a, B>

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.

impl<'a, B: BlockCipher + Zeroize + ZeroizeOnDrop> EncryptOperation<'a, Gcm<B>> for GcmEncryptOperation<'a, B>

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: BlockCipher + Clone + Zeroize + ZeroizeOnDrop> SecureZeroingType for Gcm<B>

fn zeroed() -> Self

Create a zeroed instance

fn secure_clone(&self) -> Self

Create a secure clone that preserves security properties

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

type Key = SecretBytes<32>

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> Zeroize for Gcm<B>

where B: Zeroize + BlockCipher + ZeroizeOnDrop,

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.