[package]

name = "pgp-fuzz"

version = "0.0.0"

publish = false

edition = "2021"

[package.metadata]

cargo-fuzz = true

[dependencies]

libfuzzer-sys = "0.4"

rand = "0.8"

rand_chacha = "0.3"

buffer-redux = { version = "1.0.0", default-features = false }

[dependencies.pgp]

path = ".."

[profile.release]

overflow-checks = true

[[bin]]

name = "1_message_from_bytes"

path = "fuzz_targets/1_message_from_bytes.rs"

test = false

doc = false

bench = false

[[bin]]

name = "2_message_from_string"

path = "fuzz_targets/2_message_from_string.rs"

test = false

doc = false

bench = false

[[bin]]

name = "3_message_from_armored"

path = "fuzz_targets/3_message_from_armored.rs"

test = false

doc = false

bench = false

[[bin]]

name = "4_message_roundtrip_check"

path = "fuzz_targets/4_message_roundtrip_check.rs"

test = false

doc = false

bench = false

[[bin]]

name = "5_message_decryption"

path = "fuzz_targets/5_message_decryption.rs"

test = false

doc = false

bench = false

[[bin]]

name = "6_message_signing"

path = "fuzz_targets/6_message_signing.rs"

test = false

doc = false

bench = false

[[bin]]

name = "7_signed_key_from_binary"

path = "fuzz_targets/7_signed_key_from_binary.rs"

test = false

doc = false

bench = false

[[bin]]

name = "8_signed_public_key_from_armored"

path = "fuzz_targets/8_signed_public_key_from_armored.rs"

test = false

doc = false

bench = false

[[bin]]

name = "9_signed_public_key_from_binary"

path = "fuzz_targets/9_signed_public_key_from_binary.rs"

test = false

doc = false

bench = false

[[bin]]

name = "10_signed_secret_key_from_bytes"

path = "fuzz_targets/10_signed_secret_key_from_bytes.rs"

test = false

doc = false

bench = false

[[bin]]

name = "11_cleartext_signed_message_from_armor"

path = "fuzz_targets/11_cleartext_signed_message_from_armor.rs"

test = false

doc = false

bench = false

[[bin]]

name = "12_cleartext_signed_message_from_string"

path = "fuzz_targets/12_cleartext_signed_message_from_string.rs"

test = false

doc = false

bench = false

[[bin]]

name = "13_signature_from_binary"

path = "fuzz_targets/13_signature_from_binary.rs"

test = false

doc = false

bench = false

[[bin]]

name = "14_base64_decoder"

path = "fuzz_targets/14_base64_decoder.rs"

test = false

doc = false

bench = false

[[bin]]

name = "15_dearmor_parser"

path = "fuzz_targets/15_dearmor_parser.rs"

test = false

doc = false

bench = false

See https://github.com/rust-fuzz/cargo-fuzz for setup and usage instructions.

Hints:

* For use with stable Rust versions, consider using `--sanitizer none`

* See the `dictionaries` subdirectory for use with `-dict=` as libFuzzer parameter

"-----BEGIN DSA PRIVATE KEY-----"

"-----BEGIN EC PRIVATE KEY-----"

"-----BEGIN OPENSSH PRIVATE KEY-----"

"-----BEGIN PGP ARMORED FILE-----"

"-----BEGIN PGP MESSAGE-----"

"-----BEGIN PGP PRIVATE KEY BLOCK-----"

"-----BEGIN PGP PUBLIC KEY BLOCK-----"

"-----BEGIN PGP SECRET KEY BLOCK-----"

"-----BEGIN PGP SIGNATURE-----"

"-----BEGIN PGP SIGNED MESSAGE-----"

"-----BEGIN RSA PRIVATE KEY-----"

"-----END DSA PRIVATE KEY-----"

"-----END EC PRIVATE KEY-----"

"-----END OPENSSH PRIVATE KEY-----"

"-----END PGP ARMORED FILE-----"

"-----END PGP MESSAGE-----"

"-----END PGP PRIVATE KEY BLOCK-----"

"-----END PGP PUBLIC KEY BLOCK-----"

"-----END PGP SECRET KEY BLOCK-----"

"-----END PGP SIGNATURE-----"

"-----END PGP SIGNED MESSAGE-----"

"-----END RSA PRIVATE KEY-----"

use libfuzzer_sys::fuzz_target;

