Enum pgp::crypto::sym::SymmetricKeyAlgorithm[−][src]

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

Expand description

Available symmetric key algorithms.

Variants

Plaintext

Plaintext or unencrypted data

IDEA

IDEA

TripleDES

Triple-DES

CAST5

CAST5

Blowfish

Blowfish

AES128

AES with 128-bit key

AES192

AES with 192-bit key

AES256

AES with 256-bit key

Twofish

Twofish with 256-bit key

Camellia128

Camellia with 128-bit key

Camellia192

Camellia with 192-bit key

Camellia256

Camellia with 256-bit key

Private10

Implementations

[src]

impl SymmetricKeyAlgorithm

[src]

pub fn block_size(self) -> usize

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

[src]

pub fn key_size(self) -> usize

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

[src]

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.

[src]

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.

[src]

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.

[src]

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.

[src]

pub fn encrypt_with_rng<R: CryptoRng + Rng>(
 self,
 rng: &mut 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.

[src]

pub fn encrypt(self, key: &[u8 ], plaintext: &[u8 ]) -> Result<Vec<u8>>

Same as encrypt_with_rng, but uses rand::thread_rng for RNG.

[src]

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

[src]

pub fn encrypt_protected<'a>(
 self,
 key: &[u8 ],
 plaintext: &'a [u8 ]
) -> Result<Vec<u8>>

[src]

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.

[src]