Enum pgp::crypto::sym::SymmetricKeyAlgorithm

#[repr(u8)]
pub enum SymmetricKeyAlgorithm {
    Plaintext,
    IDEA,
    TripleDES,
    CAST5,
    Blowfish,
    AES128,
    AES192,
    AES256,
    Twofish,
    Camellia128,
    Camellia192,
    Camellia256,
    Private10,
}

Available symmetric key algorithms.

Variants

Plaintext

Plaintext or unencrypted data

IDEA

TripleDES

TripleDES (DES-EDE, 168 bit key derived from 192)

CAST5

CAST5 (128 bit key, as per [RFC2144])

Blowfish

Blowfish (128 bit key, 16 rounds)

AES128

AES192

AES256

Twofish

Twofish with 256-bit key [TWOFISH]

Camellia128

Camellia192

Camellia256

Private10

Methods

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 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<'a>(
    self,
    key: &[u8],
    ciphertext: &'a mut [u8]
) -> Result<&'a [u8]>

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<'a>(
    self,
    key: &[u8],
    ciphertext: &'a mut [u8]
) -> Result<&'a [u8]>

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.

pub fn decrypt_with_iv<'a>(
    self,
    key: &[u8],
    iv_vec: &[u8],
    ciphertext: &'a mut [u8],
    resync: bool
) -> Result<(&'a [u8], &'a [u8])>

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_regular<'a>(
    self,
    key: &[u8],
    iv_vec: &[u8],
    ciphertext: &'a mut [u8]
) -> Result<()>

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

pub fn encrypt(self, 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<'a>(
    self,
    key: &[u8],
    plaintext: &'a [u8]
) -> Result<Vec<u8>>

pub fn encrypt_with_iv<'a>(
    self,
    key: &[u8],
    iv_vec: &[u8],
    ciphertext: &'a mut [u8],
    resync: bool
) -> 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_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: &mut R) -> Vec<u8>

Generate a new session key.

Trait Implementations

impl Clone for SymmetricKeyAlgorithm

fn clone(&self) -> SymmetricKeyAlgorithm

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for SymmetricKeyAlgorithm

impl Default for SymmetricKeyAlgorithm

fn default() -> Self

Returns the "default value" for a type.

impl Eq for SymmetricKeyAlgorithm

impl PartialEq<SymmetricKeyAlgorithm> for SymmetricKeyAlgorithm

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Debug for SymmetricKeyAlgorithm

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

Formats the value using the given formatter.

impl FromPrimitive for SymmetricKeyAlgorithm

fn from_i64(n: i64) -> Option<Self>

Convert an i64 to return an optional value of this type. If the type cannot be represented by this value, then None is returned.

fn from_u64(n: u64) -> Option<Self>

Convert an u64 to return an optional value of this type. If the type cannot be represented by this value, then None is returned.

fn from_isize(n: isize) -> Option<Self>

Convert an isize to return an optional value of this type. If the value cannot be represented by this value, then None is returned.

fn from_i8(n: i8) -> Option<Self>

Convert an i8 to return an optional value of this type. If the type cannot be represented by this value, then None is returned.

fn from_i16(n: i16) -> Option<Self>

Convert an i16 to return an optional value of this type. If the type cannot be represented by this value, then None is returned.

fn from_i32(n: i32) -> Option<Self>

Convert an i32 to return an optional value of this type. If the type cannot be represented by this value, then None is returned.

fn from_i128(n: i128) -> Option<Self>

Convert an i128 to return an optional value of this type. If the type cannot be represented by this value, then None is returned.

fn from_usize(n: usize) -> Option<Self>

Convert a usize to return an optional value of this type. If the type cannot be represented by this value, then None is returned.

fn from_u8(n: u8) -> Option<Self>

Convert an u8 to return an optional value of this type. If the type cannot be represented by this value, then None is returned.

fn from_u16(n: u16) -> Option<Self>

Convert an u16 to return an optional value of this type. If the type cannot be represented by this value, then None is returned.

fn from_u32(n: u32) -> Option<Self>

Convert an u32 to return an optional value of this type. If the type cannot be represented by this value, then None is returned.

fn from_u128(n: u128) -> Option<Self>

Convert an u128 to return an optional value of this type. If the type cannot be represented by this value, then None is returned.

fn from_f32(n: f32) -> Option<Self>

Convert a f32 to return an optional value of this type. If the type cannot be represented by this value, then None is returned.

fn from_f64(n: f64) -> Option<Self>

Convert a f64 to return an optional value of this type. If the type cannot be represented by this value, then None is returned.

impl DefaultIsZeroes for SymmetricKeyAlgorithm