Struct AesGcmFileRead 

pub struct AesGcmFileRead { /* private fields */ }

Transparent decryption of AGS1 stream-encrypted files.

Implements the FileRead trait, providing random-access reads over encrypted data. Each read() call determines which encrypted blocks overlap the requested plaintext range, reads and decrypts them, then returns the requested plaintext bytes.

Usage

// (ignored: requires async runtime and concrete FileRead/FileWrite impls)
let reader = AesGcmFileRead::new(
    inner_reader,       // Box<dyn FileRead> for the encrypted file
    cipher,             // Arc<AesGcmCipher> with the DEK
    aad_prefix.to_vec(),
    encrypted_file_length,
)?;

// Read plaintext bytes transparently
let plaintext = reader.read(0..1024).await?;

Implementations

impl AesGcmFileRead

pub fn new( inner: Box<dyn FileRead>, cipher: Arc<AesGcmCipher>, aad_prefix: Box<[u8]>, encrypted_file_length: u64, ) -> Result<Self>

Creates a new AesGcmFileRead for decrypting an AGS1 stream.

Computes the plaintext size and block layout from the encrypted file length. No I/O is performed; header validation happens implicitly when blocks are decrypted (GCM authentication will fail on corrupt data).

Arguments

• inner - Reader for the underlying encrypted file
• cipher - AES-GCM cipher initialized with the file’s DEK
• aad_prefix - AAD prefix from the file’s StandardKeyMetadata
• encrypted_file_length - Total byte length of the encrypted file

pub fn plaintext_length(&self) -> u64

Returns the plaintext stream size in bytes.

pub fn calculate_plaintext_length(encrypted_file_length: u64) -> Result<u64>

Calculates the plaintext length from an encrypted file’s total length.

This is a static calculation matching Java’s AesGcmInputStream.calculatePlaintextLength().

Trait Implementations

impl FileRead for AesGcmFileRead

fn read<'life0, 'async_trait>( &'life0 self, range: Range<u64>, ) -> Pin<Box<dyn Future<Output = Result<Bytes>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Reads and decrypts a plaintext byte range from the encrypted AGS1 stream.

The caller specifies a range in plaintext coordinates (e.g. “bytes 0..1024 of the original file”). This method translates that into the encrypted file layout and performs the following steps:

1. Map to blocks — divides the plaintext range by PLAIN_BLOCK_SIZE to find which encrypted blocks (first_block..=last_block) contain the requested data.

2. Single I/O read — calculates the contiguous byte range in the encrypted file that covers all needed blocks (including the 8-byte AGS1 header offset, 12-byte nonces, and 16-byte GCM tags) and fetches them in one call to the inner FileRead.

3. Decrypt per block — iterates over each cipher block in the response, decrypts it with AES-GCM using the per-block AAD (aad_prefix || block_index), and slices out only the plaintext bytes that overlap the requested range.

4. Assemble result — concatenates the slices into a single Bytes buffer matching exactly range.end - range.start bytes.

Because each block is independently encrypted with its own nonce and AAD, arbitrary random-access reads are supported without decrypting the entire file. GCM authentication is verified per-block, so any tampering is detected at the granularity of individual blocks.