Enum SymmetricKeyAlgorithm 

#[non_exhaustive]
#[repr(u8)]
pub enum SymmetricKeyAlgorithm {
    Plaintext = 0,
    IDEA = 1,
    TripleDES = 2,
    CAST5 = 3,
    Blowfish = 4,
    AES128 = 7,
    AES192 = 8,
    AES256 = 9,
    Twofish = 10,
    Camellia128 = 11,
    Camellia192 = 12,
    Camellia256 = 13,
    Private10 = 110,
    Other(u8),
}

Available symmetric key algorithms. Ref: https://www.rfc-editor.org/rfc/rfc9580.html#name-symmetric-key-algorithms

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Plaintext = 0

Plaintext or unencrypted data

IDEA = 1

IDEA

TripleDES = 2

Triple-DES

CAST5 = 3

CAST5

Blowfish = 4

Blowfish

AES128 = 7

AES with 128-bit key

AES192 = 8

AES with 192-bit key

AES256 = 9

AES with 256-bit key

Twofish = 10

Twofish with 256-bit key

Camellia128 = 11

Camellia with 128-bit key

Camellia192 = 12

Camellia with 192-bit key

Camellia256 = 13

Camellia with 256-bit key

Private10 = 110

Other(u8)

Implementations

impl SymmetricKeyAlgorithm

pub fn block_size(self) -> usize

The size of a single block in bytes. Based on https://github.com/gpg/libgcrypt/blob/master/cipher

pub const fn key_size(self) -> usize

The size of a single block in bytes. Based on https://github.com/gpg/libgcrypt/blob/master/cipher

pub fn decrypt( self, key: &[u8], prefix: &mut [u8], ciphertext: &mut [u8], ) -> Result<()>

Decrypt the data using CFB mode, without padding. Overwrites the input. Uses an IV of all zeroes, as specified in the openpgp cfb mode. Does resynchronization.

pub fn decrypt_protected( self, key: &[u8], prefix: &mut [u8], ciphertext: &mut Vec<u8>, ) -> Result<()>

Decrypt the data using CFB mode, without padding. Overwrites the input. Uses an IV of all zeroes, as specified in the openpgp cfb mode. Does not do resynchronization.

The result will be in ciphertext.

pub fn decrypt_with_iv( self, key: &[u8], iv_vec: &[u8], encrypted_prefix: &mut [u8], encrypted_data: &mut [u8], ) -> Result<()>

Decrypt the data using CFB mode, without padding. Overwrites the input.

OpenPGP CFB mode uses an initialization vector (IV) of all zeros, and prefixes the plaintext with BS+2 octets of random data, such that octets BS+1 and BS+2 match octets BS-1 and BS. It does a CFB resynchronization after encrypting those BS+2 octets.

Thus, for an algorithm that has a block size of 8 octets (64 bits), the IV is 10 octets long and octets 7 and 8 of the IV are the same as octets 9 and 10. For an algorithm with a block size of 16 octets (128 bits), the IV is 18 octets long, and octets 17 and 18 replicate octets 15 and 16. Those extra two octets are an easy check for a correct key.

pub fn decrypt_with_iv_resync( self, key: &[u8], iv_vec: &[u8], encrypted_prefix: &mut [u8], encrypted_data: &mut [u8], ) -> Result<()>

Applies the legacy resyncing

pub fn decrypt_with_iv_regular( self, key: &[u8], iv_vec: &[u8], ciphertext: &mut [u8], ) -> Result<()>

Decrypt the data using CFB mode, without padding. Overwrites the input. This is regular CFB, not OpenPgP CFB.

pub fn encrypt<R: CryptoRng + Rng>( self, rng: R, key: &[u8], plaintext: &[u8], ) -> Result<Vec<u8>>

Encrypt the data using CFB mode, without padding. Overwrites the input. Uses an IV of all zeroes, as specified in the openpgp cfb mode.

pub fn encrypt_protected<R: CryptoRng + Rng>( self, rng: R, key: &[u8], plaintext: &[u8], ) -> Result<Vec<u8>>

pub fn encrypted_protected_len(&self, plaintext_len: usize) -> usize

pub fn encrypted_protected_overhead(&self) -> usize

pub fn stream_encryptor<R, I>( self, rng: R, key: &[u8], plaintext: I, ) -> Result<StreamEncryptor<I>>

where R: Rng + CryptoRng, I: Read,

pub fn stream_decryptor_protected<R>( self, key: &[u8], ciphertext: R, ) -> Result<StreamDecryptor<R>>

where R: BufRead,

Protected decryption stream

pub fn stream_decryptor_unprotected<R>( self, key: &[u8], ciphertext: R, ) -> Result<StreamDecryptor<R>>

where R: BufRead,

Unprotected decryption stream

pub fn encrypt_with_iv( self, key: &[u8], iv_vec: &[u8], ciphertext: &mut [u8], ) -> Result<()>

Encrypt the data using CFB mode, without padding. Overwrites the input.

OpenPGP CFB mode uses an initialization vector (IV) of all zeros, and prefixes the plaintext with BS+2 octets of random data, such that octets BS+1 and BS+2 match octets BS-1 and BS. It does a CFB resynchronization after encrypting those BS+2 octets.

pub fn encrypt_with_iv_resync( self, key: &[u8], iv_vec: &[u8], ciphertext: &mut [u8], ) -> Result<()>

Uses legacy resycing

pub fn encrypt_with_iv_regular( self, key: &[u8], iv_vec: &[u8], plaintext: &mut [u8], ) -> Result<()>

Encrypt the data using CFB mode, without padding. Overwrites the input.

pub fn new_session_key<R: Rng + CryptoRng>(self, rng: R) -> RawSessionKey

Generate a new session key.

Trait Implementations

impl Clone for SymmetricKeyAlgorithm

fn clone(&self) -> SymmetricKeyAlgorithm

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SymmetricKeyAlgorithm

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for SymmetricKeyAlgorithm

fn default() -> Self

Returns the “default value” for a type.

impl From<SymmetricKeyAlgorithm> for u8

fn from(enum_value: SymmetricKeyAlgorithm) -> Self

Converts to this type from the input type.

impl From<u8> for SymmetricKeyAlgorithm

fn from(number: u8) -> Self

Converts to this type from the input type.

impl FromPrimitive for SymmetricKeyAlgorithm

type Primitive = u8

fn from_primitive(number: Self::Primitive) -> Self

impl PartialEq for SymmetricKeyAlgorithm

fn eq(&self, other: &SymmetricKeyAlgorithm) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for SymmetricKeyAlgorithm

impl DefaultIsZeroes for SymmetricKeyAlgorithm

impl Eq for SymmetricKeyAlgorithm

impl StructuralPartialEq for SymmetricKeyAlgorithm