use pgp::{

types::{PublicKeyTrait, SecretKeyTrait},

Deserializable,

use rand::SeedableRng;

use rand_chacha::ChaCha8Rng;

fuzz_target!(|data: &[u8]| {

// FUZZER RESULT this triggers ~4GB OOM with short inputs

// finding RPG-8 in ROS report 2024, fixed with 0.14.2

let key_res = pgp::composed::SignedSecretKey::from_bytes(data);

match key_res {

Err(_) => return,

Ok(key) => {

// for successfully parsed keys, do something with the key

// key verification is slow

// let _ = key.verify();

let _ = key.to_armored_bytes(None.into());

let _ = key.expires_at();

let _ = key.fingerprint();

let _ = key.public_key();

// FUZZER RESULT this can panic on some inputs

// finding RPG-17 in ROS report 2024, fixed with 0.14.1

let _ = key.details.as_unsigned();

// just some simple data to sign, no special meaning

let dummy_data = vec![0u8; 8];

// indirectly calls unlock()

// FUZZER RESULT this can panic on some inputs

// finding RPG-20 in ROS report 2024, fixed with 0.14.1

let signature_res = key.create_signature(

|| "pw".into(),

pgp::crypto::hash::HashAlgorithm::SHA2_256,

&dummy_data,

);

match signature_res {

Err(_) => {}

Ok(signature) => {

let _verify_res = key.verify_signature(

pgp::crypto::hash::HashAlgorithm::SHA2_256,

&dummy_data,

&signature,

);

// FUZZER TODO, not all verifications succeed

// .expect("signature should verify");

}

}

// prepare for basic encryption test

let plaintext = vec![0u8; 32];

// fixed PRNG seed for deterministic behavior

let mut rng = ChaCha8Rng::seed_from_u64(0);

// FUZZER RESULT this can panic on some inputs

// finding RPG-21 in ROS report 2024, fixed with 0.14.1

let _ciphertext =

{ key.encrypt(&mut rng, plaintext.as_slice(), pgp::types::EskType::V6) };

// behavior should be mostly identical to the above, test it anyway

let _ciphertext =

{ key.encrypt(&mut rng, plaintext.as_slice(), pgp::types::EskType::V3_4) };

return;

}

}

use libfuzzer_sys::fuzz_target;

fuzz_target!(|data: &[u8]| {

// FUZZER RESULT this can panic on some inputs

// finding RPG-15 in ROS report 2024, fixed with 0.14.1

let message_res = pgp::composed::cleartext::CleartextSignedMessage::from_armor(data);

match message_res {

// parsing failed, we're not interested further

Err(_) => return,

// parsing succeeded, perform checks

Ok(combo) => {

let (message, _) = combo;

// test some functionality

let _ = message.signed_text();

let data2_res = message.to_armored_bytes(None.into());

match data2_res {

// FUZZER EXPERIMENT: see if the export ever fails

// not observed so far

Err(_) => panic!("inconsistent deserialize-serialize round trip behavior"),

Ok(_data2) => return,

}

}

}

use libfuzzer_sys::fuzz_target;

fuzz_target!(|data: &str| {

// FUZZER NOTE this is essentially a duplicate of the CleartextSignedMessage::from_armor() test case

// and likely not worth additional fuzzing, but was useful to confirm the panic behavior

// FUZZER RESULT this can panic on some inputs

// finding RPG-15 in ROS report 2024, fixed with 0.14.1

let _ = pgp::composed::cleartext::CleartextSignedMessage::from_string(data);

use libfuzzer_sys::fuzz_target;

use pgp::{types::SecretKeyTrait, Deserializable, SignedSecretKey};

fuzz_target!(|data: &[u8]| {

// FUZZER RESULT this triggers ~4GB OOM with short inputs

// finding RPG-8 in ROS report 2024, fixed with 0.14.2

let signature_res =

pgp::composed::StandaloneSignature::from_armor_single(std::io::Cursor::new(data));

match signature_res {

Ok(signature) => {

let (sig, _other) = signature;

let _ = sig.signature.key_expiration_time();

let _ = sig.signature.signature_expiration_time();

let _ = sig.to_armored_bytes(None.into());

// file content of ./tests/openpgp-interop/testcases/messages/gnupg-v1-001-decrypt.asc

// included here to avoid I/O operations

let key_input = "-----BEGIN PGP PRIVATE KEY BLOCK-----

let (decrypt_key, _headers) = SignedSecretKey::from_string(key_input).unwrap();

let _ = sig.verify(&decrypt_key.public_key(), b"dummy");

}

Err(_) => return,

}

use libfuzzer_sys::fuzz_target;

use pgp::Deserializable;

fuzz_target!(|data: &[u8]| {

// FUZZER RESULT this triggers ~4GB OOM with short inputs

// finding RPG-8 in ROS report 2024, fixed with 0.14.2

//

// FUZZER RESULT this triggers unsigned overflows, not visible in release profile

// finding RPG-10 in ROS report 2024, fixed with 0.14.1

let signature_res = pgp::composed::StandaloneSignature::from_bytes(data);

match signature_res {

Ok(sig) => {

// do something with the signature

let _ = sig.signature.key_expiration_time();

let _ = sig.signature.signature_expiration_time();

let _ = sig.to_armored_bytes(None.into());

}

Err(_) => return,

}

use std::io::Read;

use libfuzzer_sys::fuzz_target;

fuzz_target!(|data: &[u8]| {

// test base64 decoding

// FUZZER OBSERVATION no interesting behavior so far

let reader = pgp::base64_reader::Base64Reader::new(data);

let mut der = pgp::base64_decoder::Base64Decoder::new(reader);

let mut res = String::new();

let _ = der.read_to_string(&mut res);