diff --git a/ATTRIBUTION.md b/ATTRIBUTION.md index 32bae195d..77d3578cb 100644 --- a/ATTRIBUTION.md +++ b/ATTRIBUTION.md @@ -6,6 +6,7 @@ author, source and license. Library code and original assets are under the repos | File | Author | Source | License | |---|---|---|---| +| `crates/smime/testdata/` | MailCraft contributors; RFC 9216 example certificates | [MailCraft at 240d1d42](https://github.com/UCS-Care-Group/mailcraft/tree/240d1d42fe394cf3274402b180663ba9b43ca180/crates/smime/testdata), restored unmodified; provenance in the directory README | MIT OR Apache-2.0 (source repository) | | `licenses/dwg/acadrust-MPL-2.0.txt`, `licenses/dwg/acadrust-THIRD_PARTY_NOTICES.md` | `acadrust` contributors; ACadSharp authors for the noted ported routines | [acadrust 0.6.6](https://github.com/hakanaktt/acadrust), used unmodified as `craft-dwg`'s optional native dependency | MPL-2.0; embedded ACadSharp notice is MIT; see both retained files | | `crates/cms/profiles/photocraft-coated-cmyk.icc` | PhotoCraft contributors; generated by `craft_cms::synth::coated_cmyk` | [PhotoCraft `crates/cms`](https://github.com/storytold/photocraft/tree/b3222ee8e7e6bcb4799c37f904c595f20f9baf5e/crates/cms) | CC0-1.0 | | `crates/cms/profiles/craft-coated-fogra39.icc` | craft-libs contributors; generated by `crates/cms/tests/fogra39.rs` from the FOGRA39 data below | this repository | CC0-1.0 | diff --git a/Cargo.lock b/Cargo.lock index b68b24b74..9a600099d 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -301,6 +301,45 @@ dependencies = [ "libloading", ] +[[package]] +name = "asn1-rs" +version = "0.7.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b7f43a50ac4fdca5df8e885c21b835997f0a1cdee65494a6847694a98652d9d8" +dependencies = [ + "asn1-rs-derive", + "asn1-rs-impl", + "displaydoc", + "nom 7.1.3", + "num-traits", + "rusticata-macros", + "thiserror 2.0.21", + "time", +] + +[[package]] +name = "asn1-rs-derive" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3109e49b1e4909e9db6515a30c633684d68cdeaa252f215214cb4fa1a5bfee2c" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", + "synstructure 0.13.2", +] + +[[package]] +name = "asn1-rs-impl" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7b18050c2cd6fe86c3a76584ef5e0baf286d038cda203eb6223df2cc413565f7" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + [[package]] name = "async-broadcast" version = "0.7.2" @@ -564,6 +603,9 @@ name = "bit-vec" version = "0.9.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b71798fca2c1fe1086445a7258a4bc81e6e49dcd24c8d0dd9a1e57395b603f51" +dependencies = [ + "serde", +] [[package]] name = "bit-vec" @@ -1093,7 +1135,7 @@ dependencies = [ "crmf", "der 0.7.10", "spki 0.7.3", - "x509-cert", + "x509-cert 0.2.5", ] [[package]] @@ -1105,7 +1147,19 @@ dependencies = [ "const-oid 0.9.6", "der 0.7.10", "spki 0.7.3", - "x509-cert", + "x509-cert 0.2.5", +] + +[[package]] +name = "cms" +version = "0.3.0-rc.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d089eddc8a5c984d82fcf1427367a6fa0d019d5af04b6e3197e86c8989533b8d" +dependencies = [ + "const-oid 0.10.3", + "der 0.8.3", + "spki 0.8.1", + "x509-cert 0.3.0", ] [[package]] @@ -2541,6 +2595,37 @@ dependencies = [ "zip", ] +[[package]] +name = "craft-smime" +version = "0.1.0" +dependencies = [ + "aes 0.9.4", + "base64 0.23.1", + "cbc", + "cms 0.3.0-rc.2", + "const-oid 0.10.3", + "craft-ber", + "der 0.8.3", + "des 0.9.0", + "hmac 0.13.0", + "p256 0.14.0", + "p384 0.14.0", + "pbkdf2", + "pkcs1 0.8.0", + "pkcs12", + "proptest", + "rcgen", + "ring", + "rsa 0.10.0-rc.18", + "serde", + "sha1 0.11.0", + "sha2 0.11.1", + "spki 0.8.1", + "thiserror 2.0.21", + "x509-cert 0.3.0", + "zeroize", +] + [[package]] name = "craft-stencilcraft-document" version = "0.1.0" @@ -2905,10 +2990,10 @@ version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "36fe21b96d5b87f5de4b5b7202ec41c00110ac817ce6728fe75fb2fe5962ed92" dependencies = [ - "cms", + "cms 0.2.3", "der 0.7.10", "spki 0.7.3", - "x509-cert", + "x509-cert 0.2.5", ] [[package]] @@ -3132,6 +3217,12 @@ dependencies = [ "syn 2.0.119", ] +[[package]] +name = "data-encoding" +version = "2.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4583a4551df46e2792f82ceeac45e850d2e2d5debba0b91f102385cda5b11f06" + [[package]] name = "data-url" version = "0.3.2" @@ -3154,7 +3245,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb" dependencies = [ "const-oid 0.9.6", - "der_derive", + "der_derive 0.7.3", "flagset", "pem-rfc7468 0.7.0", "zeroize", @@ -3167,10 +3258,26 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6a996a108feb8b427a6e12fcf6af4aa83409b79d72c15337d7741368131ee004" dependencies = [ "const-oid 0.10.3", + "der_derive 0.8.0", + "flagset", "pem-rfc7468 1.0.0", "zeroize", ] +[[package]] +name = "der-parser" +version = "10.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "07da5016415d5a3c4dd39b11ed26f915f52fc4e0dc197d87908bc916e51bc1a6" +dependencies = [ + "asn1-rs", + "displaydoc", + "nom 7.1.3", + "num-bigint", + "num-traits", + "rusticata-macros", +] + [[package]] name = "der_derive" version = "0.7.3" @@ -3182,6 +3289,17 @@ dependencies = [ "syn 2.0.119", ] +[[package]] +name = "der_derive" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "59600e2c2d636fde9b65e99cc6445ac770c63d3628195ff39932b8d6d7409903" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + [[package]] name = "deranged" version = "0.5.9" @@ -6646,6 +6764,15 @@ dependencies = [ "cc", ] +[[package]] +name = "oid-registry" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "12f40cff3dde1b6087cc5d5f5d4d65712f34016a03ed60e9c08dcc392736b5b7" +dependencies = [ + "asn1-rs", +] + [[package]] name = "once_cell" version = "1.21.4" @@ -7135,6 +7262,21 @@ dependencies = [ "spki 0.8.1", ] +[[package]] +name = "pkcs12" +version = "0.2.0-rc.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9fd993500a1de8a428a2e6cc9a2ec942c99a801a88d58a24fb986c5ad3b767ca" +dependencies = [ + "cms 0.3.0-rc.2", + "const-oid 0.10.3", + "der 0.8.3", + "digest 0.11.3", + "spki 0.8.1", + "x509-cert 0.3.0", + "zeroize", +] + [[package]] name = "pkcs8" version = "0.10.2" @@ -7764,6 +7906,19 @@ dependencies = [ "cipher 0.5.2", ] +[[package]] +name = "rcgen" +version = "0.14.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8774e05a7d0de114588e6a28fe7e71694b82614ed569d86d8b389dfbc98b8ad8" +dependencies = [ + "ring", + "rustls-pki-types", + "time", + "x509-parser", + "yasna", +] + [[package]] name = "read-fonts" version = "0.39.2" @@ -8131,6 +8286,15 @@ dependencies = [ "semver", ] +[[package]] +name = "rusticata-macros" +version = "4.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "faf0c4a6ece9950b9abdb62b1cfcf2a68b3b67a10ba445b3bb85be2a293d0632" +dependencies = [ + "nom 7.1.3", +] + [[package]] name = "rustix" version = "0.38.44" @@ -8661,7 +8825,7 @@ dependencies = [ "spki 0.7.3", "thiserror 2.0.21", "tracing", - "x509-cert", + "x509-cert 0.2.5", ] [[package]] @@ -8710,7 +8874,7 @@ dependencies = [ "sigstore-crypto", "sigstore-types", "thiserror 2.0.21", - "x509-cert", + "x509-cert 0.2.5", ] [[package]] @@ -8723,7 +8887,7 @@ dependencies = [ "base64 0.22.1", "chrono", "cmpv2", - "cms", + "cms 0.2.3", "const-oid 0.9.6", "der 0.7.10", "hex", @@ -8735,7 +8899,7 @@ dependencies = [ "sigstore-types", "thiserror 2.0.21", "tracing", - "x509-cert", + "x509-cert 0.2.5", "x509-tsp", ] @@ -8762,7 +8926,7 @@ checksum = "d30aff69036e4579b416956e9ba68cec45b793116f78f10842d04c7f8b924bab" dependencies = [ "base64 0.22.1", "chrono", - "cms", + "cms 0.2.3", "const-oid 0.9.6", "hex", "pem", @@ -8781,7 +8945,7 @@ dependencies = [ "thiserror 2.0.21", "tls_codec", "tracing", - "x509-cert", + "x509-cert 0.2.5", ] [[package]] @@ -9332,6 +9496,17 @@ dependencies = [ "futures-core", ] +[[package]] +name = "synstructure" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + [[package]] name = "synstructure" version = "0.14.0" @@ -11337,6 +11512,35 @@ dependencies = [ "tls_codec", ] +[[package]] +name = "x509-cert" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "105ef4642d9cb137ef83d623d0e4bf08b8adf69e9918ca904a174adb6d3d038b" +dependencies = [ + "const-oid 0.10.3", + "der 0.8.3", + "spki 0.8.1", +] + +[[package]] +name = "x509-parser" +version = "0.18.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d43b0f71ce057da06bc0851b23ee24f3f86190b07203dd8f567d0b706a185202" +dependencies = [ + "asn1-rs", + "data-encoding", + "der-parser", + "lazy_static", + "nom 7.1.3", + "oid-registry", + "ring", + "rusticata-macros", + "thiserror 2.0.21", + "time", +] + [[package]] name = "x509-tsp" version = "0.1.0" @@ -11344,7 +11548,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f5ceece934a21607055b7ac5c25adb56a2ff559804b10705dc674d1d838c15e1" dependencies = [ "cmpv2", - "cms", + "cms 0.2.3", "der 0.7.10", ] @@ -11407,6 +11611,16 @@ version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7a5a4b21e1a62b67a2970e6831bc091d7b87e119e7f9791aef9702e3bef04448" +[[package]] +name = "yasna" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b5f6765e852b9b4dc8e2a76843e4d64d1cea8e79bcde0b6901aea8e7c7f08282" +dependencies = [ + "bit-vec 0.9.1", + "time", +] + [[package]] name = "yeslogic-fontconfig-sys" version = "6.0.1" @@ -11438,7 +11652,7 @@ dependencies = [ "proc-macro2", "quote", "syn 3.0.6", - "synstructure", + "synstructure 0.14.0", ] [[package]] @@ -11549,7 +11763,7 @@ dependencies = [ "proc-macro2", "quote", "syn 3.0.6", - "synstructure", + "synstructure 0.14.0", ] [[package]] diff --git a/Cargo.toml b/Cargo.toml index 178381cce..77b20da79 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -11,6 +11,7 @@ rust-version = "1.95" repository = "https://github.com/storytold/craft-libs" [workspace.dependencies] +craft-smime = { path = "crates/smime" } craft-ber = { path = "crates/ber" } craft-proto = { path = "crates/proto" } acadrust = "=0.6.6" diff --git a/crates/smime/Cargo.toml b/crates/smime/Cargo.toml new file mode 100644 index 000000000..d2b53cabb --- /dev/null +++ b/crates/smime/Cargo.toml @@ -0,0 +1,44 @@ +[package] +name = "craft-smime" +description = "S/MIME (RFC 8551): Digital signatures checked from CMS (RFC 5652) and X.509 (RFC 5280), no I/O" +version.workspace = true +edition.workspace = true +license.workspace = true +rust-version.workspace = true +repository.workspace = true + +[lints] +workspace = true + +[dependencies] +craft-ber = { workspace = true } +serde = { workspace = true } +base64 = "0.23" +# RustCrypto: CMS, X.509, DER, SPKI, OID, RSA, P256, P384, SHA2. +cms = { version = "=0.3.0-rc.2", default-features = false } +x509-cert = { version = "0.3", default-features = false } +der = { version = "0.8", default-features = false, features = ["alloc", "oid"] } +spki = { version = "0.8", default-features = false, features = ["alloc"] } +const-oid = { version = "0.10", default-features = false, features = ["db"] } +# Match craft-pkcs7's RSA pin; parse PKCS #1 separately to avoid incompatible RC encoding APIs. +rsa = { version = "=0.10.0-rc.18", default-features = false } +pkcs1 = { version = "0.8", default-features = false, features = ["alloc"] } +p256 = { version = "0.14", default-features = false, features = ["ecdsa", "alloc"] } +p384 = { version = "0.14", default-features = false, features = ["ecdsa", "alloc"] } +sha2 = { version = "0.11", default-features = false, features = ["oid"] } +# PKCS #12 file handling (RFC 7292 Appendix B): PBES2, triple-DES key derivation. +pkcs12 = { version = "=0.2.0-rc.0", default-features = false, features = ["kdf"] } +pbkdf2 = { version = "0.13", default-features = false, features = ["hmac"] } +hmac = { version = "0.13", default-features = false } +sha1 = { version = "0.11", default-features = false } +aes = { version = "0.9", default-features = false } +des = { version = "0.9", default-features = false } +cbc = { version = "0.2", default-features = false, features = ["block-padding"] } +zeroize = { version = "1", default-features = false, features = ["alloc"] } +# Error handling. +thiserror = { workspace = true } + +[dev-dependencies] +proptest = { workspace = true } +rcgen = { version = "0.14.10", default-features = false, features = ["crypto", "ring"] } +ring = "0.17" diff --git a/crates/smime/src/algorithms.rs b/crates/smime/src/algorithms.rs new file mode 100644 index 000000000..ba9837acd --- /dev/null +++ b/crates/smime/src/algorithms.rs @@ -0,0 +1,283 @@ +// SPDX-FileCopyrightText: MailCraft contributors +// SPDX-License-Identifier: MIT OR Apache-2.0 +//! The algorithms a Digital signature or a certificate is checked with (RFC 8551 §2, RFC 5754, +//! RFC 4055, RFC 5480): SHA-2 digests, RSA (PKCS #1 v1.5 and PSS, 2048 bits or more) and ECDSA +//! on P-256 and P-384. MD5, SHA-1 and shorter RSA keys are no longer safe and are refused as +//! such; anything else is unknown. The primitives are RustCrypto's; this only names them. + +use const_oid::ObjectIdentifier; +use der::{Decode, Encode}; +use sha2::Digest; +use spki::{AlgorithmIdentifierOwned, SubjectPublicKeyInfoOwned}; + +/// Why a signature didn't check out. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Fault { + /// It doesn't match: what it covers was changed, or another key made it. + Invalid, + /// It uses an algorithm that's no longer safe (MD5, SHA-1, RSA under 2048 bits). + Weak, + /// It uses an algorithm that isn't known here. + Unknown, + /// The key or the signature can't be read, or they are of different kinds: nothing can be + /// said of what it covers. + Malformed, +} + +/// The least RSA modulus, in bits, that is safe enough (RFC 8551 §6). +pub const MIN_RSA_BITS: usize = 2048; +/// The largest RSA modulus checked, in bits: a longer key takes too long to be worth it. +pub const MAX_RSA_BITS: usize = 8192; + +const fn oid(s: &str) -> ObjectIdentifier { + ObjectIdentifier::new_unwrap(s) +} + +// Digests. +const MD5: ObjectIdentifier = oid("1.2.840.113549.2.5"); +const SHA1: ObjectIdentifier = oid("1.3.14.3.2.26"); +const SHA224: ObjectIdentifier = oid("2.16.840.1.101.3.4.2.4"); +const SHA256: ObjectIdentifier = oid("2.16.840.1.101.3.4.2.1"); +const SHA384: ObjectIdentifier = oid("2.16.840.1.101.3.4.2.2"); +const SHA512: ObjectIdentifier = oid("2.16.840.1.101.3.4.2.3"); + +// RSA. +const RSA: ObjectIdentifier = oid("1.2.840.113549.1.1.1"); +const MD2_RSA: ObjectIdentifier = oid("1.2.840.113549.1.1.2"); +const MD5_RSA: ObjectIdentifier = oid("1.2.840.113549.1.1.4"); +const SHA1_RSA: ObjectIdentifier = oid("1.2.840.113549.1.1.5"); +const PSS: ObjectIdentifier = oid("1.2.840.113549.1.1.10"); +const SHA256_RSA: ObjectIdentifier = oid("1.2.840.113549.1.1.11"); +const SHA384_RSA: ObjectIdentifier = oid("1.2.840.113549.1.1.12"); +const SHA512_RSA: ObjectIdentifier = oid("1.2.840.113549.1.1.13"); +const SHA224_RSA: ObjectIdentifier = oid("1.2.840.113549.1.1.14"); +const MGF1: ObjectIdentifier = oid("1.2.840.113549.1.1.8"); + +/// The bits of an RSA modulus written big-endian. +fn modulus_bits(modulus: &[u8]) -> usize { + let mut significant = modulus.iter().skip_while(|b| **b == 0); + let top = significant.next().copied().unwrap_or(0); + significant.count().saturating_mul(8).saturating_add(8usize.saturating_sub(top.leading_zeros() as usize)) +} + +/// What kind of key `key` is: RSA of so many bits, ECDSA on P-256 or P-384, or another. +pub(crate) fn key_kind(key: &SubjectPublicKeyInfoOwned) -> crate::pkcs12::KeyKind { + use crate::pkcs12::KeyKind; + if key.algorithm.oid == RSA { + return key + .subject_public_key + .as_bytes() + .and_then(|b| pkcs1::RsaPublicKey::>::from_der(b).ok()) + .map_or(KeyKind::Other, |k| KeyKind::Rsa { bits: modulus_bits(k.modulus.as_bytes()) }); + } + if key.algorithm.oid == EC_KEY { + return match key.algorithm.parameters.as_ref().and_then(|p| p.decode_as::().ok()) { + Some(P256) => KeyKind::P256, + Some(P384) => KeyKind::P384, + _ => KeyKind::Other, + }; + } + KeyKind::Other +} + +/// What kind of private key a PKCS #8 `PrivateKeyInfo` holds, from its own algorithm identifier +/// (`algorithm`; for EC, its named `curve`, from the identifier's parameters or the key's own) +/// and, for RSA, its `modulus` (big-endian): never from a certificate that came with it. +pub(crate) fn private_key_kind(algorithm: ObjectIdentifier, curve: Option, modulus: Option<&[u8]>) -> crate::pkcs12::KeyKind { + use crate::pkcs12::KeyKind; + match (algorithm, curve, modulus) { + (RSA, _, Some(modulus)) => KeyKind::Rsa { bits: modulus_bits(modulus) }, + (EC_KEY, Some(P256), _) => KeyKind::P256, + (EC_KEY, Some(P384), _) => KeyKind::P384, + _ => KeyKind::Other, + } +} + +// ECDSA. +const EC_KEY: ObjectIdentifier = oid("1.2.840.10045.2.1"); +const SHA1_ECDSA: ObjectIdentifier = oid("1.2.840.10045.4.1"); +const SHA224_ECDSA: ObjectIdentifier = oid("1.2.840.10045.4.3.1"); +const SHA256_ECDSA: ObjectIdentifier = oid("1.2.840.10045.4.3.2"); +const SHA384_ECDSA: ObjectIdentifier = oid("1.2.840.10045.4.3.3"); +const SHA512_ECDSA: ObjectIdentifier = oid("1.2.840.10045.4.3.4"); +const P256: ObjectIdentifier = oid("1.2.840.10045.3.1.7"); +const P384: ObjectIdentifier = oid("1.3.132.0.34"); + +/// A digest algorithm that is safe to rely on. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Hash { + Sha224, + Sha256, + Sha384, + Sha512, +} + +impl Hash { + /// The digest a CMS `digestAlgorithm` names. + pub fn of(algorithm: &AlgorithmIdentifierOwned) -> Result { + Hash::by_oid(algorithm.oid) + } + + fn by_oid(oid: ObjectIdentifier) -> Result { + match oid { + SHA224 => Ok(Hash::Sha224), + SHA256 => Ok(Hash::Sha256), + SHA384 => Ok(Hash::Sha384), + SHA512 => Ok(Hash::Sha512), + MD5 | SHA1 => Err(Fault::Weak), + _ => Err(Fault::Unknown), + } + } + + /// The digest of `data`. + pub fn digest(self, data: &[u8]) -> Vec { + match self { + Hash::Sha224 => sha2::Sha224::digest(data).to_vec(), + Hash::Sha256 => sha2::Sha256::digest(data).to_vec(), + Hash::Sha384 => sha2::Sha384::digest(data).to_vec(), + Hash::Sha512 => sha2::Sha512::digest(data).to_vec(), + } + } +} + +/// How a signature is made. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +enum Scheme { + Pkcs1(Hash), + Pss(Hash, usize), + Ecdsa(Hash), +} + +/// The scheme `algorithm` names; `digest` is the CMS signer's digest algorithm, for the names +/// that leave the hash to it (`rsaEncryption`, `id-ecPublicKey`), `None` for a certificate. +fn scheme(algorithm: &AlgorithmIdentifierOwned, digest: Option) -> Result { + match algorithm.oid { + RSA => digest.map(Scheme::Pkcs1).ok_or(Fault::Unknown), + SHA224_RSA => Ok(Scheme::Pkcs1(Hash::Sha224)), + SHA256_RSA => Ok(Scheme::Pkcs1(Hash::Sha256)), + SHA384_RSA => Ok(Scheme::Pkcs1(Hash::Sha384)), + SHA512_RSA => Ok(Scheme::Pkcs1(Hash::Sha512)), + MD2_RSA | MD5_RSA | SHA1_RSA | SHA1_ECDSA => Err(Fault::Weak), + PSS => pss(algorithm), + EC_KEY => digest.map(Scheme::Ecdsa).ok_or(Fault::Unknown), + SHA224_ECDSA => Ok(Scheme::Ecdsa(Hash::Sha224)), + SHA256_ECDSA => Ok(Scheme::Ecdsa(Hash::Sha256)), + SHA384_ECDSA => Ok(Scheme::Ecdsa(Hash::Sha384)), + SHA512_ECDSA => Ok(Scheme::Ecdsa(Hash::Sha512)), + _ => Err(Fault::Unknown), + } +} + +/// RSASSA-PSS with its parameters (RFC 4055 §3.1): the hash, MGF1 with the same hash, and the +/// salt's length. Their defaults are SHA-1, which is no longer safe. +fn pss(algorithm: &AlgorithmIdentifierOwned) -> Result { + let params = algorithm.parameters.as_ref().ok_or(Fault::Weak)?; + let der = params.to_der().map_err(|_| Fault::Unknown)?; + let params = pkcs1::RsaPssParams::::from_der(&der).map_err(|_| Fault::Unknown)?; + let hash = Hash::by_oid(params.hash.oid)?; + if params.mask_gen.oid != MGF1 { + return Err(Fault::Unknown); + } + let mgf_hash = params.mask_gen.parameters.as_ref().map(|p| p.oid).ok_or(Fault::Weak)?; + if Hash::by_oid(mgf_hash)? != hash { + return Err(Fault::Unknown); + } + Ok(Scheme::Pss(hash, usize::from(params.salt_len))) +} + +/// Check `signature` over `data` with the key `key`, by `algorithm` (and `digest`, for a CMS +/// signer: see [`scheme`]). +pub fn verify( + key: &SubjectPublicKeyInfoOwned, + algorithm: &AlgorithmIdentifierOwned, + digest: Option, + data: &[u8], + signature: &[u8], +) -> Result<(), Fault> { + verify_hashed(key, algorithm, digest, &mut |hash| hash.digest(data), signature) +} + +/// [`verify`], with what was signed given by its digest: `hashed` gives it by each algorithm +/// (so that a long content is hashed once per algorithm however many keys are tried). +pub fn verify_hashed( + key: &SubjectPublicKeyInfoOwned, + algorithm: &AlgorithmIdentifierOwned, + digest: Option, + hashed: &mut dyn FnMut(Hash) -> Vec, + signature: &[u8], +) -> Result<(), Fault> { + // RFC 4055 3.3: an id-RSASSA-PSS SPKI restricts schemes and parameters. + // Those restrictions are not implemented here; do not treat it as rsaEncryption. + if key.algorithm.oid == PSS { + return Err(Fault::Unknown); + } + let scheme = scheme(algorithm, digest)?; + match scheme { + Scheme::Pkcs1(hash) | Scheme::Pss(hash, _) => { + if key.algorithm.oid != RSA { + return Err(Fault::Malformed); + } + let public = rsa_key(key)?; + let hashed = hashed(hash); + let checked = match scheme { + Scheme::Pss(_, salt) => match hash { + Hash::Sha224 => public.verify(rsa::pss::Pss::::new_with_salt(salt), &hashed, signature), + Hash::Sha256 => public.verify(rsa::pss::Pss::::new_with_salt(salt), &hashed, signature), + Hash::Sha384 => public.verify(rsa::pss::Pss::::new_with_salt(salt), &hashed, signature), + Hash::Sha512 => public.verify(rsa::pss::Pss::::new_with_salt(salt), &hashed, signature), + }, + _ => { + let padding = match hash { + Hash::Sha224 => rsa::Pkcs1v15Sign::new::(), + Hash::Sha256 => rsa::Pkcs1v15Sign::new::(), + Hash::Sha384 => rsa::Pkcs1v15Sign::new::(), + Hash::Sha512 => rsa::Pkcs1v15Sign::new::(), + }; + public.verify(padding, &hashed, signature) + } + }; + checked.map_err(|_| Fault::Invalid) + } + Scheme::Ecdsa(hash) => { + if key.algorithm.oid != EC_KEY { + return Err(Fault::Malformed); + } + let curve = key.algorithm.parameters.as_ref().and_then(|p| p.decode_as::().ok()).ok_or(Fault::Unknown)?; + let point = key.subject_public_key.as_bytes().ok_or(Fault::Unknown)?; + let hashed = hashed(hash); + use p256::ecdsa::signature::hazmat::PrehashVerifier; + match curve { + P256 => { + let key = p256::ecdsa::VerifyingKey::from_sec1_bytes(point).map_err(|_| Fault::Malformed)?; + let sig = p256::ecdsa::Signature::from_der(signature).map_err(|_| Fault::Malformed)?; + key.verify_prehash(&hashed, &sig).map_err(|_| Fault::Invalid) + } + P384 => { + let key = p384::ecdsa::VerifyingKey::from_sec1_bytes(point).map_err(|_| Fault::Malformed)?; + let sig = p384::ecdsa::Signature::from_der(signature).map_err(|_| Fault::Malformed)?; + key.verify_prehash(&hashed, &sig).map_err(|_| Fault::Invalid) + } + _ => Err(Fault::Unknown), + } + } + } +} + +/// The RSA key of `key`: [`Fault::Weak`] under [`MIN_RSA_BITS`], [`Fault::Unknown`] past what +/// the library takes (8192 bits) or when it can't be read. +fn rsa_key(key: &SubjectPublicKeyInfoOwned) -> Result { + let bits = key.subject_public_key.as_bytes().ok_or(Fault::Unknown)?; + let pkcs1 = pkcs1::RsaPublicKey::>::from_der(bits).map_err(|_| Fault::Unknown)?; + let bits = modulus_bits(pkcs1.modulus.as_bytes()); + if bits < MIN_RSA_BITS { + return Err(Fault::Weak); + } + if bits > MAX_RSA_BITS { + return Err(Fault::Unknown); + } + rsa::RsaPublicKey::new( + rsa::BoxedUint::from_be_slice_vartime(pkcs1.modulus.as_bytes()), + rsa::BoxedUint::from_be_slice_vartime(pkcs1.public_exponent.as_bytes()), + ) + .map_err(|_| Fault::Unknown) +} diff --git a/crates/smime/src/cert.rs b/crates/smime/src/cert.rs new file mode 100644 index 000000000..28968f27f --- /dev/null +++ b/crates/smime/src/cert.rs @@ -0,0 +1,448 @@ +// SPDX-FileCopyrightText: MailCraft contributors +// SPDX-License-Identifier: MIT OR Apache-2.0 +//! An X.509 certificate (RFC 5280) as a Digital signature is checked with: its bytes, what it +//! says, and the few questions asked of it (who it names, for what, until when, who signed it). + +use crate::Timestamp; +use crate::digital_signature::{MAX_SIGNER_ADDRESSES, signer_text}; +use const_oid::ObjectIdentifier; +use der::{Decode, Encode}; +use x509_cert::Certificate; +use x509_cert::ext::pkix::constraints::name::GeneralSubtrees; +use x509_cert::ext::pkix::name::GeneralName; +use x509_cert::ext::pkix::{ + AuthorityKeyIdentifier, BasicConstraints, CertificatePolicies, ExtendedKeyUsage, KeyUsage, NameConstraints, SubjectAltName, SubjectKeyIdentifier, +}; + +use crate::algorithms::{self, Fault}; +use craft_ber as ber; + +/// The largest certificate read. +pub const MAX_CERT_BYTES: usize = 64 * 1024; + +const EMAIL_PROTECTION: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.3.6.1.5.5.7.3.4"); +const ANY_EXTENDED_KEY_USAGE: ObjectIdentifier = ObjectIdentifier::new_unwrap("2.5.29.37.0"); +const EMAIL_ADDRESS: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.2.840.113549.1.9.1"); + +/// The extensions whose meaning is known here (RFC 5280 §4.2): a certificate with any other +/// marked critical is refused (§6.1.4 (o)). Certificate policies are taken as any policy (no +/// policy is asked for, §6.1.1 (c)); the identifiers say nothing to check. +const KNOWN: [ObjectIdentifier; 8] = [ + ObjectIdentifier::new_unwrap("2.5.29.14"), // subject key identifier + ObjectIdentifier::new_unwrap("2.5.29.15"), // key usage + ObjectIdentifier::new_unwrap("2.5.29.17"), // subject alternative name + ObjectIdentifier::new_unwrap("2.5.29.19"), // basic constraints + ObjectIdentifier::new_unwrap("2.5.29.30"), // name constraints + ObjectIdentifier::new_unwrap("2.5.29.32"), // certificate policies + ObjectIdentifier::new_unwrap("2.5.29.35"), // authority key identifier + ObjectIdentifier::new_unwrap("2.5.29.37"), // extended key usage +]; + +/// The name constraints a certification authority puts on what it vouches for (RFC 5280 +/// §4.2.1.10), for the two kinds of name a mail certificate has: mail addresses and directory +/// names. The other kinds name nothing that is checked here. +#[derive(Clone, Debug, Default)] +pub struct Constraints { + pub permitted_mail: Option>, + pub excluded_mail: Vec, + pub permitted_dirs: Option>>>, + pub excluded_dirs: Vec>>, +} + +/// A directory identity represented as ordered DER relative names. +pub type DirectoryName = Vec>; + +/// A certificate: its DER, the body its issuer signed, and what it says. +#[derive(Clone, Debug)] +pub struct Cert { + der: Vec, + /// Where the to-be-signed body is in `der`. + tbs: std::ops::Range, + parsed: Certificate, + subject: Vec, + issuer: Vec, +} + +impl PartialEq for Cert { + fn eq(&self, other: &Self) -> bool { + self.der == other.der + } +} + +impl Cert { + /// The certificate `der` is, when it is one. + pub fn from_der(der: &[u8]) -> Option { + if der.len() > MAX_CERT_BYTES { + return None; + } + let (outer, rest) = ber::read(der)?; + if !rest.is_empty() { + return None; + } + let (tbs, _) = ber::read(outer.value)?; + let start = outer.whole.len().checked_sub(outer.value.len())?; + let end = start.checked_add(tbs.whole.len())?; + let parsed = Certificate::from_der(der).ok()?; + // RFC 5280 4.1.1.2: the outer and signed algorithm identifiers must agree. + if parsed.signature_algorithm() != parsed.tbs_certificate().signature() { + return None; + } + // A recognized extension that cannot be decoded is not an absent extension. + // In particular, never fall back to the subject identity after a malformed SAN. + let tbs = parsed.tbs_certificate(); + if tbs.get_extension::().is_err() + || tbs.get_extension::().is_err() + || tbs.get_extension::().is_err() + || tbs.get_extension::().is_err() + || tbs.get_extension::().is_err() + || tbs.get_extension::().is_err() + || tbs.get_extension::().is_err() + || tbs.get_extension::().is_err() + { + return None; + } + let subject = parsed.tbs_certificate().subject().to_der().ok()?; + let issuer = parsed.tbs_certificate().issuer().to_der().ok()?; + Some(Cert { der: der.to_vec(), tbs: start..end, parsed, subject, issuer }) + } + + pub fn der(&self) -> &[u8] { + &self.der + } + + fn tbs(&self) -> &[u8] { + self.der.get(self.tbs.clone()).unwrap_or_default() + } + + pub fn subject(&self) -> &[u8] { + &self.subject + } + + pub fn issuer(&self) -> &[u8] { + &self.issuer + } + + /// The serial number's bytes. + pub fn serial(&self) -> &[u8] { + self.parsed.tbs_certificate().serial_number().as_bytes() + } + + /// The subject key identifier, when it has one. + pub fn key_id(&self) -> Option> { + let (_, ski) = self.parsed.tbs_certificate().get_extension::().ok()??; + Some(ski.0.as_bytes().to_vec()) + } + + pub fn public_key(&self) -> &spki::SubjectPublicKeyInfoOwned { + self.parsed.tbs_certificate().subject_public_key_info() + } + + /// Its SHA-256 fingerprint: upper-case hexadecimal pairs with colons between. + pub fn fingerprint(&self) -> String { + algorithms::Hash::Sha256.digest(&self.der).iter().map(|b| format!("{b:02X}")).collect::>().join(":") + } + + /// From and until when it is valid, in seconds since 1970. + pub fn validity(&self) -> (Timestamp, Timestamp) { + let v = self.parsed.tbs_certificate().validity(); + let secs = |t: &x509_cert::time::Time| Timestamp::try_from(t.to_unix_duration().as_secs()).unwrap_or(Timestamp::MAX); + (secs(&v.not_before), secs(&v.not_after)) + } + + /// Whether it is valid at `now`. + pub fn valid_at(&self, now: Timestamp) -> bool { + let (from, until) = self.validity(); + from <= now && now <= until + } + + /// The name it is for: its common name, else its whole name. + pub fn name(&self) -> String { + name_of(self.parsed.tbs_certificate().subject()) + } + + /// The name of who issued it. + pub fn issuer_name(&self) -> String { + name_of(self.parsed.tbs_certificate().issuer()) + } + + /// The mail addresses it is for: its subject alternative names of that kind, and an + /// `emailAddress` in its subject (RFC 8551 §3.1), at most [`MAX_SIGNER_ADDRESSES`]. + pub fn addresses(&self) -> Vec { + let mut out = Vec::new(); + if let Ok(Some((_, san))) = self.parsed.tbs_certificate().get_extension::() { + for name in san.0.iter() { + if let GeneralName::Rfc822Name(a) = name { + out.push(signer_text(a.as_str())); + } + } + } + for atv in self.parsed.tbs_certificate().subject().iter() { + if atv.oid == EMAIL_ADDRESS + && let Ok(a) = atv.value.decode_as::() + { + out.push(signer_text(a.as_str())); + } + } + out.retain(|a| !a.is_empty()); + out.dedup_by(|a, b| a.eq_ignore_ascii_case(b)); + out.truncate(MAX_SIGNER_ADDRESSES); + out + } + + /// The mail addresses it names, exactly as written (its alternative names of that kind and + /// the `emailAddress` in its subject), all of them: for comparing + /// and for name constraints, never for showing. The certificate byte cap bounds this list; display truncation + /// must not hide names from certification-authority constraints. + pub fn raw_addresses(&self) -> Vec { + let mut out = Vec::new(); + if let Ok(Some((_, san))) = self.parsed.tbs_certificate().get_extension::() { + out.extend(san.0.iter().filter_map(|n| match n { + GeneralName::Rfc822Name(a) => Some(a.as_str().to_string()), + _ => None, + })); + } + out.extend( + self.parsed + .tbs_certificate() + .subject() + .iter() + .filter(|atv| atv.oid == EMAIL_ADDRESS) + .filter_map(|atv| atv.value.decode_as::().ok()) + .map(|a| a.as_str().to_string()), + ); + out + } + + /// Whether it is for `address`: one of its addresses as written is that address, letter case + /// aside in plain ASCII (RFC 5280 §4.2.1.6, §7.5). An address with a space, a control or any + /// character past ASCII on either side never is. + pub fn is_for(&self, address: &str) -> bool { + printable(address) && self.raw_addresses().iter().any(|a| printable(a) && a.eq_ignore_ascii_case(address)) + } + + /// The address of its it is for `address` by ([`Cert::is_for`]), as it shows it. + pub fn address_for(&self, address: &str) -> Option { + printable(address).then(|| self.raw_addresses().into_iter().find(|a| printable(a) && a.eq_ignore_ascii_case(address))).flatten() + } + + /// Whether it carries an extension marked critical that isn't known here. + pub fn unknown_critical(&self) -> bool { + self.parsed.tbs_certificate().extensions().is_some_and(|exts| exts.iter().any(|e| e.critical && !KNOWN.contains(&e.extn_id))) + } + + /// Its path length constraint, when its basic constraints give one (unreadable: none + /// allowed below it). + pub fn path_len(&self) -> Option { + match self.parsed.tbs_certificate().get_extension::() { + Ok(Some((_, bc))) => bc.path_len_constraint, + Ok(None) => None, + Err(_) => Some(0), + } + } + + /// Whether, as a certification authority on a path, its extended key usage (when it has + /// one) lets it vouch for mail: email protection, or any use. + pub fn may_vouch_for_mail(&self) -> bool { + match self.parsed.tbs_certificate().get_extension::() { + Ok(Some((_, eku))) => eku.0.iter().any(|o| *o == EMAIL_PROTECTION || *o == ANY_EXTENDED_KEY_USAGE), + Ok(None) => true, + Err(_) => false, + } + } + + /// Whether it is a certification authority's by any sign (basic constraints say so, or its + /// key usage lets it sign certificates): never a mail signer's. + pub fn is_authority(&self) -> bool { + let tbs = self.parsed.tbs_certificate(); + let ca = matches!(tbs.get_extension::(), Ok(Some((_, bc))) if bc.ca); + let signs = matches!(tbs.get_extension::(), Ok(Some((_, ku))) if ku.key_cert_sign()); + ca || signs + } + + /// The name constraints it puts on what it vouches for; `Err` when they can't be read or use + /// what RFC 5280 says mustn't be (a minimum or a maximum). + pub fn constraints(&self) -> Result, ()> { + let Some((_, nc)) = self.parsed.tbs_certificate().get_extension::().map_err(|_| ())? else { return Ok(None) }; + let mut c = Constraints::default(); + if let Some(permitted) = &nc.permitted_subtrees { + let (mail, dirs) = subtrees(permitted)?; + c.permitted_mail = mail; + c.permitted_dirs = dirs; + } + if let Some(excluded) = &nc.excluded_subtrees { + let (mail, dirs) = subtrees(excluded)?; + c.excluded_mail = mail.unwrap_or_default(); + c.excluded_dirs = dirs.unwrap_or_default(); + } + Ok(Some(c)) + } + + /// Every directory identity: the nonempty subject and every directoryName SAN. + pub fn directory_names(&self) -> Option> { + let rdns = |name: &x509_cert::name::Name| name.iter_rdn().map(|r| r.to_der().ok()).collect::>>(); + let mut names = Vec::new(); + let subject = rdns(self.parsed.tbs_certificate().subject())?; + if !subject.is_empty() { + names.push(subject); + } + if let Some((_, san)) = self.parsed.tbs_certificate().get_extension::().ok()? { + for name in &san.0 { + if let GeneralName::DirectoryName(name) = name { + names.push(rdns(name)?); + } + } + } + Some(names) + } + + /// Whether it may be a certification authority's: basic constraints say so, and its key + /// usage, when it has one, lets it sign certificates. + pub fn is_ca(&self) -> bool { + let tbs = self.parsed.tbs_certificate(); + let ca = matches!(tbs.get_extension::(), Ok(Some((_, bc))) if bc.ca); + let signs = match tbs.get_extension::() { + Ok(Some((_, ku))) => ku.key_cert_sign(), + Ok(None) => true, + Err(_) => false, + }; + ca && signs + } + + /// Whether it is for signing mail (RFC 8551 §4.4): its key usage, when it has one, allows a + /// Digital signature or non-repudiation, and its extended key usage, when it has one, names + /// email protection (or any use). + pub fn for_email(&self) -> bool { + let tbs = self.parsed.tbs_certificate(); + let usage = match tbs.get_extension::() { + Ok(Some((_, ku))) => ku.digital_signature() || ku.non_repudiation(), + Ok(None) => true, + Err(_) => false, + }; + let extended = match tbs.get_extension::() { + Ok(Some((_, eku))) => eku.0.iter().any(|o| *o == EMAIL_PROTECTION || *o == ANY_EXTENDED_KEY_USAGE), + Ok(None) => true, + Err(_) => false, + }; + usage && extended + } + + /// Whether it is for mail at all, to sign it or to encrypt it (RFC 8551 §4.4): its key usage, + /// when it has one, allows a Digital signature, non-repudiation, key encipherment or key + /// agreement, and its extended key usage, when it has one, names email protection (or any + /// use). What a Public key imported for an address must be. + pub fn for_mail(&self) -> bool { + let tbs = self.parsed.tbs_certificate(); + let usage = match tbs.get_extension::() { + Ok(Some((_, ku))) => ku.digital_signature() || ku.non_repudiation() || ku.key_encipherment() || ku.key_agreement(), + Ok(None) => true, + Err(_) => false, + }; + usage && self.may_vouch_for_mail() + } + + /// Whether it names itself as its issuer. + pub fn self_issued(&self) -> bool { + self.subject == self.issuer + } + + /// Whether `issuer`'s key made its signature. + pub fn signed_by(&self, issuer: &Cert) -> Result<(), Fault> { + let signature = self.parsed.signature().as_bytes().ok_or(Fault::Invalid)?; + algorithms::verify(issuer.public_key(), self.parsed.signature_algorithm(), None, self.tbs(), signature) + } +} + +/// Whether `address` has only the printable ASCII an address is compared in (and something). +pub(crate) fn printable(address: &str) -> bool { + !address.is_empty() && address.bytes().all(|b| (0x21..=0x7e).contains(&b)) +} + +/// The mail and directory names of `subtrees` (`None` of a kind: none of that kind given). +type Subtrees = (Option>, Option>>>); + +fn subtrees(subtrees: &GeneralSubtrees) -> Result { + let (mut mail, mut dirs): Subtrees = (None, None); + for s in subtrees.iter().take(64) { + if s.minimum != 0 || s.maximum.is_some() { + return Err(()); + } + match &s.base { + GeneralName::Rfc822Name(a) => mail.get_or_insert_with(Vec::new).push(a.as_str().to_string()), + GeneralName::DirectoryName(n) => dirs.get_or_insert_with(Vec::new).push(n.iter_rdn().filter_map(|r| r.to_der().ok()).collect()), + // RFC 5280 4.2.1.10: constraints cannot be treated as processed when + // this validator does not implement their name form. Fail closed. + _ => return Err(()), + } + } + if subtrees.len() > 64 { + return Err(()); + } + Ok((mail, dirs)) +} + +/// Whether the mail address `address` is within the constraint `base` (RFC 5280 §4.2.1.10): a +/// whole address, every address at one host, or (with a leading dot) every address at any host +/// under a domain. Letter case aside. +pub fn mail_within(address: &str, base: &str) -> bool { + let address = address.to_ascii_lowercase(); + let base = base.to_ascii_lowercase(); + if base.contains('@') { + return address == base; + } + let Some((_, host)) = address.rsplit_once('@') else { return false }; + if let Some(domain) = base.strip_prefix('.') { + return host.len() > domain.len() && host.ends_with(domain) && host.as_bytes().get(host.len() - domain.len() - 1) == Some(&b'.'); + } + host == base +} + +/// Whether the name `rdns` is within the directory name `base`: it begins with all of it, each +/// relative name compared using the supported ASCII subset of RFC 5280 §7.1. +/// Unsupported string types or non-ASCII values must fail closed in the caller. +pub fn dir_within(rdns: &[Vec], base: &[Vec]) -> bool { + rdns.len() >= base.len() && rdns.iter().zip(base).all(|(a, b)| matches!((rdn_key(a), rdn_key(b)), (Some(x), Some(y)) if x == y)) +} + +/// Whether every relative name is within the supported comparison profile. +pub fn directory_supported(rdns: &[Vec]) -> bool { + rdns.iter().all(|rdn| rdn_key(rdn).is_some()) +} + +fn rdn_key(der: &[u8]) -> Option)>> { + use der::Tag; + let rdn = x509_cert::name::RelativeDistinguishedName::from_der(der).ok()?; + let mut key: Vec<(String, Vec)> = rdn + .iter() + .map(|atv| { + let value = match der::Tagged::tag(&atv.value) { + Tag::PrintableString | Tag::Utf8String => { + let text = std::str::from_utf8(atv.value.value()).ok()?; + // RFC 5280 7.1 requires StringPrep for non-ASCII names. Until the + // complete profile is implemented, constrained chains fail closed. + if !text.is_ascii() { + return None; + } + let folded: Vec = text.split_whitespace().map(str::to_lowercase).collect(); + let mut v = b"s".to_vec(); + v.extend_from_slice(folded.join(" ").as_bytes()); + v + } + _ => return None, + }; + Some((atv.oid.to_string(), value)) + }) + .collect::>()?; + key.sort(); + Some(key) +} + +/// A name for people: its common name, else the whole of it as RFC 4514 writes it. +fn name_of(name: &x509_cert::name::Name) -> String { + if let Ok(Some(cn)) = name.common_name() { + let cn = signer_text(&cn.value()); + if !cn.is_empty() { + return cn; + } + } + signer_text(&name.to_string()) +} diff --git a/crates/smime/src/chain.rs b/crates/smime/src/chain.rs new file mode 100644 index 000000000..81d52b71d --- /dev/null +++ b/crates/smime/src/chain.rs @@ -0,0 +1,232 @@ +// SPDX-FileCopyrightText: MailCraft contributors +// SPDX-License-Identifier: MIT OR Apache-2.0 +//! Whether a signer's certificate rests on a trust anchor (RFC 5280 §6, as S/MIME needs it): a +//! path from it through certification authorities' certificates that came with the message, to +//! a certificate the host trusts. Each link's signature is checked, and every certificate on the +//! path must be valid at the time of the check and keep its authorities' constraints. Bounded: a +//! path is at most [`MAX_PATH`] long, and the signatures checked come out of the message's +//! budget ([`crate::MAX_VERIFICATIONS`]). + +use std::collections::HashMap; + +use crate::Timestamp; +use crate::digital_signature::Why; + +use crate::algorithms::Fault; +use crate::cert::{Cert, Constraints, dir_within, directory_supported, mail_within}; + +/// The most certificates between a signer's and a trust anchor. +pub const MAX_PATH: usize = 6; +/// The most trust anchors kept. +pub const MAX_ANCHORS: usize = 4_000; + +/// The certificates the host trusts (the system's certification authorities, handed in: this +/// crate never reads a store of its own). +#[derive(Clone, Debug, Default)] +pub struct Anchors { + certs: Vec, + by_subject: HashMap, Vec>, +} + +impl Anchors { + /// Anchors from certificates in DER; one that isn't a certificate is left out, as is + /// everything past [`MAX_ANCHORS`]. + pub fn new(ders: I) -> Anchors + where + I: IntoIterator, + B: AsRef<[u8]>, + { + let mut anchors = Anchors::default(); + for der in ders { + if anchors.certs.len() >= MAX_ANCHORS { + break; + } + if let Some(cert) = Cert::from_der(der.as_ref()) { + anchors.by_subject.entry(cert.subject().to_vec()).or_default().push(anchors.certs.len()); + anchors.certs.push(cert); + } + } + anchors + } + + pub fn len(&self) -> usize { + self.certs.len() + } + + pub fn is_empty(&self) -> bool { + self.certs.is_empty() + } + + fn named(&self, subject: &[u8]) -> impl Iterator { + self.by_subject.get(subject).into_iter().flatten().filter_map(|i| self.certs.get(*i)) + } + + fn holds(&self, cert: &Cert) -> bool { + self.named(cert.subject()).any(|a| a == cert) + } +} + +/// Whether `leaf` rests on one of `anchors` through the certificates of `pool`, at `now`, +/// checking at most `budget` signatures (taken from it). Every path to an anchor is tried until +/// one holds (RFC 5280 §6.1): each certificate on it valid at `now`, none with a critical +/// extension not known here, each authority's path length and name constraints kept, and every +/// authority's extended key usage, when it has one, allowing mail. +/// +/// (Validity is checked at the time of the check, not the signing time the signer gives: that is +/// the signer's own word, and a certificate that ran out or was replaced since is said.) +pub fn trust(leaf: &Cert, pool: &[Cert], anchors: &Anchors, now: Timestamp, budget: &mut usize) -> Result<(), Why> { + let mut search = Search { leaf, pool, anchors, now, budget, weak: false, refused: None, ran_out: false }; + let mut path = Vec::new(); + if search.walk(leaf, &mut path) { + return Ok(()); + } + Err(match search.refused { + // (A path left untried may hold: no answer, rather than the first refusal's.) + _ if search.ran_out => Why::TooMuch, + Some(why) => why, + None if search.weak => Why::WeakAlgorithm, + None if leaf.self_issued() => Why::SelfSigned, + None => Why::UnknownIssuer, + }) +} + +struct Search<'a, 'b> { + leaf: &'a Cert, + pool: &'a [Cert], + anchors: &'a Anchors, + now: Timestamp, + budget: &'b mut usize, + /// A link was signed with an algorithm that's no longer safe. + weak: bool, + /// Why the first path found to an anchor didn't hold. + refused: Option, + /// The budget ran out before every path was tried. + ran_out: bool, +} + +impl<'a> Search<'a, '_> { + /// Whether `cert` rests on an anchor by a path that holds; `path` has the certificates above + /// the leaf so far, the anchor last once one is reached. + fn walk(&mut self, cert: &'a Cert, path: &mut Vec<&'a Cert>) -> bool { + // A certificate the host trusts itself ends the path, whether it holds or not. + if self.anchors.holds(cert) { + return self.holds(path); + } + for anchor in self.anchors.named(cert.issuer()) { + if self.signed(cert, anchor) { + path.push(anchor); + if self.holds(path) { + return true; + } + path.pop(); + } + } + if path.len() >= MAX_PATH { + return false; + } + for issuer in self.pool.iter().filter(|c| c.subject() == cert.issuer() && *c != cert && c.is_ca()) { + // (No certificate twice on a path.) + if path.contains(&issuer) || !self.signed(cert, issuer) { + continue; + } + path.push(issuer); + if self.walk(issuer, path) { + return true; + } + path.pop(); + } + false + } + + /// Whether the path from the leaf through `above` (the anchor last) holds; why not is kept. + fn holds(&mut self, above: &[&Cert]) -> bool { + let full: Vec<&Cert> = std::iter::once(self.leaf).chain(above.iter().copied()).collect(); + match judge(&full, self.now) { + Ok(()) => true, + Err(why) => { + self.refused.get_or_insert(why); + false + } + } + } + + fn signed(&mut self, cert: &Cert, by: &Cert) -> bool { + if *self.budget == 0 { + self.ran_out = true; + return false; + } + *self.budget -= 1; + match cert.signed_by(by) { + Ok(()) => true, + Err(Fault::Weak) => { + self.weak = true; + false + } + Err(_) => false, + } + } +} + +/// Whether the path `full` (the leaf first, the anchor last) holds at `now` (RFC 5280 §6.1). +pub(crate) fn judge(full: &[&Cert], now: Timestamp) -> Result<(), Why> { + if full.iter().any(|c| !c.valid_at(now)) { + return Err(Why::Expired); + } + // (The anchor is the host's to vouch for, extensions and all.) + let last = full.len().saturating_sub(1); + if full.iter().take(last).any(|c| c.unknown_critical()) { + return Err(Why::Constrained); + } + for (k, ca) in full.iter().enumerate().skip(1) { + if !ca.may_vouch_for_mail() { + return Err(Why::Constrained); + } + // The certificates below it that count: the leaf, and every authority's not issued by + // itself (§6.1.4 (l), §6.1.3 (b)). + let below: Vec<&Cert> = full.iter().take(k).enumerate().filter(|(j, c)| *j == 0 || !c.self_issued()).map(|(_, c)| *c).collect(); + if let Some(n) = ca.path_len() + && below.len().saturating_sub(1) > usize::from(n) + { + return Err(Why::Constrained); + } + let Ok(constraints) = ca.constraints() else { return Err(Why::Constrained) }; + if let Some(c) = constraints + && !below.iter().all(|cert| within(cert, &c)) + { + return Err(Why::Constrained); + } + } + Ok(()) +} + +/// Whether the names of `cert` are within `c`. +fn within(cert: &Cert, c: &Constraints) -> bool { + let mail = cert.raw_addresses(); + if let Some(permitted) = &c.permitted_mail + && !mail.iter().all(|a| permitted.iter().any(|p| mail_within(a, p))) + { + return false; + } + if mail.iter().any(|a| c.excluded_mail.iter().any(|e| mail_within(a, e))) { + return false; + } + // Unsupported normalization must not make an excluded subtree look different. + if c.permitted_dirs.is_none() && c.excluded_dirs.is_empty() { + return true; + } + let Some(names) = cert.directory_names() else { return false }; + if !names.iter().all(|name| directory_supported(name)) + || !c.excluded_dirs.iter().all(|name| directory_supported(name)) + || c.permitted_dirs.as_ref().is_some_and(|names| !names.iter().all(|name| directory_supported(name))) + { + return false; + } + names.iter().all(|rdns| { + if let Some(permitted) = &c.permitted_dirs + && !permitted.iter().any(|p| dir_within(rdns, p)) + { + return false; + } + !c.excluded_dirs.iter().any(|e| dir_within(rdns, e)) + }) +} diff --git a/crates/smime/src/digital_signature.rs b/crates/smime/src/digital_signature.rs new file mode 100644 index 000000000..19bb572f7 --- /dev/null +++ b/crates/smime/src/digital_signature.rs @@ -0,0 +1,277 @@ +// SPDX-FileCopyrightText: MailCraft contributors +// SPDX-License-Identifier: MIT OR Apache-2.0 +//! What checking a message's Digital signature found (#30), whichever format it is in: S/MIME +//! (`craft-smime`) or OpenPGP. One of four results ([`Verdict`]), why when it isn't the +//! first ([`Why`]), and what is known of who signed it ([`Signer`]). Worked out from the bytes the +//! message came as, in memory, and never written to the mailbox file: it is checked again when +//! the message is next looked at, against the trust and the clock of that moment. + +use serde::{Deserialize, Serialize}; + +use crate::Timestamp; + +/// The format of a Digital signature. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub enum SignatureFormat { + /// S/MIME (RFC 8551): CMS signed data and an X.509 certificate. + Smime, + /// OpenPGP (RFC 9580), as PGP/MIME (RFC 3156) or inline. + OpenPgp, +} + +impl SignatureFormat { + pub fn as_str(self) -> &'static str { + match self { + SignatureFormat::Smime => "smime", + SignatureFormat::OpenPgp => "openpgp", + } + } +} + +/// The four results a check has, best first. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub enum Verdict { + /// The Digital signature is valid, its signer is trusted, the signer's address is the + /// message's one From address (verified is for that signer and that address together, never + /// for a key alone), and what was signed is the whole message ([`Coverage::Whole`]). + Verified, + /// The Digital signature is valid, but its signer isn't verified ([`Why`] says how): an + /// unknown issuer, a certificate out of date or not for mail, an address that isn't the From + /// address, an OpenPGP key nobody marked verified. + NotVerified, + /// The message was changed after it was signed: what is shown isn't what was signed. + Changed, + /// The Digital signature can't be checked ([`Why`] says why): an algorithm that's no longer + /// safe or isn't known, no Public key, or a signature that can't be read. + Unchecked, +} + +impl Verdict { + /// Its name for an agent and a script: `verified`, `notVerified`, `changed`, `unchecked`. + pub fn as_str(self) -> &'static str { + match self { + Verdict::Verified => "verified", + Verdict::NotVerified => "notVerified", + Verdict::Changed => "changed", + Verdict::Unchecked => "unchecked", + } + } + + /// The better of two results ([`Verdict::Verified`] best): of several signers of one + /// message, the best one stands. + pub fn best(self, other: Verdict) -> Verdict { + self.min(other) + } +} + +/// Why a check found less than [`Verdict::Verified`]. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub enum Why { + // Not verified. + /// The certificate wasn't issued by a certification authority this computer trusts. + UnknownIssuer, + /// The certificate signed itself, and isn't one this computer trusts. + SelfSigned, + /// The certificate, or one of those it rests on, is out of date (or not valid yet). + Expired, + /// The certificate isn't for signing mail (its key usage or extended key usage say so). + NotForEmail, + /// The certificate is for another address than the message's From address. + AddressMismatch, + /// An authority on the way to a trusted one doesn't allow the certificate to be used this + /// way: a name outside what it may vouch for, a path too long, a use it doesn't allow, or a + /// critical extension not known here (RFC 5280 §4.2, §6.1). + Constrained, + /// No certification authorities for mail could be read on this computer, so no signer can be + /// verified here. + NoAuthorities, + /// This computer's certification authorities haven't been read yet (they are read at start): + /// the check is made again when they are. + AuthoritiesNotRead, + /// An OpenPGP key that the owner hasn't marked Verified. + KeyNotVerified, + /// Only part of the message was signed (a wrapper such as a list's footer holds it), so + /// what is outside that part could say anything. + PartlySigned, + // Changed. + /// What was signed isn't what arrived. + Altered, + // Can't be checked. + /// It uses an algorithm that's no longer safe (MD5, SHA-1, a short RSA key). + WeakAlgorithm, + /// It uses an algorithm MailCraft doesn't know. + UnknownAlgorithm, + /// The signer's Public key (certificate) isn't in the message or kept here. + NoPublicKey, + /// The signer's OpenPGP key was revoked by its owner, for when the message was signed. + KeyRevoked, + /// The signer's OpenPGP key had expired when the message was signed. + KeyExpired, + /// The OpenPGP key that made it isn't one that may sign. + NotASigningKey, + /// The Digital signature itself has expired (it said until when it holds). + SignatureExpired, + /// The Digital signature can't be read. + Unreadable, + /// The bytes the message came as aren't here (it was read before they were kept): Check + /// again downloads them. + NoOriginal, + /// There is more to check than a message is allowed (many certificates, or many ways to a + /// trusted authority): it was stopped before an answer. + TooMuch, +} + +impl Why { + /// Its name for an agent and a script. + pub fn as_str(self) -> &'static str { + match self { + Why::UnknownIssuer => "unknownIssuer", + Why::SelfSigned => "selfSigned", + Why::Expired => "expired", + Why::NotForEmail => "notForEmail", + Why::AddressMismatch => "addressMismatch", + Why::Constrained => "constrained", + Why::NoAuthorities => "noAuthorities", + Why::AuthoritiesNotRead => "authoritiesNotRead", + Why::KeyNotVerified => "keyNotVerified", + Why::PartlySigned => "partlySigned", + Why::Altered => "altered", + Why::WeakAlgorithm => "weakAlgorithm", + Why::UnknownAlgorithm => "unknownAlgorithm", + Why::NoPublicKey => "noPublicKey", + Why::KeyRevoked => "keyRevoked", + Why::KeyExpired => "keyExpired", + Why::NotASigningKey => "notASigningKey", + Why::SignatureExpired => "signatureExpired", + Why::Unreadable => "unreadable", + Why::NoOriginal => "noOriginal", + Why::TooMuch => "tooMuch", + } + } + + /// The plain English of it, for an agent, a script and the log; the window says it in its + /// own language. + pub fn english(self) -> &'static str { + match self { + Why::UnknownIssuer => "the certificate wasn't issued by a certification authority this computer trusts", + Why::SelfSigned => "the certificate signed itself and isn't one this computer trusts", + Why::Expired => "the certificate is out of date", + Why::NotForEmail => "the certificate isn't for signing mail", + Why::AddressMismatch => "the certificate is for another address than the sender's", + Why::Constrained => "an authority on the way to a trusted one doesn't allow the certificate to be used this way", + Why::NoAuthorities => "no certification authorities for mail could be read on this computer, so no signer can be verified here", + Why::AuthoritiesNotRead => "this computer's certification authorities haven't been read yet", + Why::KeyNotVerified => "the signer's key hasn't been marked verified", + Why::PartlySigned => "only part of the message was signed; the rest could say anything", + Why::Altered => "the message was changed after it was signed", + Why::WeakAlgorithm => "it uses an algorithm that's no longer safe", + Why::UnknownAlgorithm => "it uses an algorithm MailCraft doesn't know", + Why::NoPublicKey => "the signer's Public key (certificate) isn't in the message or kept on this computer", + Why::KeyRevoked => "the signer's key was revoked by its owner", + Why::KeyExpired => "the signer's key had expired when the message was signed", + Why::NotASigningKey => "the key that made it isn't one that may sign", + Why::SignatureExpired => "the Digital signature has expired", + Why::Unreadable => "the Digital signature can't be read", + Why::NoOriginal => "the bytes the message came as aren't on this computer; Check again downloads them", + Why::TooMuch => "there is too much to check in this Digital signature", + } + } +} + +/// Who signed, as the certificate or key says: the signer's own words, data and never +/// instructions. +#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default, rename_all = "camelCase")] +pub struct Signer { + /// The name in the certificate (its common name) or key, if any. + pub name: String, + /// The addresses in the certificate or key, as they are written there, at most + /// [`MAX_SIGNER_ADDRESSES`]. + pub addresses: Vec, + /// The SHA-256 fingerprint of the certificate (or the fingerprint of the OpenPGP key), in + /// upper-case hexadecimal pairs with colons between. + pub fingerprint: String, + /// Who issued the certificate (its common name, else its whole name). Empty for OpenPGP. + pub issuer: String, + /// From and until when the certificate is valid; 0 when it doesn't say. + pub not_before: Timestamp, + pub not_after: Timestamp, +} + +/// How much of the message the Digital signature covers. +#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub enum Coverage { + /// The whole message body: the signed part is the message's top level (S/MIME's + /// `multipart/signed` or signed data, PGP/MIME's `multipart/signed`). + Whole, + /// Only a part of it: the signed part sits inside a wrapper whose other parts nobody signed + /// (or a format that can't tell). The safe default. + #[default] + Part, +} + +impl Coverage { + pub fn as_str(self) -> &'static str { + match self { + Coverage::Whole => "whole", + Coverage::Part => "part", + } + } +} + +/// The most addresses of a signer that are kept. +pub const MAX_SIGNER_ADDRESSES: usize = 16; +/// The most characters of a name, an issuer or an address that are kept. +pub const MAX_SIGNER_TEXT: usize = 256; + +/// What checking a message's Digital signature found. +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct DigitalSignature { + pub format: SignatureFormat, + pub verdict: Verdict, + /// Why it is less than verified; `None` when it is verified. + pub why: Option, + /// Who signed, when the signer's certificate or key was found. + pub signer: Option, + /// When the signer says they signed it (S/MIME's signing time): the signer's word, not + /// checked by anybody. + pub signed_at: Option, + /// Whether the certificate was checked against its issuer's list of revoked certificates. + /// Never yet (#30 R7): the details say "Revocation not checked". + pub revocation_checked: bool, + /// How much of the message was signed; set with [`DigitalSignature::covering`]. + #[serde(default)] + pub coverage: Coverage, +} + +impl DigitalSignature { + /// A result of `verdict` for `why`, with nothing known of the signer. + pub fn bare(format: SignatureFormat, verdict: Verdict, why: Why) -> DigitalSignature { + DigitalSignature { format, verdict, why: Some(why), signer: None, signed_at: None, revocation_checked: false, coverage: Coverage::Part } + } + + /// This result for a signature that covers `coverage` of the message: a valid signature by a + /// trusted signer over only part of it is [`Verdict::NotVerified`] ([`Why::PartlySigned`]), + /// never verified for the message. Either format's checker ends with it. + pub fn covering(mut self, coverage: Coverage) -> DigitalSignature { + self.coverage = coverage; + if coverage == Coverage::Part && self.verdict == Verdict::Verified { + self.verdict = Verdict::NotVerified; + self.why = Some(Why::PartlySigned); + } + self + } +} + +/// `text` (a name or address from a certificate) as a name coming in is kept +/// ([`crate::names::incoming`]): one line, without control or format characters (no +/// reordering by a bidirectional override, nothing hidden by a zero-width one), at most +/// [`MAX_SIGNER_TEXT`] characters. +pub fn signer_text(text: &str) -> String { + crate::names::incoming(text, MAX_SIGNER_TEXT).unwrap_or_default() +} diff --git a/crates/smime/src/import.rs b/crates/smime/src/import.rs new file mode 100644 index 000000000..216cfaa92 --- /dev/null +++ b/crates/smime/src/import.rs @@ -0,0 +1,171 @@ +// SPDX-FileCopyrightText: MailCraft contributors +// SPDX-License-Identifier: MIT OR Apache-2.0 +//! Certificates read from a file the owner imports as Public keys (#30): DER or PEM, what each +//! one is for, and whether the file holds a private key instead (which is never a Public key +//! to import, and goes through File › Options › Security in the window). No I/O; the file is +//! hostile: sizes and counts are capped, and nothing here panics on any bytes. + +use crate::Timestamp; +use base64::Engine as _; +use craft_ber as ber; + +use crate::cert::{Cert, MAX_CERT_BYTES, printable}; + +/// The most certificates read from one file. +pub const MAX_IMPORT_CERTIFICATES: usize = 16; +/// The most addresses a certificate is kept for. +const MAX_ADDRESSES: usize = 16; + +/// What a certificate to import says of itself. +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CertificateInfo { + /// The certificate, in DER. + pub der: Vec, + /// Its SHA-256 fingerprint, as a Digital signature's details have it. + pub fingerprint: String, + /// The mail addresses it is for (subject alternative names, and an `emailAddress` in its + /// subject), in lower case: plain ASCII only, as a signer's address is compared. + pub addresses: Vec, + /// Until when it is valid. + pub not_after: Timestamp, + /// Whether it is for mail ([`Cert::for_mail`]). + pub for_mail: bool, + /// Whether it is a certification authority's. + pub authority: bool, + /// Who it is for (its subject's common name, else its whole subject), cleaned. + pub name: String, + /// Who issued it (the issuer's common name, else its whole name), cleaned. + pub issuer: String, +} + +/// What the certificate `der` says of itself; `None` when it isn't one. +pub fn certificate_info(der: &[u8]) -> Option { + let cert = Cert::from_der(der)?; + let mut addresses: Vec = Vec::new(); + for a in cert.raw_addresses() { + let a = a.to_ascii_lowercase(); + if printable(&a) && a.contains('@') && !addresses.contains(&a) && addresses.len() < MAX_ADDRESSES { + addresses.push(a); + } + } + Some(CertificateInfo { + der: cert.der().to_vec(), + fingerprint: cert.fingerprint(), + addresses, + not_after: cert.validity().1, + for_mail: cert.for_mail(), + authority: cert.is_authority(), + name: cert.name(), + issuer: cert.issuer_name(), + }) +} + +/// The certificates in `bytes`: PEM `CERTIFICATE` blocks (as many as there are, at most +/// [`MAX_IMPORT_CERTIFICATES`]), else one certificate in DER (or BER). Empty when there is none. +pub fn certificates_in(bytes: &[u8]) -> Vec> { + let blocks = pem_blocks(bytes, "CERTIFICATE"); + if !blocks.is_empty() { + return blocks.into_iter().filter(|b| Cert::from_der(b).is_some()).take(MAX_IMPORT_CERTIFICATES).collect(); + } + if bytes.len() > MAX_CERT_BYTES { + return Vec::new(); + } + match ber::to_der(bytes) { + Some(der) if Cert::from_der(&der).is_some() => vec![der], + _ => Vec::new(), + } +} + +/// The decoded bodies of the PEM blocks labelled `label` in `bytes` (RFC 7468), each at most a +/// certificate's size, at most [`MAX_IMPORT_CERTIFICATES`]. +fn pem_blocks(bytes: &[u8], label: &str) -> Vec> { + let text = String::from_utf8_lossy(bytes); + let begin = format!("-----BEGIN {label}-----"); + let end = format!("-----END {label}-----"); + let mut out = Vec::new(); + let mut body: Option = None; + for line in text.lines() { + let line = line.trim(); + match body.as_mut() { + None if line == begin => body = Some(String::new()), + None => {} + Some(b) if line == end => { + if let Ok(der) = base64::engine::general_purpose::STANDARD.decode(b.as_bytes()) + && der.len() <= MAX_CERT_BYTES + { + out.push(der); + } + body = None; + if out.len() >= MAX_IMPORT_CERTIFICATES { + break; + } + } + Some(b) => { + // (A header line of RFC 1421's kind is no base64: such a block won't decode.) + if !append_pem_line(b, line) { + body = None; + } + } + } + } + out +} + +/// Whether `bytes` hold a private key in a form S/MIME's tools write: a PEM block of any kind of +/// `PRIVATE KEY` (PKCS #8, encrypted or not, PKCS #1, SEC 1, OpenSSH, OpenPGP's armour too), a +/// PKCS #12 file, or a PKCS #8, PKCS #1 or SEC 1 key in DER. +pub fn holds_private_key(bytes: &[u8]) -> bool { + let text = String::from_utf8_lossy(bytes.get(..bytes.len().min(crate::pkcs12::MAX_P12_LEN)).unwrap_or_default()); + if text.lines().any(|l| { + let l = l.trim(); + l.starts_with("-----BEGIN ") && l.contains("PRIVATE KEY") + }) { + return true; + } + if crate::pkcs12::looks_like(bytes) { + return true; + } + let Some(der) = ber::to_der(bytes.get(..bytes.len().min(crate::pkcs12::MAX_P12_LEN)).unwrap_or_default()) else { return false }; + let Some((outer, _)) = ber::read(&der) else { return false }; + if outer.tag != 0x30 { + return false; + } + let Some(fields) = ber::children(outer.value) else { return false }; + let tags: Vec = fields.iter().map(|f| f.tag).collect(); + let first_int = |v: &[u8]| fields.first().is_some_and(|f| f.tag == 0x02 && f.value == v); + // PKCS #8 PrivateKeyInfo / OneAsymmetricKey: version, algorithm, the key in an OCTET STRING. + let pkcs8 = matches!(tags.as_slice(), [0x02, 0x30, 0x04, ..]) && (first_int(&[0]) || first_int(&[1])); + // EncryptedPrivateKeyInfo: algorithm, the encrypted key. + let encrypted = matches!(tags.as_slice(), [0x30, 0x04]); + // PKCS #1 RSAPrivateKey: version 0 and eight INTEGERs. + let rsa = tags.len() >= 9 && tags.iter().take(9).all(|t| *t == 0x02) && first_int(&[0]); + // SEC 1 ECPrivateKey: version 1, the key in an OCTET STRING. + let ec = matches!(tags.as_slice(), [0x02, 0x04, ..]) && first_int(&[1]); + pkcs8 || encrypted || rsa || ec +} + +// Check the prospective length before allocation, including a single oversized line. +fn append_pem_line(body: &mut String, line: &str) -> bool { + if body.len().checked_add(line.len()).is_none_or(|len| len > MAX_CERT_BYTES.saturating_mul(2)) { + return false; + } + body.push_str(line); + true +} + +#[cfg(test)] +mod bounded_pem_tests { + use super::*; + + #[test] + fn oversized_pem_lines_are_refused_before_accumulation() { + let cap = MAX_CERT_BYTES * 2; + let mut body = String::new(); + assert!(!append_pem_line(&mut body, &"A".repeat(cap + 1))); + assert!(body.is_empty()); + assert!(append_pem_line(&mut body, &"A".repeat(cap - 1))); + assert!(append_pem_line(&mut body, "A")); + assert!(!append_pem_line(&mut body, "A")); + assert_eq!(body.len(), cap); + } +} diff --git a/crates/smime/src/import_tests.rs b/crates/smime/src/import_tests.rs new file mode 100644 index 000000000..2865dcbf3 --- /dev/null +++ b/crates/smime/src/import_tests.rs @@ -0,0 +1,74 @@ +// SPDX-FileCopyrightText: MailCraft contributors +// SPDX-License-Identifier: MIT OR Apache-2.0 +//! Certificates read for import, and private keys told apart (#30). The certificates are those +//! of `pkcs12_tests` (synthetic `example.org` people under a test authority), and one made for a +//! web server with Bob's key. + +use base64::Engine as _; +use proptest::prelude::*; + +use crate::import::{certificate_info, certificates_in, holds_private_key}; +use crate::pkcs12_tests::{ALICE_PEM, CA_PEM, MODERN}; + +/// Bob's key, certified for `www.example.org` and for serving the web only. +pub(crate) const SERVER_PEM: &str = "-----BEGIN CERTIFICATE-----\nMIICeTCCAWGgAwIBAgITBZjuab1kWRuw6iskHm6GfE5XsDANBgkqhkiG9w0BAQsF\nADAsMRgwFgYDVQQDDA9FeGFtcGxlIFRlc3QgQ0ExEDAOBgNVBAoMB0V4YW1wbGUw\nIBcNMjYxMTEwMjM1NzM0WhgPMjEyNjEwMTcyMzU3MzRaMBYxFDASBgNVBAMMC0Jv\nYiBFeGFtcGxlMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVMGX6KffvBxXYqhk\nGl7wd0hrcjrtj18zbj1rN23ToDZ6d+Iy3rQQZvU5gCfqoP/scGZ9K377DvfqOzR8\n8VGPoKNzMHEwGgYDVR0RBBMwEYIPd3d3LmV4YW1wbGUub3JnMBMGA1UdJQQMMAoG\nCCsGAQUFBwMBMB0GA1UdDgQWBBQNf+WUyk2rA7Ol2+DplbqCmjDuOTAfBgNVHSME\nGDAWgBQDV2BK6ZYA5LKhPQiiQ98tSGv7JjANBgkqhkiG9w0BAQsFAAOCAQEAUlZu\nif7xv5ZXlsWt0KX458+G2vekBcqdE3UD21hTvJ9tbCrnfIuXa9pigZsYUzqV5Xwt\npaXU+7JedPYNZs0qqk2nPw+VULsxBNhaKre5V+v4tdHxq16MTsAalT6GfeOtX8+G\nZ5CwUqqe5SW9kkUi0QnaR/BDZuTKIOKKBCJ4AEOmi9cbDWUQiKkQRR4mEQH7wAJM\nfBXlNb7YHRikSE/ZHAjsLKNwSEpOsKnKav8KxPy/moR+emB9AFIHAsGjmPTMNhdG\nQ5DrRP3eAtKBGCrFGOj+JSxXW4O2eqKGuMHy7fLrCD2st7qBv4Lm7lEw1SDsXAQ/\nx1BBQKVBaJYfE2pKOA==\n-----END CERTIFICATE-----\n"; + +#[test] +fn certificates_are_read_from_pem_and_der() { + let both = format!("{ALICE_PEM}{CA_PEM}"); + let read = certificates_in(both.as_bytes()); + assert_eq!(read.len(), 2); + assert_eq!(certificates_in(&read[0]), vec![read[0].clone()], "DER"); + assert!(certificates_in(b"no certificate").is_empty()); + assert!(certificates_in(b"").is_empty()); +} + +#[test] +fn what_a_certificate_is_for_is_told() { + let alice = certificate_info(&certificates_in(ALICE_PEM.as_bytes())[0]).unwrap(); + assert_eq!(alice.addresses, vec!["alice@example.org".to_string()], "its alternative name and its subject's address, once"); + assert!(alice.for_mail); + assert!(!alice.authority); + assert_eq!(alice.fingerprint, "10:33:B4:36:A1:40:16:60:4A:21:D5:BC:F3:B1:69:38:60:22:DF:01:85:71:8D:BC:F5:BB:63:4B:09:CB:AA:FC"); + assert!(alice.not_after > 4_000_000_000); + let server = certificate_info(&certificates_in(SERVER_PEM.as_bytes())[0]).unwrap(); + assert!(!server.for_mail, "for the web only"); + assert!(server.addresses.is_empty()); + let ca = certificate_info(&certificates_in(CA_PEM.as_bytes())[0]).unwrap(); + assert!(ca.authority); + assert!(certificate_info(b"junk").is_none()); +} + +#[test] +fn a_private_key_in_any_form_is_told() { + for label in ["PRIVATE KEY", "ENCRYPTED PRIVATE KEY", "RSA PRIVATE KEY", "EC PRIVATE KEY", "OPENSSH PRIVATE KEY", "PGP PRIVATE KEY BLOCK"] { + let pem = format!("-----BEGIN {label}-----\nAAAA\n-----END {label}-----\n"); + assert!(holds_private_key(pem.as_bytes()), "{label}"); + } + assert!(holds_private_key(&base64::engine::general_purpose::STANDARD.decode(MODERN).unwrap()), "a PKCS #12 file"); + // PKCS #8: version 0, an algorithm, the key in an OCTET STRING. + let pkcs8 = [0x30, 0x0b, 0x02, 0x01, 0x00, 0x30, 0x03, 0x06, 0x01, 0x2a, 0x04, 0x01, 0x00]; + assert!(holds_private_key(&pkcs8)); + // EncryptedPrivateKeyInfo. + assert!(holds_private_key(&[0x30, 0x08, 0x30, 0x03, 0x06, 0x01, 0x2a, 0x04, 0x01, 0x00])); + // SEC 1: version 1, the key. + assert!(holds_private_key(&[0x30, 0x06, 0x02, 0x01, 0x01, 0x04, 0x01, 0x07])); + // PKCS #1: nine INTEGERs, the first 0. + let mut rsa = vec![0x30, 27]; + for _ in 0..9 { + rsa.extend_from_slice(&[0x02, 0x01, 0x00]); + } + assert!(holds_private_key(&rsa)); + for public in [ALICE_PEM.as_bytes(), &certificates_in(ALICE_PEM.as_bytes())[0], b"-----BEGIN PGP PUBLIC KEY BLOCK-----", b""] { + assert!(!holds_private_key(public)); + } +} + +proptest! { + #[test] + fn any_bytes_are_read_without_a_panic(bytes in proptest::collection::vec(any::(), 0..2048)) { + let _ = certificates_in(&bytes); + let _ = certificate_info(&bytes); + let _ = holds_private_key(&bytes); + } +} diff --git a/crates/smime/src/lib.rs b/crates/smime/src/lib.rs new file mode 100644 index 000000000..d9b534389 --- /dev/null +++ b/crates/smime/src/lib.rs @@ -0,0 +1,55 @@ +// SPDX-FileCopyrightText: MailCraft contributors +// SPDX-License-Identifier: MIT OR Apache-2.0 +//! MailCraft's S/MIME (RFC 8551): Digital signatures checked (#30), written from the public +//! specifications (RFC 5652 for CMS, RFC 5280 for X.509, RFC 5754, RFC 4055 and RFC 5480 for +//! the algorithms). No I/O: the host hands in the certificates it trusts ([`Anchors`]), the +//! message's halves come from `mailcraft-mime`, and the result is +//! [`crate::digital_signature::DigitalSignature`], which OpenPGP shares. +//! +//! [`check`] reads the CMS SignedData of a detached or an opaque Digital signature, finds the +//! signer's certificate, compares the signer's digest with the message's, checks the signature +//! (RSA PKCS #1 v1.5 or PSS of 2048 bits or more, ECDSA on P-256 or P-384, over SHA-2), and then +//! whether the certificate rests on a trust anchor, is for signing mail and is for the From +//! address. MD5 and SHA-1 are no longer safe and are said to be. Revocation isn't checked. +//! +//! Directory-name constraints currently support ASCII PrintableString/UTF8String names. +//! Constrained chains requiring other string profiles are refused, not approximately matched. +//! Opaque CMS content is verified as exact octets; only detached transport text permits LF repair. +//! +//! Input is hostile: BER is turned into DER with nesting bounded, every length is checked +//! against what is there, the certificates, signers and the path to an anchor are capped, and +//! nothing here panics on any bytes. +#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)] +#![cfg_attr(not(test), deny(clippy::indexing_slicing))] + +/// Seconds since the Unix epoch, UTC. +pub type Timestamp = i64; + +mod algorithms; +mod cert; +mod chain; +pub mod digital_signature; +pub mod import; +mod names; +pub mod pkcs12; +mod verify; + +#[cfg(test)] +#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)] +mod import_tests; +#[cfg(test)] +#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)] +mod pkcs12_tests; +#[cfg(test)] +#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)] +mod tests; + +pub use chain::{Anchors, MAX_ANCHORS}; +pub use verify::{Checked, Context, MAX_CERTS, MAX_SIGNERS, MAX_VERIFICATIONS, Signed, check}; + +/// The fingerprint and addresses of a certificate in DER, as a Digital signature's details show +/// them: `None` when it isn't one. +pub fn certificate_summary(der: &[u8]) -> Option<(String, Vec, crate::Timestamp)> { + let cert = cert::Cert::from_der(der)?; + Some((cert.fingerprint(), cert.addresses(), cert.validity().1)) +} diff --git a/crates/smime/src/names.rs b/crates/smime/src/names.rs new file mode 100644 index 000000000..f0ad2bad5 --- /dev/null +++ b/crates/smime/src/names.rs @@ -0,0 +1,128 @@ +// SPDX-FileCopyrightText: MailCraft contributors +// SPDX-License-Identifier: MIT OR Apache-2.0 +//! Bounded certificate display-name sanitization extracted from MailCraft. + +/// Whether `c` is one of Unicode's format characters (general category Cf, Unicode 17.0): the +/// soft hyphen, the Arabic number signs and end-of-ayah marks, the Syriac abbreviation mark, the +/// Arabic pound and piastre marks above, the Mongolian vowel separator, zero-width marks and +/// joiners, bidirectional marks, embeddings, overrides and isolates, the word joiner and +/// invisible operators, the deprecated shaping controls, the byte-order mark, interlinear +/// annotations, the Kaithi number signs, the Egyptian hieroglyph, shorthand and musical format +/// controls, and tags. +pub fn is_format(c: char) -> bool { + matches!( + c, + '\u{00ad}' + | '\u{0600}'..='\u{0605}' + | '\u{061c}' + | '\u{06dd}' + | '\u{070f}' + | '\u{0890}'..='\u{0891}' + | '\u{08e2}' + | '\u{180e}' + | '\u{200b}'..='\u{200f}' + | '\u{202a}'..='\u{202e}' + | '\u{2060}'..='\u{2064}' + | '\u{2066}'..='\u{206f}' + | '\u{feff}' + | '\u{fff9}'..='\u{fffb}' + | '\u{110bd}' + | '\u{110cd}' + | '\u{13430}'..='\u{1343f}' + | '\u{1bca0}'..='\u{1bca3}' + | '\u{1d173}'..='\u{1d17a}' + | '\u{e0001}' + | '\u{e0020}'..='\u{e007f}' + ) +} + +/// Whether `c` is the zero-width non-joiner or joiner (U+200C, U+200D): format characters that +/// are part of a word where they stand inside one. +pub fn is_joiner(c: char) -> bool { + matches!(c, '\u{200c}' | '\u{200d}') +} + +/// A name as it is kept: one line (a line break, a tab or any other white space parts words, and +/// words are parted by one space), without control characters or the characters Unicode marks as +/// showing nothing (a joiner inside a word and one variation selector after a character stay), +/// trimmed, at most `max` characters. `None` when nothing is left. +pub fn incoming(text: &str, max: usize) -> Option { + let (name, _) = clean(text, max); + (!name.is_empty()).then_some(name) +} + +/// Whether `c` is one of the rest of Unicode's default-ignorable code points +/// (`Default_Ignorable_Code_Point`, Unicode 17.0, less the format characters and the variation +/// selectors): the combining grapheme joiner, the Hangul fillers, the Khmer inherent vowels, and +/// the code points Unicode keeps for more characters that show nothing. +fn is_ignorable(c: char) -> bool { + matches!( + c, + '\u{034f}' + | '\u{115f}'..='\u{1160}' + | '\u{17b4}'..='\u{17b5}' + | '\u{2065}' + | '\u{3164}' + | '\u{ffa0}' + | '\u{fff0}'..='\u{fff8}' + | '\u{e0000}' + | '\u{e0002}'..='\u{e001f}' + | '\u{e0080}'..='\u{e00ff}' + | '\u{e01f0}'..='\u{e0fff}' + ) +} + +/// Whether `c` is a variation selector (`Variation_Selector`, Unicode 17.0): it picks how the +/// character before it is drawn. +fn is_selector(c: char) -> bool { + matches!(c, '\u{180b}'..='\u{180d}' | '\u{180f}' | '\u{fe00}'..='\u{fe0f}' | '\u{e0100}'..='\u{e01ef}') +} + +/// The braille pattern blank: a symbol to Unicode, and in braille the space between words. +const BRAILLE_BLANK: char = '\u{2800}'; + +/// `text` cleaned and cut to at most `max` characters, and whether something was left out for +/// the length. Nothing past it is read. +fn clean(text: &str, max: usize) -> (String, bool) { + let mut out = String::new(); + let mut count = 0usize; + // A space between words, and a joiner inside one, come only with the character after them. + let mut space = false; + let mut joiner: Option = None; + // Whether the last character written shows, so that a variation selector may follow it. + let mut selectable = false; + for c in text.chars() { + if is_joiner(c) { + if count > 0 && !space { + joiner = Some(c); + } + } else if c.is_whitespace() || c == BRAILLE_BLANK { + space = count > 0; + joiner = None; + } else if is_selector(c) { + if selectable && !space && joiner.is_none() { + if count >= max { + return (out, true); + } + out.push(c); + count = count.saturating_add(1); + selectable = false; + } + } else if !c.is_control() && !is_format(c) && !is_ignorable(c) { + let needed = 1 + usize::from(space) + usize::from(joiner.is_some()); + if count.saturating_add(needed) > max { + return (out, true); + } + if std::mem::take(&mut space) { + out.push(' '); + } + if let Some(j) = joiner.take() { + out.push(j); + } + out.push(c); + count = count.saturating_add(needed); + selectable = true; + } + } + (out, false) +} diff --git a/crates/smime/src/pkcs12.rs b/crates/smime/src/pkcs12.rs new file mode 100644 index 000000000..753a26dfb --- /dev/null +++ b/crates/smime/src/pkcs12.rs @@ -0,0 +1,794 @@ +// SPDX-FileCopyrightText: MailCraft contributors +// SPDX-License-Identifier: MIT OR Apache-2.0 +//! A PKCS #12 file (`.p12`, `.pfx`; RFC 7292) opened with its passphrase (#30 R13): the +//! certificate and private key an owner's IT department hands out, for the window to put in the +//! system's credential store. No I/O, and nothing kept: what is opened goes back to the caller, +//! the private key in memory that is wiped when it is let go of. +//! +//! The file is believed only when its MAC checks with the passphrase (RFC 7292 §5.1, the +//! password-integrity mode, HMAC with SHA-1 or SHA-2 keyed by the PKCS #12 key derivation of +//! Appendix B): a file without one, or with a public-key integrity mode, is refused, and a MAC +//! that doesn't check is a wrong passphrase. The bags may be encrypted with PBES2 (RFC 8018: +//! PBKDF2 with HMAC-SHA-1 or SHA-2, and AES-128/192/256-CBC or 3DES-CBC) or with the old +//! pbeWithSHAAnd3-KeyTripleDES-CBC (RFC 7292 Appendix C); RC2, RC4, two-key 3DES, DES and the +//! 40-bit schemes are no longer safe and are refused. +//! +//! The file is hostile: its size, the bags, their nesting and every iteration count (and their +//! sum) are capped, lengths are checked against what is there, and nothing here panics on any +//! bytes. The cryptography is RustCrypto's (`pkcs12`'s key derivation, `pbkdf2`, `hmac`, `sha1`, +//! `sha2`, `aes`, `des`, `cbc`); only the layout is read here. + +use aes::cipher::block_padding::Pkcs7; +use aes::cipher::{BlockModeDecrypt, KeyIvInit}; +use const_oid::ObjectIdentifier; +use craft_ber::{self as ber, Tlv}; +use der::Decode; +use hmac::{KeyInit, Mac}; +use zeroize::Zeroizing; + +/// The largest file opened (the window reads at most as much). +pub const MAX_P12_LEN: usize = 1 << 20; +/// The most bags read, in all. +pub const MAX_BAGS: usize = 64; +/// The most iterations one key derivation may ask for: past it the file is refused as +/// unreasonable rather than spent time on. +pub const MAX_ITERATIONS: u64 = 1_000_000; +/// The most iterations every key derivation of one file may ask for together. +const MAX_TOTAL_ITERATIONS: u64 = 8_000_000; +/// How deep safe-contents bags may nest in each other. +const MAX_NESTING: usize = 4; +/// The most certificates kept from one file. +const MAX_CERTIFICATES: usize = 32; + +const DATA: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.2.840.113549.1.7.1"); +const ENCRYPTED_DATA: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.2.840.113549.1.7.6"); +const KEY_BAG: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.2.840.113549.1.12.10.1.1"); +const SHROUDED_KEY_BAG: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.2.840.113549.1.12.10.1.2"); +const CERT_BAG: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.2.840.113549.1.12.10.1.3"); +const SAFE_CONTENTS_BAG: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.2.840.113549.1.12.10.1.6"); +const X509_CERTIFICATE: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.2.840.113549.1.9.22.1"); +const LOCAL_KEY_ID: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.2.840.113549.1.9.21"); + +const SHA1: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.3.14.3.2.26"); +const SHA256: ObjectIdentifier = ObjectIdentifier::new_unwrap("2.16.840.1.101.3.4.2.1"); +const SHA384: ObjectIdentifier = ObjectIdentifier::new_unwrap("2.16.840.1.101.3.4.2.2"); +const SHA512: ObjectIdentifier = ObjectIdentifier::new_unwrap("2.16.840.1.101.3.4.2.3"); + +const PBES2: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.2.840.113549.1.5.13"); +const PBKDF2: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.2.840.113549.1.5.12"); +const HMAC_SHA1: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.2.840.113549.2.7"); +const HMAC_SHA256: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.2.840.113549.2.9"); +const HMAC_SHA384: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.2.840.113549.2.10"); +const HMAC_SHA512: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.2.840.113549.2.11"); +const AES128_CBC: ObjectIdentifier = ObjectIdentifier::new_unwrap("2.16.840.1.101.3.4.1.2"); +const AES192_CBC: ObjectIdentifier = ObjectIdentifier::new_unwrap("2.16.840.1.101.3.4.1.22"); +const AES256_CBC: ObjectIdentifier = ObjectIdentifier::new_unwrap("2.16.840.1.101.3.4.1.42"); +const DES_EDE3_CBC: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.2.840.113549.3.7"); +const SHA_3DES: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.2.840.113549.1.12.1.3"); +/// The PKCS #12 schemes that are no longer safe (RC4, two-key 3DES, RC2), and PKCS #5 v1.5's +/// (DES and RC2 with MD2, MD5 or SHA-1). +const WEAK: [&str; 11] = [ + "1.2.840.113549.1.12.1.1", + "1.2.840.113549.1.12.1.2", + "1.2.840.113549.1.12.1.4", + "1.2.840.113549.1.12.1.5", + "1.2.840.113549.1.12.1.6", + "1.2.840.113549.1.5.1", + "1.2.840.113549.1.5.3", + "1.2.840.113549.1.5.4", + "1.2.840.113549.1.5.6", + "1.2.840.113549.1.5.10", + "1.2.840.113549.1.5.11", +]; + +/// Why a PKCS #12 file couldn't be opened. +#[derive(Clone, Copy, Debug, PartialEq, Eq, thiserror::Error)] +pub enum Error { + /// Larger than any such file is. + #[error("the file is larger than a certificate file can be")] + TooLarge, + /// Not a PKCS #12 file, or a damaged one. + #[error("the file isn't a certificate file (.p12 or .pfx) that can be read")] + Unreadable, + /// It has no MAC with a passphrase: nothing vouches that it is as it was made. + #[error("the file isn't protected with a passphrase, so nothing vouches for it")] + NoMac, + /// The MAC doesn't check: the passphrase is wrong (or the file was changed). + #[error("the passphrase is wrong")] + WrongPassphrase, + /// It is encrypted with a scheme that is no longer safe (RC2, RC4, DES, 40-bit keys). + #[error("the file is encrypted in a way that is no longer safe (RC2, RC4, DES or 40-bit keys); export it again with AES")] + WeakEncryption, + /// It uses an algorithm this program doesn't know. + #[error("the file uses an algorithm MailCraft doesn't know")] + UnknownAlgorithm, + /// It asks for more iterations than any file needs, or more bags or nesting than there is room for. + #[error("the file asks for more work than a certificate file needs")] + Unreasonable, + /// It holds no private key, or more than one. + #[error("the file holds no private key, or more than one")] + NoPrivateKey, + /// It holds no certificate for its private key. + #[error("the file holds no certificate for its private key")] + NoCertificate, +} + +/// What a PKCS #12 file holds, opened. +pub struct Opened { + /// The certificate of the private key, in DER: the one whose public key is the key's, else + /// the one with the key's local key id. + pub certificate: Vec, + /// The other certificates (the authorities on the way to a trusted one), in DER. + pub others: Vec>, + /// The private key as PKCS #8 `PrivateKeyInfo` in DER, wiped when let go of. + pub private_key: Zeroizing>, + /// What kind of key the private key is, read from its own PKCS #8 algorithm identifier (and + /// curve): whether it may be used here. The certificate is of the same kind. + pub key_kind: KeyKind, + /// Whether the private key was encrypted in the file (a shrouded key bag, or a bag in an + /// encrypted safe), and not merely vouched for by the MAC: a key in a plain key bag of a + /// plain safe is in the file in clear. + pub key_encrypted: bool, +} + +/// What kind of key a certificate holds. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum KeyKind { + /// RSA, with a modulus of so many bits. + Rsa { bits: usize }, + /// ECDSA on NIST P-256. + P256, + /// ECDSA on NIST P-384. + P384, + /// Any other. + Other, +} + +impl std::fmt::Debug for Opened { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("Opened") + .field("certificate", &self.certificate.len()) + .field("others", &self.others.len()) + .field("private_key", &"[redacted]") + .field("key_kind", &self.key_kind) + .field("key_encrypted", &self.key_encrypted) + .finish() + } +} + +/// Whether `bytes` look like a PKCS #12 file (a version 3 PFX), without opening it: so that a +/// private key is never taken for a Public key to import. +pub fn looks_like(bytes: &[u8]) -> bool { + let Some(der) = ber::to_der(bytes.get(..bytes.len().min(MAX_P12_LEN)).unwrap_or_default()).map(Zeroizing::new) else { return false }; + let Some((pfx, _)) = ber::read(&der) else { return false }; + let Some(fields) = ber::children(pfx.value) else { return false }; + matches!(fields.as_slice(), [version, info, ..] if version.tag == 0x02 && version.value == [3] && info.tag == 0x30) +} + +/// Open the PKCS #12 file `p12` with `passphrase`. +pub fn open(p12: &[u8], passphrase: &str) -> Result { + if p12.len() > MAX_P12_LEN { + return Err(Error::TooLarge); + } + let der = Zeroizing::new(ber::to_der(p12).ok_or(Error::Unreadable)?); + let (pfx, rest) = ber::read(&der).ok_or(Error::Unreadable)?; + if pfx.tag != 0x30 || !rest.is_empty() { + return Err(Error::Unreadable); + } + let fields = ber::children(pfx.value).ok_or(Error::Unreadable)?; + let (version, auth_safe, mac) = match fields.as_slice() { + [v, a, m] => (v, a, Some(m)), + [v, a] => (v, a, None), + _ => return Err(Error::Unreadable), + }; + if version.tag != 0x02 || version.value != [3] { + return Err(Error::Unreadable); + } + let mut work = Work { iterations: 0, bags: 0 }; + // Only the password-integrity mode: the authenticated safe is data, and the MAC is over it. + let (content_type, content) = content_info(auth_safe)?; + if content_type != DATA { + return Err(Error::NoMac); + } + let safe = Zeroizing::new(octets(content)?); + let mac = mac.ok_or(Error::NoMac)?; + let legacy_password = check_mac(mac, &safe, passphrase, &mut work)?; + let safe = Zeroizing::new(ber::to_der(&safe).ok_or(Error::Unreadable)?); + let mut found = Found::default(); + let (list, rest) = ber::read(&safe).ok_or(Error::Unreadable)?; + if list.tag != 0x30 || !rest.is_empty() { + return Err(Error::Unreadable); + } + for info in ber::children(list.value).ok_or(Error::Unreadable)? { + let (kind, content) = content_info(&info)?; + let (contents, encrypted) = if kind == DATA { + (Zeroizing::new(octets(content)?), false) + } else if kind == ENCRYPTED_DATA { + (encrypted_data(content, passphrase, &legacy_password, &mut work)?, true) + } else { + // (Enveloped data, which needs a key of the owner's to open: not a file to import.) + return Err(Error::UnknownAlgorithm); + }; + safe_contents(&contents, Safe { passphrase, legacy_password: &legacy_password, encrypted, depth: 0 }, &mut work, &mut found)?; + } + found.finish() +} + +/// What opening costs so far. +struct Work { + iterations: u64, + bags: usize, +} + +impl Work { + /// Count a key derivation of `iterations`: refused past the caps. + fn derive(&mut self, iterations: u64) -> Result<(), Error> { + if iterations == 0 || iterations > MAX_ITERATIONS { + return Err(Error::Unreasonable); + } + self.iterations = self.iterations.saturating_add(iterations); + if self.iterations > MAX_TOTAL_ITERATIONS { Err(Error::Unreasonable) } else { Ok(()) } + } +} + +/// A private-key bag and whether it was encrypted. +struct KeyBag { + key: Zeroizing>, + encrypted: bool, +} + +/// The bags found. +#[derive(Default)] +struct Found { + /// Each private key and whether it was encrypted in the file. + keys: Vec, + certificates: Vec<(Vec, Option>)>, +} + +impl Found { + /// Pair only by verified public key, never by untrusted bag metadata. + fn finish(mut self) -> Result { + let KeyBag { key, encrypted: key_encrypted } = match self.keys.len() { + 1 => self.keys.pop().ok_or(Error::NoPrivateKey)?, + _ => return Err(Error::NoPrivateKey), + }; + let key_kind = private_key_kind(&key); + let kind_of = |c: &[u8]| crate::cert::Cert::from_der(c).map_or(KeyKind::Other, |c| crate::algorithms::key_kind(c.public_key())); + let public = public_of(&key); + let by_key = public.as_ref().and_then(|p| self.certificates.iter().position(|(c, _)| certificate_key(c).as_ref() == Some(p))); + // localKeyId is untrusted metadata, not proof of key ownership. + let at = by_key.ok_or(Error::NoCertificate)?; + let (certificate, _) = self.certificates.remove(at); + if kind_of(&certificate) != key_kind { + return Err(Error::NoCertificate); + } + Ok(Opened { certificate, others: self.certificates.into_iter().map(|(c, _)| c).collect(), private_key: key, key_kind, key_encrypted }) + } +} + +/// What kind of key a PKCS #8 `PrivateKeyInfo` is, by its own algorithm identifier: RSA by its +/// modulus, EC by its named curve (the identifier's parameters, else the `ECPrivateKey`'s own). +fn private_key_kind(pkcs8: &[u8]) -> KeyKind { + let read = || -> Option { + let (info, _) = ber::read(pkcs8)?; + let fields = ber::children(info.value)?; + let [_, alg, key, ..] = fields.as_slice() else { return None }; + if key.tag != 0x04 { + return None; + } + let (oid, params) = algorithm(alg).ok()?; + let (inner, _) = ber::read(key.value)?; + let parts = ber::children(inner.value)?; + let curve_of = |t: &Tlv<'_>| oid_of(t).ok(); + let curve = params.as_ref().and_then(curve_of).or_else(|| { + // ECPrivateKey (RFC 5915): [0] parameters, a named curve. + let explicit = parts.iter().find(|p| p.tag == 0xa0)?; + let (named, _) = ber::read(explicit.value)?; + curve_of(&named) + }); + // RSAPrivateKey (RFC 8017 A.1.2): version, modulus, … + let modulus = parts.get(1).filter(|n| n.tag == 0x02).map(|n| n.value); + Some(crate::algorithms::private_key_kind(oid, curve, modulus)) + }; + read().unwrap_or(KeyKind::Other) +} + +/// A ContentInfo's type and content (inside its `[0] EXPLICIT`). +fn content_info<'a>(info: &Tlv<'a>) -> Result<(ObjectIdentifier, Tlv<'a>), Error> { + if info.tag != 0x30 { + return Err(Error::Unreadable); + } + let fields = ber::children(info.value).ok_or(Error::Unreadable)?; + let [oid, explicit] = fields.as_slice() else { return Err(Error::Unreadable) }; + if explicit.tag != 0xa0 { + return Err(Error::Unreadable); + } + let (content, rest) = ber::read(explicit.value).ok_or(Error::Unreadable)?; + if !rest.is_empty() { + return Err(Error::Unreadable); + } + Ok((oid_of(oid)?, content)) +} + +fn oid_of(tlv: &Tlv<'_>) -> Result { + if tlv.tag != 0x06 { + return Err(Error::Unreadable); + } + ObjectIdentifier::from_der(tlv.whole).map_err(|_| Error::Unreadable) +} + +/// An OCTET STRING's octets: in one piece, or (BER) in pieces under a constructed tag. +fn octets(tlv: Tlv<'_>) -> Result, Error> { + match tlv.tag { + 0x04 | 0x80 => Ok(tlv.value.to_vec()), + 0x24 | 0xa0 => { + let mut out = Vec::new(); + for piece in ber::children(tlv.value).ok_or(Error::Unreadable)? { + if piece.tag != 0x04 { + return Err(Error::Unreadable); + } + out.extend_from_slice(piece.value); + } + Ok(out) + } + _ => Err(Error::Unreadable), + } +} + +/// An INTEGER that fits, not negative. +fn uint(tlv: &Tlv<'_>) -> Result { + if tlv.tag != 0x02 || tlv.value.is_empty() || tlv.value.len() > 9 || tlv.value.first().is_some_and(|b| b & 0x80 != 0) { + return Err(Error::Unreasonable); + } + let digits = tlv.value.strip_prefix(&[0]).unwrap_or(tlv.value); + if digits.len() > 8 { + return Err(Error::Unreasonable); + } + Ok(digits.iter().fold(0u64, |acc, d| (acc << 8) | u64::from(*d))) +} + +/// An AlgorithmIdentifier: its OID and its parameters, if any. +fn algorithm<'a>(tlv: &Tlv<'a>) -> Result<(ObjectIdentifier, Option>), Error> { + if tlv.tag != 0x30 { + return Err(Error::Unreadable); + } + let fields = ber::children(tlv.value).ok_or(Error::Unreadable)?; + match fields.as_slice() { + [oid] => Ok((oid_of(oid)?, None)), + [oid, params] => Ok((oid_of(oid)?, (params.tag != 0x05).then_some(*params))), + _ => Err(Error::Unreadable), + } +} + +/// The hashes a MAC or a key derivation is made with. +#[derive(Clone, Copy)] +enum Hash { + Sha1, + Sha256, + Sha384, + Sha512, +} + +impl Hash { + fn digest(oid: ObjectIdentifier) -> Result { + Ok(match oid { + SHA1 => Hash::Sha1, + SHA256 => Hash::Sha256, + SHA384 => Hash::Sha384, + SHA512 => Hash::Sha512, + _ => return Err(Error::UnknownAlgorithm), + }) + } + + fn hmac(oid: ObjectIdentifier) -> Result { + Ok(match oid { + HMAC_SHA1 => Hash::Sha1, + HMAC_SHA256 => Hash::Sha256, + HMAC_SHA384 => Hash::Sha384, + HMAC_SHA512 => Hash::Sha512, + _ => return Err(Error::UnknownAlgorithm), + }) + } + + fn len(self) -> usize { + match self { + Hash::Sha1 => 20, + Hash::Sha256 => 32, + Hash::Sha384 => 48, + Hash::Sha512 => 64, + } + } + + /// The PKCS #12 key derivation (RFC 7292 Appendix B.2) of `len` bytes for `purpose`. + fn pkcs12_kdf(self, password: &[u8], salt: &[u8], purpose: Purpose, iterations: u64, len: usize) -> Result>, Error> { + use pkcs12::kdf::{Pkcs12KeyType, derive_key}; + let id = match purpose { + Purpose::Key => Pkcs12KeyType::EncryptionKey, + Purpose::Iv => Pkcs12KeyType::Iv, + Purpose::Mac => Pkcs12KeyType::Mac, + }; + let rounds = i32::try_from(iterations).map_err(|_| Error::Unreasonable)?; + let out = match self { + Hash::Sha1 => derive_key::(password, salt, id, rounds, len), + Hash::Sha256 => derive_key::(password, salt, id, rounds, len), + Hash::Sha384 => derive_key::(password, salt, id, rounds, len), + Hash::Sha512 => derive_key::(password, salt, id, rounds, len), + }; + out.map(Zeroizing::new).map_err(|_| Error::Unreadable) + } + + /// Whether the HMAC of `data` under `key` is `tag`, in constant time. + fn hmac_checks(self, key: &[u8], data: &[u8], tag: &[u8]) -> bool { + fn check(key: &[u8], data: &[u8], tag: &[u8]) -> bool { + match ::new_from_slice(key) { + Ok(mut mac) => { + mac.update(data); + mac.verify_slice(tag).is_ok() + } + Err(_) => false, + } + } + match self { + Hash::Sha1 => check::>(key, data, tag), + Hash::Sha256 => check::>(key, data, tag), + Hash::Sha384 => check::>(key, data, tag), + Hash::Sha512 => check::>(key, data, tag), + } + } + + fn pbkdf2(self, password: &[u8], salt: &[u8], iterations: u32, out: &mut [u8]) { + match self { + Hash::Sha1 => pbkdf2::pbkdf2_hmac::(password, salt, iterations, out), + Hash::Sha256 => pbkdf2::pbkdf2_hmac::(password, salt, iterations, out), + Hash::Sha384 => pbkdf2::pbkdf2_hmac::(password, salt, iterations, out), + Hash::Sha512 => pbkdf2::pbkdf2_hmac::(password, salt, iterations, out), + } + } +} + +#[derive(Clone, Copy)] +enum Purpose { + Key, + Iv, + Mac, +} + +/// The passphrase as the PKCS #12 key derivation takes it (RFC 7292 Appendix B.1): a BMPString, +/// two bytes to a character, ended by two zero bytes. `None` for a character outside the BMP. +fn bmp(passphrase: &str) -> Option>> { + let mut out = Zeroizing::new(Vec::with_capacity(passphrase.len().saturating_mul(2).saturating_add(2))); + for c in passphrase.chars() { + let unit = u16::try_from(u32::from(c)).ok()?; + out.extend_from_slice(&unit.to_be_bytes()); + } + out.extend_from_slice(&[0, 0]); + Some(out) +} + +/// The forms of the passphrase a file may have been made with: the BMPString, and for an empty +/// one also nothing at all (which some writers use). +fn passwords(passphrase: &str) -> Vec>> { + let mut out: Vec>> = bmp(passphrase).into_iter().collect(); + if passphrase.is_empty() { + out.push(Zeroizing::new(Vec::new())); + } + out +} + +/// Check the file's MAC (RFC 7292 §5.1, Appendix B.4) over `safe`. +fn check_mac(mac: &Tlv<'_>, safe: &[u8], passphrase: &str, work: &mut Work) -> Result>, Error> { + if mac.tag != 0x30 { + return Err(Error::Unreadable); + } + let fields = ber::children(mac.value).ok_or(Error::Unreadable)?; + let (digest_info, salt, iterations) = match fields.as_slice() { + [d, s] => (d, s, 1), + [d, s, i] => (d, s, uint(i)?), + _ => return Err(Error::Unreadable), + }; + if digest_info.tag != 0x30 || salt.tag != 0x04 { + return Err(Error::Unreadable); + } + let parts = ber::children(digest_info.value).ok_or(Error::Unreadable)?; + let [alg, digest] = parts.as_slice() else { return Err(Error::Unreadable) }; + if digest.tag != 0x04 { + return Err(Error::Unreadable); + } + let (oid, _) = algorithm(alg)?; + let hash = Hash::digest(oid)?; + if digest.value.len() != hash.len() { + return Err(Error::Unreadable); + } + for password in passwords(passphrase) { + work.derive(iterations)?; + let key = hash.pkcs12_kdf(&password, salt.value, Purpose::Mac, iterations, hash.len())?; + if hash.hmac_checks(&key, safe, digest.value) { + return Ok(password); + } + } + Err(Error::WrongPassphrase) +} + +/// The contents of an EncryptedData (RFC 5652 §8), decrypted. +fn encrypted_data(content: Tlv<'_>, passphrase: &str, legacy_password: &[u8], work: &mut Work) -> Result>, Error> { + if content.tag != 0x30 { + return Err(Error::Unreadable); + } + let fields = ber::children(content.value).ok_or(Error::Unreadable)?; + let info = fields.get(1).ok_or(Error::Unreadable)?; + if info.tag != 0x30 { + return Err(Error::Unreadable); + } + let parts = ber::children(info.value).ok_or(Error::Unreadable)?; + let [kind, alg, encrypted] = parts.as_slice() else { return Err(Error::Unreadable) }; + if oid_of(kind)? != DATA { + return Err(Error::Unreadable); + } + let ciphertext = octets(*encrypted)?; + decrypt(alg, &ciphertext, passphrase, legacy_password, work) +} + +/// `ciphertext` decrypted with the passphrase as the algorithm identifier `alg` says. +fn decrypt(alg: &Tlv<'_>, ciphertext: &[u8], passphrase: &str, legacy_password: &[u8], work: &mut Work) -> Result>, Error> { + let (oid, params) = algorithm(alg)?; + if WEAK.iter().any(|w| oid.to_string() == *w) { + return Err(Error::WeakEncryption); + } + let params = params.ok_or(Error::Unreadable)?; + if oid == SHA_3DES { + // RFC 7292 Appendix C: pkcs-12PbeParams, the key and IV from the PKCS #12 derivation. + let fields = ber::children(params.value).ok_or(Error::Unreadable)?; + let [salt, iterations] = fields.as_slice() else { return Err(Error::Unreadable) }; + if salt.tag != 0x04 { + return Err(Error::Unreadable); + } + let iterations = uint(iterations)?; + // Reuse the exact representation authenticated by the MAC, including empty bytes. + let password = legacy_password; + work.derive(iterations)?; + let key = Hash::Sha1.pkcs12_kdf(password, salt.value, Purpose::Key, iterations, 24)?; + work.derive(iterations)?; + let iv = Hash::Sha1.pkcs12_kdf(password, salt.value, Purpose::Iv, iterations, 8)?; + return cbc_decrypt::(&key, &iv, ciphertext); + } + if oid != PBES2 { + return Err(Error::UnknownAlgorithm); + } + let fields = ber::children(params.value).ok_or(Error::Unreadable)?; + let [kdf, scheme] = fields.as_slice() else { return Err(Error::Unreadable) }; + let (kdf_oid, kdf_params) = algorithm(kdf)?; + if kdf_oid != PBKDF2 { + return Err(Error::UnknownAlgorithm); + } + let kdf_fields = ber::children(kdf_params.ok_or(Error::Unreadable)?.value).ok_or(Error::Unreadable)?; + let mut kdf_fields = kdf_fields.iter(); + let salt = kdf_fields.next().filter(|s| s.tag == 0x04).ok_or(Error::UnknownAlgorithm)?; + let iterations = uint(kdf_fields.next().ok_or(Error::Unreadable)?)?; + let mut prf = Hash::Sha1; + let mut key_length: Option = None; + for field in kdf_fields { + match field.tag { + 0x02 if key_length.is_none() => key_length = Some(uint(field)?), + 0x30 => prf = Hash::hmac(algorithm(field)?.0)?, + _ => return Err(Error::Unreadable), + } + } + let (cipher, iv) = algorithm(scheme)?; + let iv = iv.filter(|v| v.tag == 0x04).ok_or(Error::Unreadable)?; + let size = match cipher { + AES128_CBC => 16, + AES192_CBC => 24, + AES256_CBC => 32, + DES_EDE3_CBC => 24, + _ => return Err(Error::UnknownAlgorithm), + }; + if key_length.is_some_and(|l| l != size as u64) { + return Err(Error::Unreadable); + } + work.derive(iterations)?; + let rounds = u32::try_from(iterations).map_err(|_| Error::Unreasonable)?; + let mut key = Zeroizing::new(vec![0u8; size]); + // (RFC 8018 takes the passphrase as octets: its UTF-8, as the writers do.) + prf.pbkdf2(passphrase.as_bytes(), salt.value, rounds, &mut key); + match cipher { + AES128_CBC => cbc_decrypt::(&key, iv.value, ciphertext), + AES192_CBC => cbc_decrypt::(&key, iv.value, ciphertext), + AES256_CBC => cbc_decrypt::(&key, iv.value, ciphertext), + _ => cbc_decrypt::(&key, iv.value, ciphertext), + } +} + +/// `ciphertext` decrypted in CBC mode with PKCS #7 padding. A wrong key shows as bad padding, +/// which is said as a wrong passphrase (the MAC has checked by then, so it seldom is). +fn cbc_decrypt(key: &[u8], iv: &[u8], ciphertext: &[u8]) -> Result>, Error> +where + C: aes::cipher::BlockCipherDecrypt + aes::cipher::KeyInit, + cbc::Decryptor: KeyIvInit + BlockModeDecrypt, +{ + let decryptor = cbc::Decryptor::::new_from_slices(key, iv).map_err(|_| Error::Unreadable)?; + let mut buffer = Zeroizing::new(ciphertext.to_vec()); + let len = decryptor.decrypt_padded::(&mut buffer).map_err(|_| Error::WrongPassphrase)?.len(); + buffer.truncate(len); + Ok(buffer) +} + +/// Where a SafeContents is: the passphrase, whether it came out of an encrypted safe, and how +/// deep in other bags. +#[derive(Clone, Copy)] +struct Safe<'a> { + passphrase: &'a str, + legacy_password: &'a [u8], + encrypted: bool, + depth: usize, +} + +/// The bags of a SafeContents, into `found`. +fn safe_contents(bytes: &[u8], safe: Safe<'_>, work: &mut Work, found: &mut Found) -> Result<(), Error> { + let Safe { passphrase, legacy_password, encrypted, depth } = safe; + if depth > MAX_NESTING { + return Err(Error::Unreasonable); + } + let der = Zeroizing::new(ber::to_der(bytes).ok_or(Error::Unreadable)?); + let (list, rest) = ber::read(&der).ok_or(Error::Unreadable)?; + if list.tag != 0x30 || !rest.is_empty() { + return Err(Error::Unreadable); + } + for bag in ber::children(list.value).ok_or(Error::Unreadable)? { + work.bags = work.bags.saturating_add(1); + if work.bags > MAX_BAGS { + return Err(Error::Unreasonable); + } + if bag.tag != 0x30 { + return Err(Error::Unreadable); + } + let fields = ber::children(bag.value).ok_or(Error::Unreadable)?; + let (kind, value, attributes) = match fields.as_slice() { + [k, v] => (k, v, None), + [k, v, a] => (k, v, Some(a)), + _ => return Err(Error::Unreadable), + }; + if value.tag != 0xa0 { + return Err(Error::Unreadable); + } + let (value, rest) = ber::read(value.value).ok_or(Error::Unreadable)?; + if !rest.is_empty() { + return Err(Error::Unreadable); + } + let key_id = attributes.and_then(local_key_id); + match oid_of(kind)? { + KEY_BAG => found.keys.push(KeyBag { key: Zeroizing::new(value.whole.to_vec()), encrypted }), + SHROUDED_KEY_BAG => { + // EncryptedPrivateKeyInfo (RFC 5958 §3). + if value.tag != 0x30 { + return Err(Error::Unreadable); + } + let parts = ber::children(value.value).ok_or(Error::Unreadable)?; + let [alg, data] = parts.as_slice() else { return Err(Error::Unreadable) }; + let ciphertext = octets(*data)?; + let key = decrypt(alg, &ciphertext, passphrase, legacy_password, work)?; + if ber::read(&key).is_none_or(|(k, rest)| k.tag != 0x30 || !rest.is_empty()) { + return Err(Error::WrongPassphrase); + } + found.keys.push(KeyBag { key, encrypted: true }); + } + CERT_BAG => { + if value.tag != 0x30 { + return Err(Error::Unreadable); + } + let parts = ber::children(value.value).ok_or(Error::Unreadable)?; + let [cert_kind, cert] = parts.as_slice() else { return Err(Error::Unreadable) }; + // (SDSI certificates are of no use for mail: left out.) + if oid_of(cert_kind)? != X509_CERTIFICATE || cert.tag != 0xa0 { + continue; + } + let (octet, _) = ber::read(cert.value).ok_or(Error::Unreadable)?; + let der = ber::to_der(&octets(octet)?).ok_or(Error::Unreadable)?; + if found.certificates.len() < MAX_CERTIFICATES && crate::cert::Cert::from_der(&der).is_some() { + found.certificates.push((der, key_id)); + } + } + SAFE_CONTENTS_BAG => safe_contents(value.whole, Safe { depth: depth.saturating_add(1), ..safe }, work, found)?, + // CRLs and secrets: of no use here. + _ => {} + } + } + Ok(()) +} + +/// A bag's localKeyId attribute (PKCS #9), when it has one. +fn local_key_id(attributes: &Tlv<'_>) -> Option> { + for attribute in ber::children(attributes.value)? { + let parts = ber::children(attribute.value)?; + let [oid, values] = parts.as_slice() else { continue }; + if oid_of(oid).ok()? == LOCAL_KEY_ID { + let (value, _) = ber::read(values.value)?; + return (value.tag == 0x04).then(|| value.value.to_vec()); + } + } + None +} + +/// What of a private key (PKCS #8) its certificate's public key must match: an RSA key's modulus +/// and exponent as `RSAPublicKey`, an EC key's public point derived from its scalar. +fn public_of(pkcs8: &[u8]) -> Option> { + let (info, _) = ber::read(pkcs8)?; + let fields = ber::children(info.value)?; + let [_, alg, key, ..] = fields.as_slice() else { return None }; + if key.tag != 0x04 { + return None; + } + let (oid, _) = algorithm(alg).ok()?; + let (inner, _) = ber::read(key.value)?; + let parts = ber::children(inner.value)?; + if oid.to_string() == "1.2.840.113549.1.1.1" { + // RSAPrivateKey (RFC 8017 A.1.2): version, modulus, publicExponent, … + let [_, n, e, ..] = parts.as_slice() else { return None }; + let mut body = n.whole.to_vec(); + body.extend_from_slice(e.whole); + return Some(rsa_public(&body)); + } + // RFC 5915 makes the public point optional. Derive it from the private scalar, + // and refuse an inconsistent supplied point rather than trusting bag metadata. + let scalar = parts.get(1).filter(|p| p.tag == 0x04)?.value; + let supplied = parts.iter().find(|p| p.tag == 0xa1).map(|p| { + let (bits, rest) = ber::read(p.value)?; + if !rest.is_empty() || bits.tag != 0x03 || bits.value.first() != Some(&0) { + return None; + } + bits.value.get(1..) + }); + use p256::elliptic_curve::sec1::ToSec1Point; + let point = match private_key_kind(pkcs8) { + KeyKind::P256 => { + let public = p256::SecretKey::from_slice(scalar).ok()?.public_key(); + if let Some(encoded) = supplied + && p256::PublicKey::from_sec1_bytes(encoded?).ok()? != public + { + return None; + } + public.to_sec1_point(false).as_bytes().to_vec() + } + KeyKind::P384 => { + let public = p384::SecretKey::from_slice(scalar).ok()?.public_key(); + if let Some(encoded) = supplied + && p384::PublicKey::from_sec1_bytes(encoded?).ok()? != public + { + return None; + } + public.to_sec1_point(false).as_bytes().to_vec() + } + _ => return None, + }; + let mut bits = vec![0]; + bits.extend(point); + Some(bits) +} + +/// `RSAPublicKey ::= SEQUENCE { modulus, publicExponent }` around `body`. +fn rsa_public(body: &[u8]) -> Vec { + let mut out = vec![0x30]; + let len = body.len(); + if len < 0x80 { + out.push(len as u8); + } else { + let bytes: Vec = len.to_be_bytes().into_iter().skip_while(|b| *b == 0).collect(); + out.push(0x80 | bytes.len() as u8); + out.extend(bytes); + } + out.extend_from_slice(body); + out +} + +/// A certificate's public key as [`public_of`] gives it: the subjectPublicKey's bits. +fn certificate_key(der: &[u8]) -> Option> { + let cert = crate::cert::Cert::from_der(der)?; + let spki = cert.public_key(); + let bits = spki.subject_public_key.as_bytes()?; + if spki.algorithm.oid.to_string() == "1.2.840.113549.1.1.1" { + return Some(bits.to_vec()); + } + // (An EC point: the BIT STRING's octets, after its unused-bits byte, as `public_of` gives.) + let mut with_unused = vec![0u8]; + with_unused.extend_from_slice(bits); + Some(with_unused) +} diff --git a/crates/smime/src/pkcs12_tests.rs b/crates/smime/src/pkcs12_tests.rs new file mode 100644 index 000000000..1d640ecd7 --- /dev/null +++ b/crates/smime/src/pkcs12_tests.rs @@ -0,0 +1,568 @@ +// SPDX-FileCopyrightText: MailCraft contributors +// SPDX-License-Identifier: MIT OR Apache-2.0 +//! PKCS #12 files opened (#30 R13). The files were made with OpenSSL 3 for synthetic +//! `example.org` people (an RSA key for Alice, a P-256 key for Bob, both under a test authority +//! made for these tests alone), with the passphrase `example-pass`: +//! `openssl pkcs12 -export` (PBES2, AES-256-CBC, HMAC-SHA-256), with `-keypbe PBE-SHA1-3DES +//! -certpbe PBE-SHA1-3DES -macalg sha1` (the old scheme), `-legacy` (RC2-40), `-nomac`, +//! `-keypbe AES-128-CBC -certpbe NONE -macalg sha512` (Bob's), `-passout pass:` (no passphrase) +//! and `-iter 2000000`. + +use base64::Engine as _; +use proptest::prelude::*; + +use crate::pkcs12::{Error, KeyKind, MAX_P12_LEN, looks_like, open}; + +const PASS: &str = "example-pass"; + +fn bytes(b64: &str) -> Vec { + base64::engine::general_purpose::STANDARD.decode(b64).unwrap() +} + +fn der(pem: &str) -> Vec { + crate::import::certificates_in(pem.as_bytes()).remove(0) +} + +#[test] +fn a_modern_file_opens_with_its_certificate_its_authority_and_its_key() { + let opened = open(&bytes(MODERN), PASS).unwrap(); + assert_eq!(opened.certificate, der(ALICE_PEM)); + assert_eq!(opened.others, vec![der(CA_PEM)]); + assert_eq!(opened.key_kind, KeyKind::Rsa { bits: 2048 }, "RSA keys aren't used here: the window is told"); + // PKCS #8 PrivateKeyInfo, RSA. + assert_eq!(opened.private_key.first(), Some(&0x30)); + assert!(opened.private_key.windows(9).any(|w| w == [0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01])); + // Never shown, even in a log. + let shown = format!("{opened:?}"); + assert!(shown.contains("redacted"), "{shown}"); + assert!(!shown.contains("48, 130"), "{shown}"); +} + +#[test] +fn the_old_triple_des_scheme_opens() { + let opened = open(&bytes(LEGACY), PASS).unwrap(); + assert_eq!(opened.certificate, der(ALICE_PEM)); + assert_eq!(opened.others.len(), 1); +} + +#[test] +fn an_ec_key_finds_its_certificate_by_its_public_key() { + let opened = open(&bytes(EC), PASS).unwrap(); + let info = crate::import::certificate_info(&opened.certificate).unwrap(); + assert_eq!(info.addresses, vec!["bob@example.org".to_string()]); + assert_eq!(opened.key_kind, KeyKind::P256); + assert!(opened.others.is_empty()); +} + +#[test] +fn a_file_with_no_passphrase_opens_with_none() { + assert!(open(&bytes(EMPTY), "").is_ok()); + assert_eq!(open(&bytes(EMPTY), PASS).err(), Some(Error::WrongPassphrase)); +} + +#[test] +fn a_wrong_passphrase_is_said_as_one() { + for file in [MODERN, LEGACY, EC] { + assert_eq!(open(&bytes(file), "wrong").err(), Some(Error::WrongPassphrase)); + } + // A passphrase with a character past the BMP can't be one a file was made with. + assert_eq!(open(&bytes(MODERN), "\u{1F600}").err(), Some(Error::WrongPassphrase)); +} + +#[test] +fn a_changed_file_fails_its_mac() { + let mut file = bytes(MODERN); + // The MAC's digest is near the end: change its last byte, then a byte of the content. + let last = file.len() - 30; + file[last] ^= 1; + assert_eq!(open(&file, PASS).err(), Some(Error::WrongPassphrase)); + let mut file = bytes(MODERN); + file[200] ^= 0x40; + assert!(open(&file, PASS).is_err()); +} + +#[test] +fn what_is_no_longer_safe_or_unvouched_for_is_refused() { + assert_eq!(open(&bytes(RC2), PASS).err(), Some(Error::WeakEncryption)); + assert_eq!(open(&bytes(NO_MAC), PASS).err(), Some(Error::NoMac)); + assert_eq!(open(&bytes(SLOW), PASS).err(), Some(Error::Unreasonable)); + assert_eq!(open(&vec![0x30; MAX_P12_LEN + 1], PASS).err(), Some(Error::TooLarge)); + assert_eq!(open(b"not a file", PASS).err(), Some(Error::Unreadable)); + assert_eq!(open(ALICE_PEM.as_bytes(), PASS).err(), Some(Error::Unreadable)); +} + +#[test] +fn a_pkcs12_file_is_told_from_a_certificate() { + for file in [MODERN, LEGACY, RC2, NO_MAC, EC] { + assert!(looks_like(&bytes(file))); + } + assert!(!looks_like(&der(ALICE_PEM))); + assert!(!looks_like(b"")); +} + +/// A DER element of `tag` around `content`. +fn tlv(tag: u8, content: &[u8]) -> Vec { + let mut out = vec![tag]; + let len = content.len(); + if len < 0x80 { + out.push(len as u8); + } else { + let bytes: Vec = len.to_be_bytes().into_iter().skip_while(|b| *b == 0).collect(); + out.push(0x80 | bytes.len() as u8); + out.extend(bytes); + } + out.extend_from_slice(content); + out +} + +fn seq(parts: &[Vec]) -> Vec { + tlv(0x30, &parts.concat()) +} + +fn oid(dotted: &str) -> Vec { + use der::Encode; + const_oid::ObjectIdentifier::new(dotted).unwrap().to_der().unwrap() +} + +/// A bag of `kind` holding `value`, with the local key id `id`. +fn bag(kind: &str, value: Vec, id: &[u8]) -> Vec { + let local_key_id = seq(&[oid("1.2.840.113549.1.9.21"), tlv(0x31, &tlv(0x04, id))]); + seq(&[oid(kind), tlv(0xa0, &value), tlv(0x31, &local_key_id)]) +} + +/// A PKCS #12 file of one plain safe (no encryption at all) holding `key` in a plain key bag +/// and `certificate`, both with the local key id `id`, under a SHA-256 MAC with [`PASS`]: what +/// `openssl pkcs12 -export -keypbe NONE -certpbe NONE` writes, and a file that pairs any key with +/// any certificate. +fn plain_p12(key: &[u8], certificate: &[u8], id: &[u8]) -> Vec { + use hmac::{KeyInit, Mac}; + let key_bag = bag("1.2.840.113549.1.12.10.1.1", key.to_vec(), id); + let cert = seq(&[oid("1.2.840.113549.1.9.22.1"), tlv(0xa0, &tlv(0x04, certificate))]); + let cert_bag = bag("1.2.840.113549.1.12.10.1.3", cert, id); + let safe = seq(&[key_bag, cert_bag]); + let data = |content: &[u8]| seq(&[oid("1.2.840.113549.1.7.1"), tlv(0xa0, &tlv(0x04, content))]); + let auth_safe = seq(&[data(&safe)]); + let salt = b"example salt"; + let password: Vec = PASS.encode_utf16().flat_map(u16::to_be_bytes).chain([0, 0]).collect(); + let mac_key = pkcs12::kdf::derive_key::(&password, salt, pkcs12::kdf::Pkcs12KeyType::Mac, 2048, 32).unwrap(); + let mut mac = as KeyInit>::new_from_slice(&mac_key).unwrap(); + mac.update(&auth_safe); + let digest = mac.finalize().into_bytes(); + let sha256 = seq(&[oid("2.16.840.1.101.3.4.2.1"), vec![0x05, 0x00]]); + let mac_data = seq(&[seq(&[sha256, tlv(0x04, &digest)]), tlv(0x04, salt), tlv(0x02, &[0x08, 0x00])]); + seq(&[tlv(0x02, &[3]), data(&auth_safe), mac_data]) +} + +/// The private keys of the fixtures, as PKCS #8. +fn rsa_key() -> Vec { + open(&bytes(MODERN), PASS).unwrap().private_key.to_vec() +} + +fn p256_key() -> Vec { + open(&bytes(EC), PASS).unwrap().private_key.to_vec() +} + +fn p256_certificate() -> Vec { + open(&bytes(EC), PASS).unwrap().certificate +} + +#[test] +fn the_kind_said_is_the_private_keys_own() { + // A P-256 key with its own certificate, in a plain safe: it opens, and is said to be in + // clear in the file. + let opened = open(&plain_p12(&p256_key(), &p256_certificate(), b"1"), PASS).unwrap(); + assert_eq!(opened.key_kind, KeyKind::P256); + assert!(!opened.key_encrypted, "a plain key bag in a plain safe"); + assert!(open(&bytes(EC), PASS).unwrap().key_encrypted); + assert!(open(&bytes(MODERN), PASS).unwrap().key_encrypted); + // An RSA key with a P-256 certificate sharing its local key id: no certificate is its. + assert_eq!(open(&plain_p12(&rsa_key(), &p256_certificate(), b"1"), PASS).err(), Some(Error::NoCertificate)); +} + +proptest! { + #![proptest_config(ProptestConfig { cases: 256, ..ProptestConfig::default() })] + + #[test] + fn any_bytes_open_without_a_panic(junk in proptest::collection::vec(any::(), 0..1024)) { + let _ = open(&junk, PASS); + let _ = looks_like(&junk); + } + + #[test] + fn a_damaged_file_opens_without_a_panic(at in 0usize..4096, byte in any::()) { + static FILE: std::sync::LazyLock> = std::sync::LazyLock::new(|| bytes(EC)); + let mut file = FILE.clone(); + let len = file.len(); + if let Some(b) = file.get_mut(at % len) { + *b = byte; + } + let _ = open(&file, PASS); + } +} + +pub(crate) const MODERN: &str = "\ +MIIOEgIBAzCCDcAGCSqGSIb3DQEHAaCCDbEEgg2tMIINqTCCB/oGCSqGSIb3DQEHBqCCB+swggfnAgEAMIIH4AYJKoZIhvcNAQcB\ +MF8GCSqGSIb3DQEFDTBSMDEGCSqGSIb3DQEFDDAkBBDdm3fB+5srzOj3zg38HGApAgIIADAMBggqhkiG9w0CCQUAMB0GCWCGSAFl\ +AwQBKgQQvM0sSUpkFZIgMm8ugLNoeYCCB3DTS+ebN3ewVoyZqBEVHgql+fwsLs2Kg1+vsIpYO6KKjRTdBOZcc43YM0KcswLrG9Pn\ +Nk9h5L3j4iXV5F4pjDpsLB/myW9NveaGnVh/3fuiPbCuyGFZFnyO/R45vFcDkoyPsG/GKLWPZuHIUZ4ZypHj8YJm6hgZyzFzxjmx\ +lMogMrNxsne0FSFLS8bLT4Y6onx8ERTLqTRWjtl+HmVYOy7/st3MB50p6Gkl1JJLvPJc+y0XBqtV8KXnn1fFBPDtSjpFX2A1TRBW\ +lSDMEKm/YA2PO1daflSoJxRmyQXdyprI0jBd6oea7larA6PexvHX5en/3Vw5P02s49dxnJSGkuqhk1mKTJJTvdu/s3WBfvTBEmiV\ +sL67c31NmDsNTQ9FUQNZKSvEj3OLZ6752e/enf4dHZebvxXcYIHLndpGAVF+jvjYoZ68O+unm2jP8k94lkHgnwu+LYBBdEpfmntU\ +lfFN68RmuOyuIUQn8Xmpw5sEH4TDLTodI5BFLHb6+Rcz6tvTFZTUcaVTJfVP4O0ZaSy/vgDSBFN6X0LwHG+znHi+hkZr2gMhElRi\ +q2Ewx/iSOWVn6Iy+k1TE+qBc1tuOA1BvzaRlg712WWM5SyNTx25+1/6G1CW7xbbyz9AmQQacZ1PUXpqr9JD5e21OgYvldy9Tt38l\ +IY/Vk5aqpD4hScAv5Ncwr7aGuchhJ8AJLkBRT1SLpazhwzmbyoSYBlwEZ/WpY8hc35OsMLHI8jgR9BXBuUVrP0kM+kFBh5Cyb1F2\ +zRFDTAGKaRh7kVAd/GHPQ6t/FveBHp2ne9ADXXF3Nl1MqAXAuSBhZs2WTWTxOG2cy+4ocb1psFia3Y9abxjMksB23byqCt+ZX1mL\ +DXmfK0EUxq1K1twkJJEQnnMcp9lvEgc4uzggu8zICWsPRh/H1v0VlDp7PextlWotnf1TnTI8WgjcqT6JsDUmLEtwEufsSQtbHm26\ +vXbLBLdW0ZTG57FmqjkPXptnrxk+X9athIxcMaphL0HZIIId5zUqDBzw5hTCf9SUd6lNjkmK5h1qTBkOF3oUWCmxZc9kcCt54nKk\ +YvKjq602dWGxI9WQ41symceExKYXqfrsKKVLEofNPr6ObYyc6dgeM9Tq0D21XMr3L4Z0rpFUj7jPbS+0vJGtXFnOCfdkEBmR/00U\ +chFTsOEHQZ2lbsaZt0MSiN1kvfvOh22mdiM6Q6VPG5HCBTIpvgOoC5RvjRxVZzDl1HDgUuPG0cM8B+tnn2IVuyflnygwoTpHZtLQ\ +qfA6ZVFnJTfMFuXwzhRDk9yJafE33gyYCLpfewQ31ljE3x/CmXdA5kzSiwRizb+Z0LJZMGI6zh/iA5tKa4xWL7IpOXPex/xe9Lhh\ +cpVLk+ylN6GUeOOcHt1bYujRQuM4BmWnNVJ46Uf2ozUd72x3jystLTYDd9+JnNLfFrKMdkyIkm4/Hihyu0GMPm5YSfgFG2qQPY2l\ +GqPV8Xs09CrZM/X10Td+a4nBFVU9HwVzWX1H4cAJXwsjanojxX1J75LAbrRQBWozWgtpBavsG+1G55ygnG+4z5+P+JYnspzTxxG1\ +NgpE6ngq9aMjZ6AsiZM5rzX78LKjuWSzA9xfawnOukt2irF/j+cDIojJR9NdLiCgh1v9AckJzQQh96NFsQ9w8s2FGUurMMih/dln\ +onyw0m/8VHYx1HPoIgwhJgOvsIrwHjkxG6gS4cIJCRBWwj/93nYgyYEBkBD24g5hMrsNpHfgf9jvQZ5y/Sj/5jNf4n0GzQXnTQur\ +Mm9FuEb3VAIfU1tNYevZ/xdF66yQ9NApmUXvTiHlitvI9ndebAW8etiLAwBajsb6eBbI489cOzCvI/9hoouFns3wSFNVuHNRD2qg\ +Ujl6dNPyPnuzow6tQz4mFPRi/WMl3aSq3CWZ9kybYJXNIO/2vaN85a7bx3tueZaAs1Jm/HrHpiwYXDM2nFqXYWDyeAfq+xLfwsJ0\ +a/eJ7s74Vjibl9ANfe7Pkb0v00y4vFkMJ60Yk/3TuW6qqLrIjAqQ8Qh+aFH/IZ1wFdibZk9Hk3yFoCV1CgA5hGT4WouTkEV8Z7PT\ +gC/ipwbgOPXUEq33yfTFDFbmrk9PvbpjSWKA9Aw+7CPA9j22j0ciYvNGacHKdf5Qgmh1J5W6uC0Rz+WupFEKwkYqj7MM3zp92tKQ\ +DXIoutcAPmQOsqapR6POtbz9J62RZLZDSkiWfMSyRzNuoOZW8TvdH7Xi/y4FH3bMBDIbNrdDIzS9yxrTMBjv773Aoa+iCtATmcU5\ +dGu22y9IUJ95hALMMRRu01RvzyImR3RZLM3zXVpMrdirFPcQ0xV3zXsxquNMBTm7LEaZPO5iUIC8kaaOSxy6X3ETG2Dd74WuB3C9\ +Y+3Jrx55yUd8vdgflIxwv3JxBhS+rqMqNSmS6ho/4Yip7SVLtrGNPyDt267y+CH2kLGyhjIccH46k/o0P/V3Rj+3RKkI5zea1jRG\ +N4ZqezhlpJJOea/MFbDS/1hV+3EAzklYs++Pw9Xeywtr21GtzVgGnmNlZj7aaf0f6VA5xC+CBjCCBacGCSqGSIb3DQEHAaCCBZgE\ +ggWUMIIFkDCCBYwGCyqGSIb3DQEMCgECoIIFOTCCBTUwXwYJKoZIhvcNAQUNMFIwMQYJKoZIhvcNAQUMMCQEENj6DxvnJypnlOxD\ +B4pal5ICAggAMAwGCCqGSIb3DQIJBQAwHQYJYIZIAWUDBAEqBBDwjW/DvRppLgPgUc4+brTxBIIE0Gibr1mXoSTq1KNRphdw8u0Q\ +PJosufEujUHoGpnTeYPnkjjfilvFrwSVN4nB8A8hB/pth1NCPFAxGSkdIZtf8AImtCZ2DDXoX1G8210m3RdoI1G5zA3RXgefKDzT\ +vVh5iKTjqIorB/slrDkTd2vBdI6odSzii+2wwUMeF6pxZ4XDjc155HFpXA5zvwIEUPbKOG+Ah9khv9ZsB2ya11hfay3/w30q87uJ\ +74lOnkEMU00e5fkHu4V/oE/2dcHRvY76f0vqpxVgLpVVQRAn5IhXNEOiJ5wDIB86zf8Eg4eMuTgWoJaOux8vA7pSzOgNZrrOD4hM\ +hXHRclWmMZqXYgz3bTTU1VfTaqID6XKnPKjQymbzfsre0M3lixdq8EdylKIDWazMuIGo3sLnJV0to0UAmKWrzqBUdedAVcSdKjHe\ +HF/NJmtzzbiLXI5s7UuqBPOKvwMLWWCm1JN70SQBX+IEP8OU1d1TJghAn9kFq6gEq4uMB/L69T+r8LQLY6ralvGbDvCGfBqvmbqM\ +una2ZKdHJ9X/B8IQuP2ioraI8ToN11wywLwPwGgISrwyVpBwQQDmPjfxs2yfgDNqb+NxZAT1+MnW9Sibo8WN+R91QOJRCxgMQmdV\ +alJFZljUH0ZhvugvdLeguAElnATMF2R5r6JmprYJA/jqz3BUo/WkUnHsV0nAhps7d9oHRkQMRQ/oYwzONBfLDmEb6AkbqAYLGJHw\ +PDHQ1efrgZlo0GeokG224wDzz2OlFSrWqMX1RQ95aM7DI/vUAO1kKI58uVYXSDwg3a3VBzhrZLedkkPU5m8SM2sYJgtmi6rKHllO\ +XvTpOPXX+XohJr7Q7S0XFR9KoSHeH1q29E/aOT01Wp7Wfq19hhtAkJtd48vOoZmoE4DdSy1mVfGXouU5piS6a+HF9HIhEZbMvP2T\ +t5EAptK5KxaJQ5xj3ICJ8tfFmePZqMITIeQem4Dpem1rcwc3eh5A1tGLoGITFEWB1TDl5wl65hY3MZItmAAqabBwaHIPhThIEYxu\ +xlSSj9GE9Tuhq00sBLfBQnDULf0XYxInFnoWalvFNtmWLR+3njdwJ5r4bPGJrNhnpDqPEPlwCJ/nKzQf1DGb/0rc7Vx2VDfNYkvU\ +4u7+M4YQm7KIsWBVZbWjNHOOUoP5iU5OaAbfFNjW5zs5h9VJSh1Yrh5UGbFk8rfR+UF+GlEA2NQ0X16N4lPFGvQqJhDX3IgKVKhX\ +nhyV1HSkLn0qUnQH8oT9ZfqASUxN0uaTN3MYGZQTRB/vKwg3V6zxKtQD3PLqRWR1eFm8UYq3/3Sa1H+qYje5GsWXL+wbB1UXrnP8\ +O4v1/PJ759QDqCpEXSc/YUAxw2J7g54LJEUKFwvvTEprlP75LFnXaRx60kzi0RDzvOzbBDIdjYtiOCEgX2l6D0TWnYPVvqsy4cK7\ +wY0OND6oE5WS2WxSCGMsfgIuOWjQ4zNFRZpjwVwBPjSbgYLY0Lxt+k3/9i+QQVrurodJQeO12rk5hn32ihc71JyQfMH5b8i/bVGs\ ++7cJhmc+I56DJ6S/o+M5RxHFIH03iBwp6wxwz9zu67OFa+w89Aybp80TeqjAcMFoqqJoO5tBub83yT7///FLwF3TraZUkWm1Cqgz\ +F5qTXAqUVgAYo3XCHFEjMUAwGQYJKoZIhvcNAQkUMQweCgBhAGwAaQBjAGUwIwYJKoZIhvcNAQkVMRYEFIVDIKpsK9ynC1lADgpT\ +GrG04AAzMEkwMTANBglghkgBZQMEAgEFAAQgGqUPhUzRMcaqds9vgTOSCbcRLzd3zWp/qA73DkTB8zsEEB9ajyrtEIfDiOZeZ+v5\ +L4kCAggA"; + +const LEGACY: &str = "\ +MIINQQIBAzCCDP8GCSqGSIb3DQEHAaCCDPAEggzsMIIM6DCCB58GCSqGSIb3DQEHBqCCB5AwggeMAgEAMIIHhQYJKoZIhvcNAQcB\ +MBwGCiqGSIb3DQEMAQMwDgQI0ywIdIL+wmUCAggAgIIHWCNIi5dNd/xDFZskzoB0TEfhZ7bZE/3+oz+hJ4aSPSKFQ12Dw77TkEio\ +FSJ3n2G8EimkuNz/d4JNhuo/kVHNQUBS6Fq//WcB1j7uQOO4M65Lz5nXcTCihxBqhVHamKWqYwnzAwkiYvjy+SLXcAS+JeXPieWX\ +BjTq2D8pSPZ2g18IalAPQFuF6wkN4K9ninrpz9IXhss5+05hgTj2xKZdj9zrU4HL3gZ5C9iAudsUDiMB9vA9ruvr7HrhLCW9ezWs\ +Vuav57JvSEXm1EGMhx0Xu5t6nf1AwgzKJ9+D3chvV4XvIV37ITvwoT5eCiAsHaCn1AJD8Q8R/26W9ypGOpuJfeXEtIyXcbybCkJ6\ +351XP0Wt87l1/i1JHsJHwgErfCASgrL2zkQGymIUxjdTtaE55kBgL9BJZvCjagI9uMw0rC5azJ8UwJwp+fsVnzYXzVsvCFK7cVR8\ +LLA0nQSiwu9E24U6/b7zn21WktBF3UFmLWsdCCEbvrrxZOmmGuwWikSF3Li4s5n2uNMJ9pJkm6qFqOvoie2048UOzcO4uuLbV+kb\ +KobV5BEo/EQQoiI66+Z7z7cK6nUjiEZNpeZKqaVnNunuJN2WvGlO4EqLykjj7vzVUU3XKHoKwpsaGalihbvKVcA939KvP4GYTyu0\ +N2UWQ9BUn/XLV+e/oHD2YLkclbYM6Xt5ZDf3RZ1mvDu8GVU8wCpL4TiYf7UA3Nc5k77O4fg9wy9cQgaM3gJwhTz4LmWJO4CgLaHY\ +Z1MoFgRghg6CWRgWrFuDwuB14FjkYsQSwCexd2KoZgbeCb2E9kVRHX9j16Y3fq4k1VzOlg70nSJr3xqhsKB4u7ahr0J3jdhIb6Xm\ +m2yknpFaOyVs9/6J8r7DYV0P1VjIAjhGfTlhQxh7Dzw/BDUrLeLbZAvzwDxZB7d2VeezGcwJz99QcyV3HC0G+rBUwyq6umUbE8cl\ +Lic0hZ1uXDiGraPSe5VZ/HCfIZCLPJfRn2of7B+QOORPiNQ869dj1Kpr59bcgu8D2hjU795TYSn4n34+5wUp3yF5mZ+DDlSEY/yZ\ +2De3QrZsEyRMrhHwDssDa2VQ4EVOeyx4KsSdfKKQDKsBoFk8cpu6Au4gw4j3/LVZZC6e7arqHwJae5vG9vuXa7TYulIQm81l8AGi\ +jV5EOWx6W7JZoiFpF506EISnDvjCjcSJ9xUPKoBoQpl0GjxPf66WakDMclKx5gsw3WTV5WNOsUHGqW7+fVS8+XdHTVzeniXprqKR\ +XXI7qQvTsgjeks300xfOXZczaBBM923HqKXzl2eR9gAJx/pcpqF330dL/KOOnJMsaXJNq20kD5ZPjjbQ+EjmEgb68QbbwSYNTg5Y\ +SCFtzrGuQ1XFAJ0e7tS6umNi2LSUOdPr1VlyXvm/03uf6Zm1JMHbmv61wia1dtyksUnO9FxrRbwpRSFT/5KBY7ZPZinbQpE2Rlxx\ +NTpu0fKCZOUokvgWHAI9brPEKgRrNdkiugRP9RvpY6UX6v82Lby14iPH+ehH9sP2NhY+vlL1qS91n9HY+HygWOcMP/PfN3HpAcZU\ +QnlZnsq4ZO+U5piY1NrKTTcnhzIGKx5ObQcDolaoczLZTFwSxyxiTlRcJyJllIR/ff+64/wNiTdYODI3rEJunEQAbf5kEPKD0Rqn\ +YRgZRtMEWk1ADKHHbjykFupIgP6dSncJ0oiH2Pq84KU0SrJspJ1gQfmywgGV0gGc8alLeifHqktPdU4OEVq4FKZzSAVyTh9o0BX9\ +KOfsbM8iRlDa2AYP+Qnfbm7wmOFThnseg5rJ4aA7jUgtlkLg9YhMOI0Uh/vIAUopr5sK1qiU/w0XykCbU0JD36qyVSFxCdSweB1E\ +rKBf1FZ5AF0pR9XgCadKBATY9vwaLxTBxTWPJwdxKSCbAOc2V3UD0yzWvxTgzL2sh3YPZFVvJJot1aYO2U+J0omYo3c86h0bYyrY\ +uCEESVoBz1Euzs912It5Z+2s4R/f2Xu6EGQHGSTFIzuRQlzuAlHyBPZhToLkclFegQapeXzyrJwOusUaGtGqkmJZoseZ/yTxGBhk\ +c9JXuTHTYnsCEiuKhyeFG1yGRDlf/AiCDN6zOBNMiXJGdpvKrcx+Efz8hdZ94CE4FUp2QRnyKDVBYKd+6fa4Cv+LsCF+Ohk8zCt0\ +FrniW0GMvjrjvRCZYADyS94LWIVm57Xggz9t+3OONOW0xpswJCNCNpwttxP/FYa3A63jYatywOj4343vOMyubLGWpeaNnAzPVMHb\ +Yb1Utx6Xhj4DMmfAK69E3cCHH06auio+bmJx7p23k5UCc+ifA9o4qW9HuZtqfRUhWc+qFycZAaENll2nMHKctlhxId5bZ+R3EzJp\ +a6doHHgwLA8/YJiCTmt68pXV9zHlMfGhv22E3RPBCJX94265+llB/juy1CdrfDzszoM8sE6ikJ0BCWbIOvDHmzHeOUpW9gq17/rC\ +bmAzZLsfD2fZW18+Ygzd86Ci+VgdB+4YtGDYUom0SIFlJn/QNGKFMIIFQQYJKoZIhvcNAQcBoIIFMgSCBS4wggUqMIIFJgYLKoZI\ +hvcNAQwKAQKgggTuMIIE6jAcBgoqhkiG9w0BDAEDMA4ECEwWX85zkiPsAgIIAASCBMijlMCuQ4vGtXt5aSh+gMYSRbErCCsU7YSQ\ +ShBrz2ELWaNE2tXKyICqb/+TD+9nLJFikT/x1wF2I4qtTq9TRLf3WhR7wQGN9vxbeAS8w+0V8iBBmDlesS8zE76m3hBbrnxpSjEh\ +Q4+IwKEFU33WwdEVTbSRQj0R3DhQN10QR/8hhRHpxZlEQY5S9u0eVrFH8vObMlj3HJCx1tUiTAEmDMeVIA2Yy3bnnbdE1z7PLyKt\ +peBvfCg/2nczZLW9DRUquGhZp9MwdbLvpkR7COgBDTZY5MBGU6SfDyPffBaNaHS9ZmTKeOIHR67ZYQ/tT/5IlA+NKmAoKmMTjmO6\ +GIv+uDLWJPZVwFPcNxDe0YHZWgFrxOHam1HFIDHacGzCjJ8kJgYK7qPT4UzW5658wZrPPayGUs7OdcBSlUXoUPwI6GzdgxtPh9DF\ +6CFbHqvuyOo/XFP7pENIcZ+Fgpk7ruB9dJGC1rMlbg9v2myYEDlvH7ydJMAQKWEF4Cosii6KO0Td+4HHz1RPXDzLT0vzdulg6pwP\ +BGEoHfcVfd0xUuJp+Rd0lO+SWIyrLNhQ9sNUowMLwuvIRJfOxWjZ/Hop21DEn1eJtweC2BOXKnxMRsdEVBmLMHPidc6bPi6djMds\ +xbYRz9rmQ0eaQFR87cvyUHQCSglO9uyLOnLFlmAehtWLev0AehRsexD5gaID5KReBXV7KNvPdTu0F8LvOCtNi2cf2eHwnJSWgKrN\ +QwHodyVhZ//pLe93tiGdASuvCrEXN7gdIREv0njRmRqxWUl8MKfLJn/XtpUrGNLnU4qFjxrKkvTo/k7Ax0A7DFAATyulan/NHnBq\ +iHF6ZuUL1jha7jMcyhq7J5zSqDSX/0LQqbaRHigZ8IsOXdV8gB4yCraG+fLm9H7PK3nIb9yIymu/eE/C2QWecIrfGSH7sem/q0ld\ +YXxOAwm12HtcJydR0iNzK0Ddty8heVqvZRoLe+G4aY899vk9Y+Lv/XP1kWQxp8sqFw2PWM4k8TCPdhlk76PgDlkmvtDg7Yl8usT0\ ++BDLRSxtebssQTkRZ+OZzHMuj3uvyDeB9xpicoqGLgU0Qqq5w6g1SXeqyJIiEf3z7dWWw+dXxb7vbDQYySMBaUEHvXFFSCwz31Ml\ +iQAmlDT+MBqLaQhsABTa/k47Pagov+X751QT4Hs3mr8khTUoqRpRZJmFol5GBpwk5GOTMYWHBdPfqoLoU8mEObQoHT7aOembQNaM\ +NOi3zpNeKZi9kNcmMCc8EMP9IuSqwpSdx7Vq0ZNK6dCUoGmod/PTVwk5rYKUdfenLoNS5HBZaawJa+0yXunNnbkHGU01AzR19d0Y\ +nrKczQxCwQz4tRi7cf2/d2xDWFgHbU6m5OH1BMaGZcW/d35zahiz0XXlvRNIN/3mxg2gi9BO+P5TLBi3iEHeQzOHJb4vmJlpcjXh\ +3nIPBZT2roWIKpb9THlzasf8OzTGphL+Ru0zBlNmeYeJhI5yF9lPj7yMDfRCo0jk39Yy1zcMQ7ZSIgXCVRzctJxdp5AsMLrqKQhp\ +eTUW7DQ1VFE2eCAPPNl2kMZ31tM/GKIUQbwnhgQspmjWbj9XwKlmRni6nWbh2/dp+7X/3e5cXS4fParNRcMZQmPt8Ka3IGTnS64x\ +JTAjBgkqhkiG9w0BCRUxFgQUhUMgqmwr3KcLWUAOClMasbTgADMwOTAhMAkGBSsOAwIaBQAEFMhJrwJwP5rTOUpuyMctQhSu75vz\ +BBA5cgeI/EDEl/gkbG7WnPM4AgIIAA=="; + +const RC2: &str = "\ +MIIJyQIBAzCCCYcGCSqGSIb3DQEHAaCCCXgEggl0MIIJcDCCBCcGCSqGSIb3DQEHBqCCBBgwggQUAgEAMIIEDQYJKoZIhvcNAQcB\ +MBwGCiqGSIb3DQEMAQYwDgQImY9Bmh6uNp8CAggAgIID4BTIb8wbN9av/HdVdrKW3Eu2N6IjA8GZZS44fkQWSMGQsHJqxJcJ4iHt\ +UNgG/fZUum+iwyceHL8dHrncGvaajpeyXvt8mqY33UxAesW3wj4Cw9PZMRy+Alsr6vv9vWiimdesEebRST+Y+eQWeXBRs8whlGQE\ +5sVNNtrm5QUsMOUas2tiOTF53sh7leVPLIaPq5sDw96dY5lK3RtIhcoORW8bPm2jqxWu8H5kyBIiOW2dRha4kyB4J6T3zT4Yzo/1\ +AK6RFkqU/UFTyYI8SRwozUE7nWAhO6zts+tTcyyTVFz+gcpP58PEtuWBJcGdFaNKh4Vf9E2oHwxFmjPRYgflmqtRvwVh8J1pL2zG\ +9LtDAqRrMwdjfw/PZHWgvbdKeZdj0oVRai5YlHBkqgJxKed9hH+ULrCuZOWrRcBV3V0zOPKvgcacdT81reJWP/DCEoVqaqxYea4I\ +oZ7TNsv0GQOOAriJKhsKGLy5vYFT9AOxtEcyr44vrJHzhZAxQUiBRbdbo46qEADkRGgVPRcnqzgJyxA8KAwCPSGeHHETxSE8qzvC\ +FqWdwxudGsQ6uxVDsptPKtyIZUkqR4nG/Fm4ZC0VgXjHfwKmiiLN9nYVvQDO7Xaq7TOrmUog+ifUaFuEEtbC3gbH88OX3Wr1g6lY\ +CLynNHp2KeoL559uVWLZMiNAjkQ4GevsP13GZTu84a00Ldc+hIKS9wj+bjP/JHlzSu++SHY9psD2/os+olCwHLUENMV5ML2rj1Oe\ +wcg6/HJF0TPmaAnsIxYYk5AgKSgpIwBocwco3siw16tn/1h6utRTEalO6vmPmBcWYMq9K5SeiqQ/J9X7JHC6qdGgtuOSTzAUqGzT\ +vwpHtMkIv2ITjWqewArQaUNw5WHxa0ZhhukprsFUmnc1Y1X7g0ddpGLZ3Dwn46AMivgsC4iA3FmPjykKGvhMddIxkaxLglNDKePx\ +1hfsCLYdNPYMHeIyw2EnYojyG9Ux/s5Z3f2LPYuK3WSS8xtvAZFDtrmVotKsGNzJiUpWH9dCTzOiHPmnakpodOJSxqxP/OlGuQzh\ +eIRMh3e6YKc809R0DVkKa3xP1kBbHPrdP+C0B24QTLUflYOLxzNY3dJ5wCZ5jbD1ZugJava/GqoV83qQkJ1hejaTsSWEhcRxBISm\ +z8guUuMemu7D2zS9cX+bJ+8scqijFzIx1/4q3WWkLPAiugK9HJ06DPfkqnxVvL4oaAVOHDVHyGJtaRiBzLUpOlC+dSkkbls/mmuk\ +sxzoiMZcAWO1vC1G/7wJsyXzS5wUvIKPgsIk3mF9GE+3TBADfnpuu6jw+GqotP53MLwuMIIFQQYJKoZIhvcNAQcBoIIFMgSCBS4w\ +ggUqMIIFJgYLKoZIhvcNAQwKAQKgggTuMIIE6jAcBgoqhkiG9w0BDAEDMA4ECOqPrTHFEt4EAgIIAASCBMjL1Rzzem4ErP7OZ3gD\ +eqNEzUjFxA1QlPbjaeLka39JtgzcsBAyIyEIgou3TddDzffJqd6V4/08Ls9SmpngPGpYXP07q6Xl1eFjrwQ+jMathtFWSHCqGgnm\ +5D9+IFalz/7/rQv43vVTqG7Cw7VCSKr0ly1dZAvGRFEnP83Ffvny+spKpSpWUY8SsY16333jp3Afb/V5NyfsJETdghxi8d56lThi\ +sx4FtTAhKMNXSLenQOkgHnscBh0w7Kg2PNBHzSW7qHQDvr5oq8ZOqIe6B3M1Lxxv5nVzSZRgHbvyy7d9nUFiuGSPMVINffXF8Acc\ +zTIbpkuW5+pEpCGKOyOsrqE8VyTLMq5e7MRPsmqu/v6CUR8gfFUp0B4ovFmsDyWOARbtoWx5aK4bhJbKX9CI+F3dKaWL9d4VJnxk\ +cYZtRHIfbrPKEb5Kk6oO4V9KOdPaXfhXkeARhLFsAQ9qb6tX3w75qfEaAwAiAjUJVgFFVQ7ycL8qNUUAt+xVNYTrYa3qXDVlsfW9\ +e/ok+XvIAhOlHIc60ug7OUmxa2E9zyeaEptRVxl1rMWaV/s8ZAQZhNzvRtNWPXUCR/pMGGySbO6G3fperpZZcIJqQ5o3nifM7Vak\ +XFHIpESFfiCD+dcl/cMlc8hzVORVaGNIc0kX6nzpZXKzXEAawEYwCpEf9T2CtD345/lZzfOGgxMEnENZrqaJCNeTmPxcSFmWAkDe\ +GsG2E6E7wX1XpuIpLu42Ik14Vgwb4Z1n9myuLqxATbnkMljJsIigr8WcGUSUOnru5ZoHZzZWGZGvQ5H3RGmDE4tWJMF4ngzTeOU7\ ++lvfmdg3bdL/jIdamvWXBbqUdsvECX1tORGZHAyJSkCqxupHaaARrSwd5t6hzM4y+dgDK5FRsxofN9ulujTDQPoKa/GuQ8rfCSxW\ +02kL8aCtv1BsqitghPMOeBst0xAFLvOrbYO6BVJpZPb4SNR957M964DVbannOhnrxPU11bWsB7V0q5Bp5mHSYON1Tslwa0VR7JsL\ +IDSQdGvldj66GGEfu7TJGrIEypKAOF83iFW72NuIrkN9qBw4XAC7Bpe8F2gkpHqCRCq+BYktD4BSnNglERLh6QiAVdwqa9J1LlwS\ +G+Kkgr0wr8uTKX7IV6XCc1Y0ngC9e4sT019+LmolLUg2v/pLw9BX90BjRyopV5oo4sywEs0pQ+2814fbBqvhRLpMKSOh5mcKr0fK\ +eStOGl2varQ6xV3g7x4ZYxnQBy/XYTBDuHhEzpGDEMk/iH6xOlvYleeUW2XgeFzDQk6B+tlkbXeCvmGZB+u+cIYG5QbT4Ro/e2Tq\ +LbCjXs2WfpIKoO466vBipuVmabca+yZ8Hdb+3dAlAq857JM8uEbZ79cWmb7pf9kPJEOrZfJobWD9YtgkTFihDbkgc2gpVYITwI0r\ +dFkk/V+NGcNon/8hMVUW51vTw93bIR74YyhCMMdei7z43ReARvAn1hPRzCJLKDPO1Pg9+WzufeGlqCko5wM5sr/xNCADeaLu7ont\ +4mRk6qSRHew4oVsQaoNkxiR4OupMSyXg7QQCfuShv30GFKileLpdXPAs3k72PtAjBEax5H58Mewnz6VOsYV26+ASBeTazwXwC8mu\ +4VxlEwy0k26/WoYxJTAjBgkqhkiG9w0BCRUxFgQUhUMgqmwr3KcLWUAOClMasbTgADMwOTAhMAkGBSsOAwIaBQAEFAc6BlZhfHcR\ +gqNVb4hRy9Y/isasBBAmnrhSYOIWt0AqY73UNFmQAgIIAA=="; + +const NO_MAC: &str = "\ +MIIJnQIBAzCCCZYGCSqGSIb3DQEHAaCCCYcEggmDMIIJfzCCA+sGCSqGSIb3DQEHAaCCA9wEggPYMIID1DCCA9AGCyqGSIb3DQEM\ +CgEDoIIDmDCCA5QGCiqGSIb3DQEJFgGgggOEBIIDgDCCA3wwggJkoAMCAQICEwWY7mm9ZFkbsOorJB5uhnxOV64wDQYJKoZIhvcN\ +AQELBQAwLDEYMBYGA1UEAwwPRXhhbXBsZSBUZXN0IENBMRAwDgYDVQQKDAdFeGFtcGxlMCAXDTI2MTExMDIzNTczNFoYDzIxMjYx\ +MDE3MjM1NzM0WjA6MRYwFAYDVQQDDA1BbGljZSBFeGFtcGxlMSAwHgYJKoZIhvcNAQkBFhFhbGljZUBleGFtcGxlLm9yZzCCASIw\ +DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMUK1lXyl11Wa8nm/71zx548b0LNAi/mAN4gqxEV1ykHT2rpfmLHOBe/9jzNtib4\ +xFOq6GyQEI5uhyRitnwsv2cyQ6Q4BMdXzlGd7kXhhX0CUnG/a54A99qu1Kwwn5bsxvv1viA0FtwENk/RZQfAAZIof5MlZxTmUimR\ +74/wfpSplA2tVr1l27JYkTlcwEE75oTGHngMVcL+somdViVwL8W8g0XmrSR+guSF4lLadxE1dIv0kiW5hNIU5eTcj/5X/SkGDgvt\ +u7K8sXGk5czTLgPdIztVhWNJUgBF7DW8IvI9bFuHBIqe+ua2vWNPDCnHvHarblzP8I8K5+9DUqdx1uMCAwEAAaOBhjCBgzAcBgNV\ +HREEFTATgRFhbGljZUBleGFtcGxlLm9yZzAOBgNVHQ8BAf8EBAMCBaAwEwYDVR0lBAwwCgYIKwYBBQUHAwQwHQYDVR0OBBYEFM4K\ +BwgbSCFFH9KVBBwDlUFEN6DkMB8GA1UdIwQYMBaAFANXYErplgDksqE9CKJD3y1Ia/smMA0GCSqGSIb3DQEBCwUAA4IBAQB4ZaoH\ +YTiXV8YNiQDcC80L113hM18buMihpyRvWYvfa6IRebJhJDV09KmI1hDP1x8sp0eaMxrDeLIZZHs5gD5I6kdUmIsWGtE4Igo5UmJU\ +PrcYjcuE7VtmQ9tzwTBgFL4scwkfZbAa43+fZe/BqndyMs2CMxAKcMV7jzw/LbrLEI6BP0MXqQ/B9wj0VcwV0prs9MxlYDbTbS0F\ +r+A+tX+0VRE39IFKo59Xs7t/9IodTBpMxIWhVZ7Ukbh8NyhE2NRM/y6czTPsO9FCC/zPF2U523812v+fkc0CnGS62kEujmRD6VTl\ +P1eHQ049OEjzCU/WHYdL9VFFoWswb87G+Ae4MSUwIwYJKoZIhvcNAQkVMRYEFIVDIKpsK9ynC1lADgpTGrG04AAzMIIFjAYJKoZI\ +hvcNAQcBoIIFfQSCBXkwggV1MIIFcQYLKoZIhvcNAQwKAQKgggU5MIIFNTBfBgkqhkiG9w0BBQ0wUjAxBgkqhkiG9w0BBQwwJAQQ\ +plQrIjqtb1mmwuPxoJsREAICCAAwDAYIKoZIhvcNAgkFADAdBglghkgBZQMEASoEECBNQ0E9PNp4Ldl4bt+M5zUEggTQAAIoW4KR\ +EhQManAkJRk+Qd7hNcuwIuKNAWevxRC/6fNNgWt3Sxn3dLs/NTuv29nSk9FSlnGMV8v6PyuRKWHPnlobZdQqJI+SRNsyAD1uRpFE\ +0t8bhpLbR+qiIuyiRNhujUnCyccs3PgQnbMnCgKYkL75Bnd0edHCRvtxu65T8cdaQZhpXqLJWwRi8lTT/xiN3Kn3krJ1J+6vnI73\ +WUQIK3PtQrGzpW+gHOeburYFHiYSDfUy1GF758R7Di//fsvd68i2RGNqFPygi3OU0uBu3eYlv0GwlbWHTRYc6dLTcalnHH0XKcBp\ +RElCVLl/phAmSiXAre4NvPkLCNlS8xfhhfOYr5bX1a9CE6TWxU4C0S6i4e1q7X7d78mD7boH2/SJ0VbufJJOoHfScReUgi3P5WKp\ +0lKvO0mPc/hlTvyq9oiYDLk0Gi0v26t7+prbuWkkAcD1HtQLwGIZjq3HyRcBT2hwx9B6VM0VS/4uSsxr6XwP2fvCI8tDLokBw+Ts\ +EAQbLR6Ozjz0eYuKnrnC4+/Pjn7TX1JvDGISZAbKNVsI6RrL/iZUbushmso78I/bg8cENE7ipGwTwYGMiZZ5+9oMKvymkowpOBr/\ +u78hppuWcJMCmty/5EtoEDVhImb6hPwJ7dY4k5ZEHl2tsweOgSEmlkzxh+dMPQPeYMc/+2VcxysDxNjW5jiaBbXVWS6XgKc/VJGu\ +29JHTN4KYdoQorWUuMBNAt0vLF+pJb/3KtgfHpZ4i6cJ28skain5RTSjXiL+RY1Q4zyKJgqgrCyMRvgXXUviEtjLIUrNdKsgPVP5\ +iV0vGkFB7/DNGn88DzEqoEGczdarU1dEsHN334swHGF6ZGdYXTfxeQu1rx5tgo1ObXcrrHYAmi6/3vufK1p/WMH2t+VzdJtR8Bjz\ +LxbCiEeaXAw8ZW3g9tClnYwdizcSq2tfmLBqhD57ydAjBjOKj8m3XwqPtk8rzedyZF9NDXPq7kqHIWX+RAtpyd/7HWHz44uj7fae\ +kYPyy1KsxMd+LlKc4BIHPmCnZ5Lk/uSvEVH9VuNoj87OQwHSdXTEQl5EA1kjeXXi7qA0OulEyVgiYwmIL8xwGDpRunC59TxYWFQU\ +KPA56IhG7jHq9owAMws5bv3XwpZAevik2RqBMoqitKSJiNUWeQZ3ILXVpvqjW6GNrFg9GRHqO3/bA3LIziboCohWLasMXywIhyaY\ +WnePvvvKouwkhLHjK5VJj71KHY3T91ULhmI/iDx0PdUgdcTH+pAX/Ogj6YG+vxnEUg1V/hZLsW5hFavvenj0iEzc+6qJyvKFpjBu\ +Rk/FBwebzYB/UJ016t9hDqyk27pnEbn8DHmsS4zCQ2IQHV0iiI1CVZALVf0yaZ4NDE/bkLBIiCUajUImzFvq/8YWYHN0RwbbtG/V\ +KJzAOHrot7pQlJy2cJyELhdbuNuPwEB/S86OwEsDIU4Ku5hF/c+WUdNKm646DsZM28EZlcq9jR+mK2x/prErV0jZcHrWaEF+n6FK\ +yEc1u/4obH2RCOK7mKQQIuTOc3JhEOcYAFjClm2OtcSanUccDT+yIBwiDkhLteXMH/GZ4VF0AXHWWD8uGZviUq5wunG9QVtlUQDz\ +Uvr4Oob6RK80S2zz3PCqwquX/vyuTIppXoYxJTAjBgkqhkiG9w0BCRUxFgQUhUMgqmwr3KcLWUAOClMasbTgADM="; + +const EC: &str = "\ +MIIE1AIBAzCCBGIGCSqGSIb3DQEHAaCCBFMEggRPMIIESzCCAvoGCSqGSIb3DQEHAaCCAusEggLnMIIC4zCCAt8GCyqGSIb3DQEM\ +CgEDoIICpzCCAqMGCiqGSIb3DQEJFgGgggKTBIICjzCCAoswggFzoAMCAQICEwWY7mm9ZFkbsOorJB5uhnxOV68wDQYJKoZIhvcN\ +AQELBQAwLDEYMBYGA1UEAwwPRXhhbXBsZSBUZXN0IENBMRAwDgYDVQQKDAdFeGFtcGxlMCAXDTI2MTExMDIzNTczNFoYDzIxMjYx\ +MDE3MjM1NzM0WjAWMRQwEgYDVQQDDAtCb2IgRXhhbXBsZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABFTBl+in37wcV2KoZBpe\ +8HdIa3I67Y9fM249azdt06A2enfiMt60EGb1OYAn6qD/7HBmfSt++w736js0fPFRj6CjgYQwgYEwGgYDVR0RBBMwEYEPYm9iQGV4\ +YW1wbGUub3JnMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDBDAdBgNVHQ4EFgQUDX/llMpNqwOzpdvg6ZW6gpow\ +7jkwHwYDVR0jBBgwFoAUA1dgSumWAOSyoT0IokPfLUhr+yYwDQYJKoZIhvcNAQELBQADggEBABUyJYbCAXO4DRftivaELtGfecBe\ +lAyblNSgoObqXGpjfDbP4GR628maNzFSCSNpT9GaBtY2nsHyqwbTBbrZcrbXrE8IXhyF+QfXW4KjQXd4zl/VDL79lv997I2ocl/G\ +RYq8jMPO22zCDkzJW/ihqgTw77YfuJy3TRG1KFDCYpt+N8jy+ua7E8nVCcjAUIGdyoEZFJmvznih0qh/gAZrHH1JF3dvgmml3R1E\ +DBY8ZueV7uMWcBGHKwc4x+qd8zhyfvKibwl5Xd/NhtBqclmgKTR2IoZA4tojridkfdzmnrB2acqkp/AEByd9E8axNymFFExtlSrE\ +N3rxIi94y3IQXgcxJTAjBgkqhkiG9w0BCRUxFgQUjInlR11rxzqXIkizr2OoL11D9JIwggFJBgkqhkiG9w0BBwGgggE6BIIBNjCC\ +ATIwggEuBgsqhkiG9w0BDAoBAqCB9zCB9DBfBgkqhkiG9w0BBQ0wUjAxBgkqhkiG9w0BBQwwJAQQqWdl82FHAGkVnnehJZkd3wIC\ +CAAwDAYIKoZIhvcNAgkFADAdBglghkgBZQMEAQIEEJgmrQYD1UonngDfy0Jb2UUEgZA+uRWJCzYL7FxB1NaX04qn17h2kOUbLwAT\ +MC2Qj28y4C1jXfvwP2/jJ66n1CYMQ5jrOyp7b2kn1CF3jYyfvUcuy1eRX5re20d3MO3BvVyJLACAwfNrG3XQhPBiqhi238zukWbC\ +Ub4PuKJIQ/w7Ro4e77aBGzhH1WN2okRbfbKJNwGO8+oD40su43K6/Pyg2ssxJTAjBgkqhkiG9w0BCRUxFgQUjInlR11rxzqXIkiz\ +r2OoL11D9JIwaTBRMA0GCWCGSAFlAwQCAwUABEB4m6CI+/V15b2q/hZZfc/EPIUaI48ZKAFYhEF3kRVR2NvgJt69KYUM0148qW+S\ +ddMTgHUukfMFkYfvSNHlPoByBBCW3D8EXEwst+W0w1AVuNT1AgIIAA=="; + +const EMPTY: &str = "\ +MIIKZwIBAzCCChUGCSqGSIb3DQEHAaCCCgYEggoCMIIJ/jCCBGoGCSqGSIb3DQEHBqCCBFswggRXAgEAMIIEUAYJKoZIhvcNAQcB\ +MF8GCSqGSIb3DQEFDTBSMDEGCSqGSIb3DQEFDDAkBBDF87jePepeWTUT3j7S2+0SAgIIADAMBggqhkiG9w0CCQUAMB0GCWCGSAFl\ +AwQBKgQQMtr209mOOryP12JAnbtuGoCCA+ByOsav2ReVfVr96Z8DrUpT7Yk491/QW8XjxxzhgZjZ8Vomefv54s/bqm7gd3q9ygOl\ +VMeA0zyOAvdnjFcy65fdJgAsjfj7p8rR46PWk8LsbV5OGgaueG+hDuNNwydEswqCrAN6E66X3X4zADJTzTLU85bbFdMGmdZ86Oly\ +T4eXoQOO9Fc4Sxl6CDMYsSqXft1bdl9byBazMjSpZuvKu+B4OwJx/u7g8f88QoMzRwnai82y/Dn9+aqg4cPq9deK308Yaq7Q4hML\ +uNHfpwUYjbULLBSq4NAzh0brm0vhjcFGJdjKi/S1KkiSFG7+xCzTPU9SFJ7AU/hti1Pe7ibP37dFm4IiYYylkiwNAPQs3q/P6sBc\ +rBYOT6Dyg2e8sQlXvaLp3B/cOheP6vU2k6WbM/2RePREH4Amx2qVdrXvNEM+i1TXMZXdurelNAS7DaG0gyGhmwzeyxApH4QqwNdv\ +DkgkW+sUONsxgJntlBNKEOyiRxi1YYCCFPgtbRucQ6lUSUjnzRr6HiuYApEk71aW/PZAMVhGKnJuoye2K59abhCyH8kxdz/umFzd\ +PNOm5Bjf8oOTtrmYP7JpPcVrDbYOUtJnzhPZEcg+SE9p1gt/lx6GjvqE8+/tZKgSNtd99xFNMat32Qbn8HG75vu0xcq8aVrN17qJ\ +fn68gd2UfGDsNfNwVcIWlTxsMlWHDfCL4QN3af4oFG1phxdMGlID7ALLcnC5VHc2fBaxH4DXTP2mriGGR0NMoZaZTqwyk16gbW5S\ +5bK4AvANC+ej9+PjEEYoHCi5T5Pad7HhkRUHyyrqN/jc+idS8JIzQoSwIH6+PGaDjofhaxr7LtKODmQ3nIAcUMs7n5BqPdcC318H\ +G9NqJ6zvAsbImrWVVYUkGhvA4T3qFqZqUgEzCf0NmTpyb0FHkGwSsmHlMdqr/DhicpBE3TU8Z8NJZOyYplaVRqOc3dRIGuzLqg/1\ +32+qblfFnE/9XidGQepwCMumitELsptymiU1FwdRfLSQjIf6DVbHAy/37RtttDHTrHTK2W8EqCiSSCSHZ4G+ORgTt5jZAn4VQbnC\ +BdtBwky2Cf/afKJYTgmV8He2KJ2DTzRX2APCQ4WRxu5wgnXA+aB/RwJyaXW653X0zh34tuaWTgikN8fJaeqTXq1cSc++vyDGVCpN\ +V5igIWfeNi7bUab6+BaBLxyJ0pIlJtGE5CuVf1bS8vx9/NcA+lyLNKuRNZAC5roLuF+ZcoviCjiVqhVpi6vMo3LjGKxZ+Pc8zl+w\ +G4W28K7Af2ZifdxR9H+5Rqa0ZiGFJOaS7akFeWHuMIML0ghkLrp0C1oG1jCCBYwGCSqGSIb3DQEHAaCCBX0EggV5MIIFdTCCBXEG\ +CyqGSIb3DQEMCgECoIIFOTCCBTUwXwYJKoZIhvcNAQUNMFIwMQYJKoZIhvcNAQUMMCQEEBwwyhmnKSJx/KzrtErA4x0CAggAMAwG\ +CCqGSIb3DQIJBQAwHQYJYIZIAWUDBAEqBBDf4dc8FXT+aYODSe2aT2gyBIIE0PsozHos8DialF+NaxO4hOL1U8n9PytgmrFH7MmM\ +HMVc3ScUVcgyC94+ZQjBJ3JWOjDo/2k+aH4c3V2k85+mXutBQU+idGNz8gh1DjHKWri8oX6SaogwG0dIVTpgAkeSVApXI1Tdzb7d\ +wxazLFIlFveL2bRGMGPpspMLgF+079AsL8phJ+EtI7G8kONL+406KYqIBr0nsqXravDIIFppB1pX83UqsBEs5Mxgkqh2P/Z9PXyQ\ +1zBCTofzXnwDISsM9WgVZfLyOSchUaO+LXnfxNAsSzm40nBn6N/s3k//JYWzyGQHIK0i/0C09J8AbiS2sGQd2tdDoEYofqECeMRl\ +JdjTv0wmJUMJldjSStDKWVNPTGBiGElWaNmDfhJrTXqIcVvoQRJZHvjCTqaYNqj12Oise2Y4p+u39U7NIVr3P1NoxdV3btaKUczd\ +MtqML1dHQJ5/0KlZBR9KINVNu7XpQpcgEu/KaGEIn6JILvQs5ISjKNmahNsfoCpUGtfV3xF3JzwRYrT9dzL7mr9Mv3s7ArZ34n3m\ +AqrGBGX6gQieMzYAtEJqUxtoNDck3SUNlgbWGs6Z9LHLrnMcCxN+k9xeanj2xnfaXNzCEcjzECvFHSr+RTCR6J+3sLj8QcAN0Pel\ +BjJICGrNHyyo4SqbixYYYe3iRpKFedTEC8ydoVmmeR7MtpSNg9K7a9fbd8cRwb/xCbi2u5t3/kFKy4UAeGVme0Tq95gvGai4/5nV\ +WkjzyXT1BPrnUIszrp0UNTs8MP6oJ1ndvKD4odlAdpQU0Ctl/eqQ+om7kqmWkSFIjUrex+YUv03euMsmUIqu6CpgCCcPV+SKHmU3\ +LPnrGH+oVYU7bPYQJcPfvL0lgcWeDiTp7AHOTB/qxEQ0OgjFc+JjNrmDwhV8qgjvAHtXRJHhRseBEWJs61IHtZ0JMvap53WfIKEn\ +IF0EihMfU1G3ht01uH4mBbUelfItlS9NGrMT+fXIy/qCB8a00doLv6b2xx2s+TBj1F1tXRe47ozNtWKxmTQw3gFhHoXXdRFX+XNa\ +5H+Qm6uGagZp58JQ0ybeit3p1Ck0TO1jYRPeLW1CW06kHCHFsvoYebhGtd9WqNk9KygjVU2h9aCg+Z+8c+mZ3nqxHs0VPMMNGrGE\ +TyUS4TechVigtVMJmj/cJA1Mme4eVyl7W2bdSvZntX+y9VTFMAJk8IHyxN6gOwvHgh/YfmvZQw/6ziL4BwEDcSVzJIGBW6X6PxcN\ +4gQ5kZhfshXwUIEKRebtmo3fTKn8D2WhUVbu3nge1I2G46ol+F2eZMtQisgjbAAxbGLr5Slz4SxijMrVgo8QHXXQhwWU2eeyCrTF\ +PKBUVHQG9CzNGRHsMmEmYk6WTyozR5ma2epCTYRPhR8fUxHxdjDuc/5qEWjPBg8m0FPCo0KbIYuhpZQTl52QRH+0mMs61kQsadow\ +bGTs+NMLOk10piUoMTDjz7A5vJwI5cS4WYmWALpIOXCVwSMLs97yJDOmFj/gFx+vbyn6W9rciQljO93vnpt7BvSUG7RQNufkePDZ\ +3VazbEmFWY0kvdOJDCeUF+AfqiOde94mOY5MNQx377q2yuBH4RNTGgY99r7/dJVd1/okNuLtK9wulLxqnZuV/iUDoF/egG4Egisd\ +Z+MXMSUwIwYJKoZIhvcNAQkVMRYEFIVDIKpsK9ynC1lADgpTGrG04AAzMEkwMTANBglghkgBZQMEAgEFAAQgcAZkx5WYR7XZrovc\ +Pgmgw0IuEAIj4FjBS78Zv6IAsScEEIk50Yy2OM0LI60aLfWObdcCAggA"; + +const SLOW: &str = "\ +MIIKagIBAzCCChcGCSqGSIb3DQEHAaCCCggEggoEMIIKADCCBGsGCSqGSIb3DQEHBqCCBFwwggRYAgEAMIIEUQYJKoZIhvcNAQcB\ +MGAGCSqGSIb3DQEFDTBTMDIGCSqGSIb3DQEFDDAlBBB8ks0TJ1AMoB0niaJzWOWJAgMehIAwDAYIKoZIhvcNAgkFADAdBglghkgB\ +ZQMEASoEEIQXlt2LpA9dPLJrIQbhjeCAggPgg1hhBenojqTc4iWsTMD37yvBa3dFNQUUB/y9ZLKMbyTRIorQx2API8WUpRqTQJHi\ +ad8BJgN8eUzaOFQtfpeCqeq8g/el9aJ/wiVDdyPWn8bEIa7bKSZUvC5Ei4qun29hHuf0GsEf38TjUz+Vwv+d/VxAnlNQrANGnZ6U\ +qNU1VQSNPhllyJnJGKhOkiCyv+7zn8518laLYcTj+Q6dGl1dINstFS+ve8BFmYv9236f6TNpDPu4n94CyUit2N6Hqg0LAVW6I0ct\ +MXoo6+7x3n0YgRzHNqo7XjfiRY96g2xb3lUJWCaHN1deVgJ1loGLrZZY1AYlWLtvUENZKC+Kwd6YpZbPydB27OApQc2sVkJYjp8T\ +9GDZ86fdIkNlfrKint59TniWPI7IPvXww27v2SHl828ADvaTR2XcS82QOqqq5INMYYRN9Kg4rjzwV1oWmDWywh8vD7cEIbbXzsBj\ +UexF5kzrjpe+j5/VYdA1VYNaERd0RlJqSXuyVxlvCvPziLzeADOoPT1lbVuloxaRNHTkr68hedHXh9Qju2YNUo+P7IbS4HXC6Nh1\ +m+8bjrRzVlA/MsLBhuxkwDv58z7n2B4iLJpu93/ZkxxyMPJI5cMg6ikeNLTmFj7vTxSb8uj31L73CySnXSlhi1CkKHCeofM6cKP+\ +DgUh5f9Axl91e+MOaNpxxZ6rxVaYMmtuzruDeABCRp2AxdA9eo5J2ReC6eHwNwDwVaECI8V1/tfdzdTTbbOD1YuaQ5z2mQgUx+C1\ +mqfVXJgWTnkUgNuwoFgOUJGQfAWuOjcZIaXx7slg9r7xQwitHnc1pn8Lj1ZB5l1ixHxn09wZCoLGhYbgR0fPEp/VQY/RlQZifxnF\ +Nc9LP6U/+qq+VbRmJ+wn7D3vcJ5/IMfOwrzYHBE2PaJLizpMR83W4dPVcOBLyogMowjkPoMFgnDzDOdlxi4Q1yaobzsS6VvnuD4Q\ +R1ehKNDG/x97CzgsFiovUW8KZkXacq0GtOUC8nuUI3O9d+HqBAPejfuq5A51r2pmn005DUCim9AEXYMxibVVqQ/qq2j9YkbRZ0gL\ +7XPiI2fxgR5B8IoZ/vbIopoy5BNhzVMRTGxLSOLLg3Y9gpdxojWS6Vg7Y2rD10UhbjIaMXMnXm2jOQ8Wv3NE5WfHotkpDV1MEEiH\ +xKn0pFByBi+WGIz/fjb6+DZtQ1JqHZZxMTSSOQcC8Ctv+Nlyi8MOxgMXKmuppKFiQxfZxgs/BRGsSY26HlohzkajQSb8nvsnx4er\ +xStV6ylCfQN1miQu1WmBWMa55v2b6YPfq3COIMVWqp/M9vlcdULkgHj23uUwggWNBgkqhkiG9w0BBwGgggV+BIIFejCCBXYwggVy\ +BgsqhkiG9w0BDAoBAqCCBTowggU2MGAGCSqGSIb3DQEFDTBTMDIGCSqGSIb3DQEFDDAlBBAchZc1zQburwsAUAl9cukPAgMehIAw\ +DAYIKoZIhvcNAgkFADAdBglghkgBZQMEASoEEG6e5jeQsIVVfYE1Xo/vFtEEggTQpHmb8WWB5X0x2w9LAUs2s9HJD6Sn+TXkOLAg\ +Kgar2eH64/QfaaLyapDTTU5utuJlLYLuse5MmqD2Z6/rzTSNkDidMqhWaORB1AJYuz75BU8l13E8B9oLbgnGeo93XAtAyD+sTQ8M\ +kjc+LyDWgakOLYPLXGO9gPWdMc7qrn2PS8LRpjR7i3TPIJRmIwAiddGr0dZW8uEJke7jFTGkDdyGkR0VF6EeHhYPKQBTVdtqN7wI\ +BugMxrqNbrQjpiZezs91HGcvQK7POy6FGkYtmvjgQuNOO4NEbtXNCG4V8XTud/PgO3i5OEQRioj9TaNWclgTsn5R6hNoULijFYJw\ +jOKAa9MqquQvYoKXE3YlW0AccgpiHBF465DO+TO36vc2Ocy58oCIzwxObK34nbNnHpmQ4fwXtf2u1a43FUROd5d2RN0gCOUrmqdK\ +uPMYABQLgqFtYxKtaNrTBt0sMjdhksW6ttREJiudv8P5Zgo8Lzjrjwp8PSO05Dux5IxOOgnRlG9nl34PysHl5domXrNfs54/iesS\ +f3WakBTSEs5Of4itSRub9cpkMWYlBJ1TmliNBJHibytBQTgGiw2nPIzGlSMDkMQ8TZGBt2LCW8KBKc/4gJHi+AEOS8p5mIk+9DTv\ +Vm1l+i8ljwELfWkFVeHZZ0MKnd4lJY743H4KKvZMT+zMw0OKg7c5Oag9QfXNyBKh2QmgimnM/5Zu1f6DDju0QqCSDov/1nPJ3tdj\ +imCzIh3UxvuM9crzic4qtsQMQz0tNPqZJ2id/icRv4cGNepKUawoS+AcpKDzuMaqAOFWMbSt7WRHONdLbyylZioZQlXu/TaA9Hcm\ +1JItzMDxFh4ZqW9D7MJPs50Zn/aRK3xV5ADuAKCg26WSt+9svgrZS3sG6bF2dVE8M6tV8qz6ljkRRiP5a5YfpmffP/mA//FuKsPH\ +8JoIURm0jLzDF2Cyj2Xk/0HJFSDkbfI4W5O6Fe62QA6hTDlOJjd7eGSCV52u3OUTNK13qMFr8ZdaGfdpMKxt2x7WEufoWbju7TtM\ +4a4bM0AoN2ob2iziC16E0GZQtqVy4is5U/yUs/nLkA1rGdvwwcubIiTaGuI4cmVeVnMqBEp6TFH6WOYSadWmfN2RzMe5gDNFGMJb\ +AUgA9xdwzKRO7C/9fox4PQ2EnVvX1NwzcexeuTE15c0ry3/N9J2CnCmaVZFHyicQYaTOKGPi4bX1ZGSblJwHoJPS+Wm8rfYBXwK6\ +hjmz1SKSt0Eh0e8oKwuM8RwJnAN13lScGT0AD668PaOgzSK3WfMDSJMRJhvzTRmpHc4/eOIa8MbG8rkNm434k7E/jujaWbMAAWCv\ +w2UnOzqmba9buKNE62tSffWE+45pO/9grKFk/X7r6W2U3ECc66iV+NcP+4oLLX4x/w3Oi62M0PaWilWgVgpMZCur3tUb1O9eap8y\ +kToB2qBP0mgYlKbwjka3i1eHoPt472W0+D/ov7PqOt+ZbQqZLFCmXh7MhvNf0K2HrycL7iSb1SSENg3AjLDzbKwQk0cjm4Y37l5x\ +JzLgdnICu18j20yHZzPn7iNUMhQZGn/miKChpNbjOfn5eOdxfHb2tuNhGXUxcIFPHc+llSAae5dNQOx9jdJGIa/FSoZogWVweM8L\ +70AvjLgxJTAjBgkqhkiG9w0BCRUxFgQUhUMgqmwr3KcLWUAOClMasbTgADMwSjAxMA0GCWCGSAFlAwQCAQUABCBSwdTuQqfx6oMN\ +oRpM+476CU35vPBZAg7uDRQ2W0rxuwQQlBfL7bD0DVRjC7ff7DCBfgIDHoSA"; + +pub(crate) const ALICE_PEM: &str = "-----BEGIN CERTIFICATE-----\nMIIDfDCCAmSgAwIBAgITBZjuab1kWRuw6iskHm6GfE5XrjANBgkqhkiG9w0BAQsF\nADAsMRgwFgYDVQQDDA9FeGFtcGxlIFRlc3QgQ0ExEDAOBgNVBAoMB0V4YW1wbGUw\nIBcNMjYxMTEwMjM1NzM0WhgPMjEyNjEwMTcyMzU3MzRaMDoxFjAUBgNVBAMMDUFs\naWNlIEV4YW1wbGUxIDAeBgkqhkiG9w0BCQEWEWFsaWNlQGV4YW1wbGUub3JnMIIB\nIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAxQrWVfKXXVZryeb/vXPHnjxv\nQs0CL+YA3iCrERXXKQdPaul+Ysc4F7/2PM22JvjEU6robJAQjm6HJGK2fCy/ZzJD\npDgEx1fOUZ3uReGFfQJScb9rngD32q7UrDCfluzG+/W+IDQW3AQ2T9FlB8ABkih/\nkyVnFOZSKZHvj/B+lKmUDa1WvWXbsliROVzAQTvmhMYeeAxVwv6yiZ1WJXAvxbyD\nReatJH6C5IXiUtp3ETV0i/SSJbmE0hTl5NyP/lf9KQYOC+27sryxcaTlzNMuA90j\nO1WFY0lSAEXsNbwi8j1sW4cEip765ra9Y08MKce8dqtuXM/wjwrn70NSp3HW4wID\nAQABo4GGMIGDMBwGA1UdEQQVMBOBEWFsaWNlQGV4YW1wbGUub3JnMA4GA1UdDwEB\n/wQEAwIFoDATBgNVHSUEDDAKBggrBgEFBQcDBDAdBgNVHQ4EFgQUzgoHCBtIIUUf\n0pUEHAOVQUQ3oOQwHwYDVR0jBBgwFoAUA1dgSumWAOSyoT0IokPfLUhr+yYwDQYJ\nKoZIhvcNAQELBQADggEBAHhlqgdhOJdXxg2JANwLzQvXXeEzXxu4yKGnJG9Zi99r\nohF5smEkNXT0qYjWEM/XHyynR5ozGsN4shlkezmAPkjqR1SYixYa0TgiCjlSYlQ+\ntxiNy4TtW2ZD23PBMGAUvixzCR9lsBrjf59l78Gqd3IyzYIzEApwxXuPPD8tussQ\njoE/QxepD8H3CPRVzBXSmuz0zGVgNtNtLQWv4D61f7RVETf0gUqjn1ezu3/0ih1M\nGkzEhaFVntSRuHw3KETY1Ez/LpzNM+w70UIL/M8XZTnbfzXa/5+RzQKcZLraQS6O\nZEPpVOU/V4dDTj04SPMJT9Ydh0v1UUWhazBvzsb4B7g=\n-----END CERTIFICATE-----\n"; + +pub(crate) const CA_PEM: &str = "-----BEGIN CERTIFICATE-----\nMIIDSzCCAjOgAwIBAgIUQiksTfPBn790EMSMwNs3Jn0jaiUwDQYJKoZIhvcNAQEL\nBQAwLDEYMBYGA1UEAwwPRXhhbXBsZSBUZXN0IENBMRAwDgYDVQQKDAdFeGFtcGxl\nMCAXDTI2MTExMDIzNTczNFoYDzIxMjYxMDE3MjM1NzM0WjAsMRgwFgYDVQQDDA9F\neGFtcGxlIFRlc3QgQ0ExEDAOBgNVBAoMB0V4YW1wbGUwggEiMA0GCSqGSIb3DQEB\nAQUAA4IBDwAwggEKAoIBAQCLZYmAht/KhFBvK9uNCHWCQ0viLErOUqeX1aXmT1gD\nK7pnO17kenetbfhEY1tBB8bvhkLYcW+A10RZslY/ZMJsf8PTHA+B+gZB5GdIDtAC\nASHTmiBJIr9bdJiD+eZ1hDNfSvXm2dlF7qEnaaUj+GoowKnyqkGQ4EbfFcVT1rJR\n09Gx1yu1Ti5gKG4/BoAZ9Q/Ho/TGKXhCOLbecWzFzFHMbwLU+oY5rVjibp/FVbwT\nC54cuuqmwS1z+t/ABBvIUv5cVZloWXcoe1Sw2KSN7IaGGM3ziCSDBM6RZiUsD/Fr\n6CkW5m2c+XPOSTwfHPz8h39bCITS0DbB86fXDy7kZQTTAgMBAAGjYzBhMB0GA1Ud\nDgQWBBQDV2BK6ZYA5LKhPQiiQ98tSGv7JjAfBgNVHSMEGDAWgBQDV2BK6ZYA5LKh\nPQiiQ98tSGv7JjAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjANBgkq\nhkiG9w0BAQsFAAOCAQEAaT1BKjztiC5bgQ3hT0zRsqSLXlzGGRYAMC49eLPAAPvO\n6CL+ZPvNByZKTRy6pt+Tr06nbj7YH92z4xO601vILQBmBwwhsQNMotKDZ/Qedb8t\ng6maxc83l5rKOR/XHze6nIoFQR1uYWrvLT/JpwTZ9SfDk5pbMVCRyExACSAQL3NF\nS1boSb2RndOIHAcwKUF7uEYm+uoMbttCFcFZTcNcO1swL43/562cJ8w2AWwCBv4j\nz0Kcna6idZx/eTZxkHizZwMGzJL9Hzbvui0gPBu0RNAbBUTeJawC/1IOEFQq43Fj\nMxttmH5D5Ax3nffhFlrAH2IgjiHTI+IbzIzNR1J0Xw==\n-----END CERTIFICATE-----\n"; + +#[test] +fn matching_local_id_cannot_override_a_different_public_key() { + // Both are 2048-bit RSA, but the CA certificate does not belong to Alice's key. + let key = rsa_key(); + let alice = der(ALICE_PEM); + let other = der(CA_PEM); + let alice_key = crate::cert::Cert::from_der(&alice).unwrap(); + let other_key = crate::cert::Cert::from_der(&other).unwrap(); + assert_eq!(crate::algorithms::key_kind(alice_key.public_key()), crate::algorithms::key_kind(other_key.public_key())); + assert_ne!(alice_key.public_key(), other_key.public_key()); + assert!(open(&plain_p12(&key, &alice, b"same-id"), PASS).is_ok()); + assert_eq!(open(&plain_p12(&key, &other, b"same-id"), PASS).err(), Some(Error::NoCertificate)); +} + +#[test] +fn ec_key_pairing_is_derived_not_claimed_by_metadata() { + for algorithm in [&rcgen::PKCS_ECDSA_P256_SHA256, &rcgen::PKCS_ECDSA_P384_SHA384] { + let key = rcgen::KeyPair::generate_for(algorithm).unwrap(); + let other = rcgen::KeyPair::generate_for(algorithm).unwrap(); + let params = rcgen::CertificateParams::new(vec!["example.org".into()]).unwrap(); + let certificate = params.self_signed(&key).unwrap(); + let wrong = params.self_signed(&other).unwrap(); + let pkcs8 = key.serialize_der(); + let (info, _) = craft_ber::read(&pkcs8).unwrap(); + let fields = craft_ber::children(info.value).unwrap(); + let (inner, _) = craft_ber::read(fields[2].value).unwrap(); + let parts = craft_ber::children(inner.value).unwrap(); + let without_point: Vec> = parts.iter().filter(|p| p.tag != 0xa1).map(|p| p.whole.to_vec()).collect(); + let omitted = seq(&[fields[0].whole.to_vec(), fields[1].whole.to_vec(), tlv(0x04, &seq(&without_point))]); + assert!(open(&plain_p12(&omitted, certificate.der(), b"same-id"), PASS).is_ok()); + assert_eq!(open(&plain_p12(&omitted, wrong.der(), b"same-id"), PASS).err(), Some(Error::NoCertificate)); + + let other_der = other.serialize_der(); + let (other_info, _) = craft_ber::read(&other_der).unwrap(); + let other_fields = craft_ber::children(other_info.value).unwrap(); + let (other_inner, _) = craft_ber::read(other_fields[2].value).unwrap(); + let other_parts = craft_ber::children(other_inner.value).unwrap(); + let point = other_parts.iter().find(|p| p.tag == 0xa1).unwrap(); + let mut forged_parts = without_point; + forged_parts.push(point.whole.to_vec()); + let forged = seq(&[fields[0].whole.to_vec(), fields[1].whole.to_vec(), tlv(0x04, &seq(&forged_parts))]); + assert_eq!(open(&plain_p12(&forged, wrong.der(), b"same-id"), PASS).err(), Some(Error::NoCertificate)); + } +} + +#[test] +fn legacy_decryption_uses_the_empty_password_representation_verified_by_the_mac() { + use aes::cipher::{BlockModeEncrypt, KeyIvInit, block_padding::Pkcs7}; + use hmac::{KeyInit, Mac}; + use pkcs12::kdf::{Pkcs12KeyType, derive_key}; + let salt = b"empty password fixture salt"; + let key = rsa_key(); + let certificate = der(ALICE_PEM); + for password in [b"".as_slice(), &[0, 0][..]] { + for encrypt_safe in [false, true] { + let encrypt = |plain: &[u8]| { + let key = derive_key::(password, salt, Pkcs12KeyType::EncryptionKey, 2048, 24).unwrap(); + let iv = derive_key::(password, salt, Pkcs12KeyType::Iv, 2048, 8).unwrap(); + let mut buffer = plain.to_vec(); + buffer.resize(plain.len() + 8, 0); + cbc::Encryptor::::new_from_slices(&key, &iv) + .unwrap() + .encrypt_padded::(&mut buffer, plain.len()) + .unwrap() + .to_vec() + }; + let algorithm = seq(&[oid("1.2.840.113549.1.12.1.3"), seq(&[tlv(0x04, salt), tlv(0x02, &[0x08, 0x00])])]); + let key_bag = if encrypt_safe { + bag("1.2.840.113549.1.12.10.1.1", key.clone(), b"id") + } else { + bag("1.2.840.113549.1.12.10.1.2", seq(&[algorithm.clone(), tlv(0x04, &encrypt(&key))]), b"id") + }; + let cert = seq(&[oid("1.2.840.113549.1.9.22.1"), tlv(0xa0, &tlv(0x04, &certificate))]); + let safe = seq(&[key_bag, bag("1.2.840.113549.1.12.10.1.3", cert, b"id")]); + let data = |content: &[u8]| seq(&[oid("1.2.840.113549.1.7.1"), tlv(0xa0, &tlv(0x04, content))]); + let content = if encrypt_safe { + let encrypted_info = seq(&[oid("1.2.840.113549.1.7.1"), algorithm, tlv(0x80, &encrypt(&safe))]); + seq(&[oid("1.2.840.113549.1.7.6"), tlv(0xa0, &seq(&[tlv(0x02, &[0]), encrypted_info]))]) + } else { + data(&safe) + }; + let auth_safe = seq(&[content]); + let mac_key = derive_key::(password, salt, Pkcs12KeyType::Mac, 2048, 32).unwrap(); + let mut mac = as KeyInit>::new_from_slice(&mac_key).unwrap(); + mac.update(&auth_safe); + let digest = mac.finalize().into_bytes(); + let sha256 = seq(&[oid("2.16.840.1.101.3.4.2.1"), vec![0x05, 0]]); + let mac_data = seq(&[seq(&[sha256, tlv(0x04, &digest)]), tlv(0x04, salt), tlv(0x02, &[0x08, 0x00])]); + let p12 = seq(&[tlv(0x02, &[3]), data(&auth_safe), mac_data]); + let opened = open(&p12, "").unwrap(); + assert_eq!(&*opened.private_key, &key); + assert_eq!(opened.certificate, certificate); + assert!(opened.key_encrypted); + assert_eq!(open(&p12, "wrong").err(), Some(Error::WrongPassphrase)); + } + } +} diff --git a/crates/smime/src/tests.rs b/crates/smime/src/tests.rs new file mode 100644 index 000000000..0b9c83948 --- /dev/null +++ b/crates/smime/src/tests.rs @@ -0,0 +1,1104 @@ +// SPDX-FileCopyrightText: MailCraft contributors +// SPDX-License-Identifier: MIT OR Apache-2.0 +//! Checking S/MIME Digital signatures (#30): fixed vectors signed with RFC 9216's example +//! certificate for Alice (by OpenSSL, `testdata/`), and certificates of example.org authorities +//! and signers made here; and never a panic on any bytes. + +use crate::digital_signature::{Coverage, Verdict, Why}; +use cms::cert::IssuerAndSerialNumber; +use cms::content_info::{CmsVersion, ContentInfo}; +use cms::signed_data::{CertificateSet, EncapsulatedContentInfo, SignedData, SignerIdentifier, SignerInfo, SignerInfos}; +use const_oid::ObjectIdentifier; +use der::asn1::{OctetString, SetOfVec}; +use der::{Any, Decode, Encode}; +use proptest::prelude::*; +use spki::AlgorithmIdentifierOwned; +use x509_cert::Certificate; +use x509_cert::attr::Attribute; + +use crate::{Anchors, Checked, Context, Signed, check}; + +const CA: &[u8] = include_bytes!("../testdata/ca.rsa.der"); +const ALICE: &[u8] = include_bytes!("../testdata/alice.sign.der"); +const DETACHED: &[u8] = include_bytes!("../testdata/detached.eml"); +const OPAQUE: &[u8] = include_bytes!("../testdata/opaque.eml"); +const OPAQUE_BER: &[u8] = include_bytes!("../testdata/opaque-ber.eml"); +const SHA1: &[u8] = include_bytes!("../testdata/sha1.eml"); +const NO_ATTRIBUTES: &[u8] = include_bytes!("../testdata/noattr.eml"); +const PSS: &[u8] = include_bytes!("../testdata/pss.eml"); +const NO_CERTS: &[u8] = include_bytes!("../testdata/nocerts.eml"); + +/// 2026-11-09, within the RFC 9216 certificates' years. +const NOW: i64 = 1_794_182_400; + +fn base64(text: &[u8]) -> Vec { + const ALPHABET: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + let mut out = Vec::new(); + let (mut acc, mut bits) = (0u32, 0u32); + for c in text { + let Some(v) = ALPHABET.iter().position(|a| a == c) else { continue }; + acc = (acc << 6) | v as u32; + bits += 6; + if bits >= 8 { + bits -= 8; + out.push((acc >> bits) as u8); + } + } + out +} + +/// A message's body: what follows its first empty line. +fn body(message: &[u8]) -> &[u8] { + let at = message.windows(4).position(|w| w == b"\r\n\r\n").unwrap(); + &message[at + 4..] +} + +/// The two halves of a detached fixture: the signed part as it came, and the CMS. +fn halves(message: &[u8]) -> (Vec, Vec) { + let text = String::from_utf8_lossy(message); + let boundary = text.split("boundary=\"").nth(1).unwrap().split('"').next().unwrap().to_string(); + let delimiter = format!("\r\n--{boundary}"); + let body = String::from_utf8_lossy(body(message)).into_owned(); + let pieces: Vec<&str> = body.split(delimiter.as_str()).collect(); + // pieces[0] is the preamble up to the first delimiter line; the content follows its CRLF. + let content = pieces[1].strip_prefix("\r\n").unwrap().as_bytes().to_vec(); + let signature_part = pieces[2].strip_prefix("\r\n").unwrap(); + (content, base64(body_of(signature_part.as_bytes()))) +} + +fn body_of(part: &[u8]) -> &[u8] { + let at = part.windows(4).position(|w| w == b"\r\n\r\n").unwrap(); + &part[at + 4..] +} + +fn anchors() -> Anchors { + Anchors::new([CA]) +} + +fn checked_detached(message: &[u8], anchors: &Anchors, from: &str, now: i64, known: &[&[u8]]) -> Checked { + let (content, signature) = halves(message); + check(Signed::Detached { content: &content, signature: &signature }, &Context { anchors, from, now, known, coverage: Coverage::Whole }).unwrap() +} + +fn checked_opaque(message: &[u8], anchors: &Anchors, from: &str) -> Checked { + let cms = base64(body(message)); + check(Signed::Opaque(&cms), &Context { anchors, from, now: NOW, known: &[], coverage: Coverage::Whole }).unwrap() +} + +#[test] +fn alices_detached_signature_is_verified() { + let c = checked_detached(DETACHED, &anchors(), "alice@smime.example", NOW, &[]); + assert_eq!(c.signature.verdict, Verdict::Verified, "{c:?}"); + assert_eq!(c.signature.why, None); + let signer = c.signature.signer.clone().unwrap(); + assert_eq!(signer.name, "Alice Lovelace"); + assert_eq!(signer.addresses, vec!["alice@smime.example".to_string()]); + assert_eq!(signer.issuer, "Sample LAMPS RSA Certification Authority"); + assert_eq!(signer.fingerprint.len(), 32 * 3 - 1); + assert!(signer.not_before < NOW && NOW < signer.not_after); + assert!(c.signature.signed_at.is_some(), "OpenSSL gives a signing time"); + assert!(!c.signature.revocation_checked); + assert_eq!(c.certificate.as_deref(), Some(ALICE), "the certificate is worth keeping"); +} + +#[test] +fn the_address_is_compared_without_regard_to_case() { + let c = checked_detached(DETACHED, &anchors(), "Alice@SMIME.example", NOW, &[]); + assert_eq!(c.signature.verdict, Verdict::Verified); +} + +#[test] +fn opaque_ber_pss_and_bare_signatures_are_verified() { + for message in [OPAQUE, OPAQUE_BER] { + let c = checked_opaque(message, &anchors(), "alice@smime.example"); + assert_eq!(c.signature.verdict, Verdict::Verified, "{c:?}"); + } + for message in [NO_ATTRIBUTES, PSS] { + let c = checked_detached(message, &anchors(), "alice@smime.example", NOW, &[]); + assert_eq!(c.signature.verdict, Verdict::Verified, "{c:?}"); + } +} + +#[test] +fn sha1_is_no_longer_safe() { + let c = checked_detached(SHA1, &anchors(), "alice@smime.example", NOW, &[]); + assert_eq!((c.signature.verdict, c.signature.why), (Verdict::Unchecked, Some(Why::WeakAlgorithm))); + assert_eq!(c.certificate, None); +} + +#[test] +fn a_signature_without_its_certificate_needs_one_kept_here() { + let c = checked_detached(NO_CERTS, &anchors(), "alice@smime.example", NOW, &[]); + assert_eq!((c.signature.verdict, c.signature.why), (Verdict::Unchecked, Some(Why::NoPublicKey))); + let c = checked_detached(NO_CERTS, &anchors(), "alice@smime.example", NOW, &[ALICE]); + assert_eq!(c.signature.verdict, Verdict::Verified); +} + +#[test] +fn an_unknown_issuer_another_address_and_an_expired_certificate_are_not_verified() { + let c = checked_detached(DETACHED, &Anchors::default(), "alice@smime.example", NOW, &[]); + assert_eq!((c.signature.verdict, c.signature.why), (Verdict::NotVerified, Some(Why::UnknownIssuer))); + assert_eq!(c.certificate, None, "only a certificate that is trusted and valid is kept (#30 review 7)"); + let c = checked_detached(DETACHED, &anchors(), "bob@smime.example", NOW, &[]); + assert_eq!((c.signature.verdict, c.signature.why), (Verdict::NotVerified, Some(Why::AddressMismatch))); + assert_eq!(c.certificate, None, "not kept for an address it isn't for"); + // 2060: past 2052. + let c = checked_detached(DETACHED, &anchors(), "alice@smime.example", 2_840_140_800, &[]); + assert_eq!((c.signature.verdict, c.signature.why), (Verdict::NotVerified, Some(Why::Expired))); + assert_eq!(c.certificate, None, "nor one out of date"); + let c = checked_detached(DETACHED, &anchors(), "alice@smime.example", NOW, &[]); + assert!(c.certificate.is_some(), "a trusted one, valid now, for the sender, is"); +} + +#[test] +fn a_change_after_signing_is_seen() { + let (mut content, signature) = halves(DETACHED); + let at = content.windows(7).position(|w| w == b"Tuesday").unwrap(); + content[at] = b'W'; + let c = check( + Signed::Detached { content: &content, signature: &signature }, + &Context { anchors: &anchors(), from: "alice@smime.example", now: NOW, known: &[], coverage: Coverage::Whole }, + ) + .unwrap(); + assert_eq!((c.signature.verdict, c.signature.why), (Verdict::Changed, Some(Why::Altered))); + // Opaque: the content inside the CMS. + let mut cms = base64(body(OPAQUE)); + let at = cms.windows(7).position(|w| w == b"Tuesday").unwrap(); + cms[at] = b'W'; + let c = + check(Signed::Opaque(&cms), &Context { anchors: &anchors(), from: "alice@smime.example", now: NOW, known: &[], coverage: Coverage::Whole }) + .unwrap(); + assert_eq!(c.signature.verdict, Verdict::Changed); + // The signature itself. + let (content, mut signature) = halves(DETACHED); + let last = signature.len() - 1; + signature[last] ^= 1; + let c = check( + Signed::Detached { content: &content, signature: &signature }, + &Context { anchors: &anchors(), from: "alice@smime.example", now: NOW, known: &[], coverage: Coverage::Whole }, + ) + .unwrap(); + assert_eq!(c.signature.verdict, Verdict::Changed); +} + +#[test] +fn content_in_lf_lines_is_checked_in_its_canonical_form() { + let (content, signature) = halves(DETACHED); + let lf: Vec = String::from_utf8_lossy(&content).replace("\r\n", "\n").into_bytes(); + let c = check( + Signed::Detached { content: &lf, signature: &signature }, + &Context { anchors: &anchors(), from: "alice@smime.example", now: NOW, known: &[], coverage: Coverage::Whole }, + ) + .unwrap(); + assert_eq!(c.signature.verdict, Verdict::Verified); +} + +#[test] +fn enveloped_data_is_no_digital_signature_and_junk_is_unreadable() { + // ContentInfo { envelopedData, [0] { SEQUENCE {} } }. + let enveloped = [0x30, 0x0f, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x07, 0x03, 0xa0, 0x02, 0x30, 0x00]; + let context = Context { anchors: &Anchors::default(), from: "a@example.org", now: NOW, known: &[], coverage: Coverage::Whole }; + assert_eq!(check(Signed::Opaque(&enveloped), &context), None); + let junk = check(Signed::Opaque(b"not a CMS"), &context).unwrap(); + assert_eq!((junk.signature.verdict, junk.signature.why), (Verdict::Unchecked, Some(Why::Unreadable))); +} + +// ---- certificates made here ---- + +const SHA256: ObjectIdentifier = ObjectIdentifier::new_unwrap("2.16.840.1.101.3.4.2.1"); +const ECDSA_SHA256: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.2.840.10045.4.3.2"); +const ECDSA_SHA384: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.2.840.10045.4.3.3"); +const SHA384: ObjectIdentifier = ObjectIdentifier::new_unwrap("2.16.840.1.101.3.4.2.2"); + +struct Made { + der: Vec, + key: rcgen::KeyPair, + params: rcgen::CertificateParams, +} + +fn params(name: &str) -> rcgen::CertificateParams { + let mut p = rcgen::CertificateParams::new(Vec::::new()).unwrap(); + p.distinguished_name = rcgen::DistinguishedName::new(); + p.distinguished_name.push(rcgen::DnType::CommonName, name); + p.not_before = rcgen::date_time_ymd(2020, 1, 1); + p.not_after = rcgen::date_time_ymd(2050, 1, 1); + p +} + +fn ca_params(name: &str) -> rcgen::CertificateParams { + let mut p = params(name); + p.is_ca = rcgen::IsCa::Ca(rcgen::BasicConstraints::Unconstrained); + p.key_usages = vec![rcgen::KeyUsagePurpose::KeyCertSign, rcgen::KeyUsagePurpose::CrlSign]; + p +} + +fn signer_params(name: &str, address: &str) -> rcgen::CertificateParams { + let mut p = params(name); + p.subject_alt_names = vec![rcgen::SanType::Rfc822Name(address.try_into().unwrap())]; + p.key_usages = vec![rcgen::KeyUsagePurpose::DigitalSignature]; + p.extended_key_usages = vec![rcgen::ExtendedKeyUsagePurpose::EmailProtection]; + p +} + +fn key(alg: &'static rcgen::SignatureAlgorithm) -> rcgen::KeyPair { + rcgen::KeyPair::generate_for(alg).unwrap() +} + +fn root(name: &str) -> Made { + let key = key(&rcgen::PKCS_ECDSA_P256_SHA256); + let params = ca_params(name); + let der = params.self_signed(&key).unwrap().der().to_vec(); + Made { der, key, params } +} + +fn issued(params: rcgen::CertificateParams, key: rcgen::KeyPair, by: &Made) -> Made { + let issuer = rcgen::Issuer::new(by.params.clone(), &by.key); + let der = params.signed_by(&key, &issuer).unwrap().der().to_vec(); + Made { der, key, params } +} + +/// A detached CMS SignedData over `content` by `signer`, carrying `certs`. +fn sign(content: &[u8], signer: &Made, certs: &[&Made], p384: bool) -> Vec { + sign_with(content, signer, certs, p384, |_| {}) +} + +/// [`sign`], with the signer's information changed by `tweak` after it is made. +fn sign_with(content: &[u8], signer: &Made, certs: &[&Made], p384: bool, tweak: impl Fn(&mut SignerInfo)) -> Vec { + sign_data_with(content, signer, certs, p384, tweak, |_| {}) +} + +/// [`sign_with`], with the SignedData changed by `tweak_data` too. +fn sign_data_with( + content: &[u8], + signer: &Made, + certs: &[&Made], + p384: bool, + tweak: impl Fn(&mut SignerInfo), + tweak_data: impl Fn(&mut SignedData), +) -> Vec { + let cert = Certificate::from_der(&signer.der).unwrap(); + let (digest_oid, sig_oid) = if p384 { (SHA384, ECDSA_SHA384) } else { (SHA256, ECDSA_SHA256) }; + let digest = if p384 { ring::digest::digest(&ring::digest::SHA384, content) } else { ring::digest::digest(&ring::digest::SHA256, content) }; + let attr = |oid: &str, value: Any| Attribute { oid: ObjectIdentifier::new_unwrap(oid), values: SetOfVec::try_from(vec![value]).unwrap() }; + let attrs: SetOfVec = SetOfVec::try_from(vec![ + attr("1.2.840.113549.1.9.3", Any::encode_from(&ObjectIdentifier::new_unwrap("1.2.840.113549.1.7.1")).unwrap()), + attr("1.2.840.113549.1.9.4", Any::encode_from(&OctetString::new(digest.as_ref().to_vec()).unwrap()).unwrap()), + ]) + .unwrap(); + let to_sign = attrs.to_der().unwrap(); + let alg = if p384 { &ring::signature::ECDSA_P384_SHA384_ASN1_SIGNING } else { &ring::signature::ECDSA_P256_SHA256_ASN1_SIGNING }; + let rng = ring::rand::SystemRandom::new(); + let pair = ring::signature::EcdsaKeyPair::from_pkcs8(alg, &signer.key.serialize_der(), &rng).unwrap(); + let signature = pair.sign(&rng, &to_sign).unwrap(); + let info = SignerInfo { + version: CmsVersion::V1, + sid: SignerIdentifier::IssuerAndSerialNumber(IssuerAndSerialNumber { + issuer: cert.tbs_certificate().issuer().clone(), + serial_number: cert.tbs_certificate().serial_number().clone(), + }), + digest_alg: AlgorithmIdentifierOwned { oid: digest_oid, parameters: None }, + signed_attrs: Some(attrs), + signature_algorithm: AlgorithmIdentifierOwned { oid: sig_oid, parameters: None }, + signature: OctetString::new(signature.as_ref().to_vec()).unwrap(), + unsigned_attrs: None, + }; + let mut info = info; + tweak(&mut info); + let set: Vec = + certs.iter().map(|c| cms::cert::CertificateChoices::Certificate(Certificate::from_der(&c.der).unwrap())).collect(); + let mut data = SignedData { + version: CmsVersion::V1, + digest_algorithms: SetOfVec::try_from(vec![AlgorithmIdentifierOwned { oid: digest_oid, parameters: None }]).unwrap(), + encap_content_info: EncapsulatedContentInfo { econtent_type: ObjectIdentifier::new_unwrap("1.2.840.113549.1.7.1"), econtent: None }, + certificates: Some(CertificateSet::try_from(set).unwrap()), + crls: None, + signer_infos: SignerInfos::try_from(vec![info]).unwrap(), + }; + tweak_data(&mut data); + ContentInfo { content_type: ObjectIdentifier::new_unwrap("1.2.840.113549.1.7.2"), content: Any::encode_from(&data).unwrap() }.to_der().unwrap() +} + +fn verdict(cms: &[u8], content: &[u8], anchors: &Anchors, from: &str) -> (Verdict, Option) { + let c = check(Signed::Detached { content, signature: cms }, &Context { anchors, from, now: NOW, known: &[], coverage: Coverage::Whole }).unwrap(); + (c.signature.verdict, c.signature.why) +} + +const CONTENT: &[u8] = b"Content-Type: text/plain\r\n\r\nThe accounts are ready.\r\n"; + +#[test] +fn a_path_through_an_intermediate_authority_is_verified() { + let root = root("Example Root"); + let intermediate = issued(ca_params("Example Mail CA"), key(&rcgen::PKCS_ECDSA_P256_SHA256), &root); + let ada = issued(signer_params("Ada", "ada@example.org"), key(&rcgen::PKCS_ECDSA_P256_SHA256), &intermediate); + let cms = sign(CONTENT, &ada, &[&ada, &intermediate], false); + let anchors = Anchors::new([&root.der]); + assert_eq!(verdict(&cms, CONTENT, &anchors, "ada@example.org"), (Verdict::Verified, None)); + // Without the intermediate authority's certificate there is no path. + let alone = sign(CONTENT, &ada, &[&ada], false); + assert_eq!(verdict(&alone, CONTENT, &anchors, "ada@example.org"), (Verdict::NotVerified, Some(Why::UnknownIssuer))); + // A P-384 signer. + let grace = issued(signer_params("Grace", "grace@example.org"), key(&rcgen::PKCS_ECDSA_P384_SHA384), &intermediate); + let cms = sign(CONTENT, &grace, &[&grace, &intermediate], true); + assert_eq!(verdict(&cms, CONTENT, &anchors, "grace@example.org"), (Verdict::Verified, None)); +} + +#[test] +fn a_certificate_not_for_mail_or_signed_by_itself_is_not_verified() { + let root = root("Example Root"); + let anchors = Anchors::new([&root.der]); + let mut web = signer_params("Web", "web@example.org"); + web.extended_key_usages = vec![rcgen::ExtendedKeyUsagePurpose::ServerAuth]; + let web = issued(web, key(&rcgen::PKCS_ECDSA_P256_SHA256), &root); + let cms = sign(CONTENT, &web, &[&web], false); + assert_eq!(verdict(&cms, CONTENT, &anchors, "web@example.org"), (Verdict::NotVerified, Some(Why::NotForEmail))); + let own_key = key(&rcgen::PKCS_ECDSA_P256_SHA256); + let own_params = signer_params("Self", "self@example.org"); + let own = Made { der: own_params.self_signed(&own_key).unwrap().der().to_vec(), key: own_key, params: own_params }; + let cms = sign(CONTENT, &own, &[&own], false); + assert_eq!(verdict(&cms, CONTENT, &anchors, "self@example.org"), (Verdict::NotVerified, Some(Why::SelfSigned))); + // Unless the host trusts it itself. + assert_eq!(verdict(&cms, CONTENT, &Anchors::new([&own.der]), "self@example.org"), (Verdict::Verified, None)); +} + +#[test] +fn an_expired_link_is_not_verified() { + let root = root("Example Root"); + let mut old = signer_params("Old", "old@example.org"); + old.not_after = rcgen::date_time_ymd(2021, 1, 1); + let old = issued(old, key(&rcgen::PKCS_ECDSA_P256_SHA256), &root); + let cms = sign(CONTENT, &old, &[&old], false); + assert_eq!(verdict(&cms, CONTENT, &Anchors::new([&root.der]), "old@example.org"), (Verdict::NotVerified, Some(Why::Expired))); +} + +#[test] +fn a_certificate_from_another_authority_of_the_same_name_is_not_trusted() { + let real = root("Example Root"); + let fake = root("Example Root"); + let ada = issued(signer_params("Ada", "ada@example.org"), key(&rcgen::PKCS_ECDSA_P256_SHA256), &fake); + let cms = sign(CONTENT, &ada, &[&ada], false); + assert_eq!(verdict(&cms, CONTENT, &Anchors::new([&real.der]), "ada@example.org"), (Verdict::NotVerified, Some(Why::UnknownIssuer))); +} + +/// A certificate of the signer's issuer and serial number put in the message (anybody can put +/// one there) is not the signer's unless its key made the signature: it changes nothing. +#[test] +fn a_certificate_that_only_claims_the_signers_name_changes_nothing() { + let real = root("Example Root"); + let fake = root("Example Root"); + let serial = |mut p: rcgen::CertificateParams| { + p.serial_number = Some(rcgen::SerialNumber::from(vec![0x30, 0x01, 0x02])); + p + }; + let ada = issued(serial(signer_params("Ada", "ada@example.org")), key(&rcgen::PKCS_ECDSA_P256_SHA256), &real); + let impostor = issued(serial(signer_params("Ada", "ada@example.org")), key(&rcgen::PKCS_ECDSA_P256_SHA256), &fake); + let anchors = Anchors::new([&real.der]); + // The impostor first: the signer is still found, and verified. + let cms = sign(CONTENT, &ada, &[&impostor, &ada], false); + assert_eq!(verdict(&cms, CONTENT, &anchors, "ada@example.org"), (Verdict::Verified, None)); + // Changed content is put down to the signer that fits, and named. + let changed = b"Content-Type: text/plain\r\n\r\nThe accounts are empty.\r\n"; + let c = check( + Signed::Detached { content: changed, signature: &cms }, + &Context { anchors: &anchors, from: "ada@example.org", now: NOW, known: &[], coverage: Coverage::Whole }, + ) + .unwrap(); + assert_eq!((c.signature.verdict, c.signature.why), (Verdict::Changed, Some(Why::Altered))); + let named = c.signature.signer.unwrap(); + assert_eq!(named.fingerprint, crate::cert::Cert::from_der(&ada.der).unwrap().fingerprint(), "the real signer, not the impostor"); + // With only the impostor's certificate, nobody is named as having signed it. + let alone = sign(CONTENT, &ada, &[&impostor], false); + let c = check( + Signed::Detached { content: CONTENT, signature: &alone }, + &Context { anchors: &anchors, from: "ada@example.org", now: NOW, known: &[], coverage: Coverage::Whole }, + ) + .unwrap(); + assert_eq!(c.signature.verdict, Verdict::Changed); + assert!(c.signature.signer.is_none()); + assert!(c.certificate.is_none(), "nothing of it is kept"); +} + +/// A signature that can't be read is "can't be checked", never "changed". +#[test] +fn a_malformed_signature_cant_be_checked() { + let root = root("Example Root"); + let ada = issued(signer_params("Ada", "ada@example.org"), key(&rcgen::PKCS_ECDSA_P256_SHA256), &root); + let junk = sign_with(CONTENT, &ada, &[&ada], false, |info| info.signature = OctetString::new(vec![0xff; 12]).unwrap()); + assert_eq!(verdict(&junk, CONTENT, &Anchors::new([&root.der]), "ada@example.org"), (Verdict::Unchecked, Some(Why::Unreadable))); + // An RSA signature algorithm for an elliptic-curve key: of different kinds. + let crossed = sign_with(CONTENT, &ada, &[&ada], false, |info| { + info.signature_algorithm = AlgorithmIdentifierOwned { oid: ObjectIdentifier::new_unwrap("1.2.840.113549.1.1.11"), parameters: None } + }); + assert_eq!(verdict(&crossed, CONTENT, &Anchors::new([&root.der]), "ada@example.org"), (Verdict::Unchecked, Some(Why::Unreadable))); +} + +/// A valid signature by a trusted signer over only part of a message (a wrapper's first part) +/// is never verified for the message. +#[test] +fn a_signature_over_part_of_a_message_is_not_verified_for_it() { + let (content, signature) = halves(DETACHED); + let anchors = anchors(); + let c = check( + Signed::Detached { content: &content, signature: &signature }, + &Context { anchors: &anchors, from: "alice@smime.example", now: NOW, known: &[], coverage: Coverage::Part }, + ) + .unwrap(); + assert_eq!((c.signature.verdict, c.signature.why), (Verdict::NotVerified, Some(Why::PartlySigned))); + assert_eq!(c.signature.coverage, Coverage::Part); + // A message from several people is nobody's alone: no address matches. + let c = checked_detached(DETACHED, &anchors, "", NOW, &[]); + assert_eq!((c.signature.verdict, c.signature.why), (Verdict::NotVerified, Some(Why::AddressMismatch))); +} + +// ---- #30 review: what a path must keep (RFC 5280 §4.2, §6.1) ---- + +/// An authority's certificate for `name` issued by `by`, changed by `change` first. +fn authority(name: &str, by: &Made, change: impl FnOnce(&mut rcgen::CertificateParams)) -> Made { + let mut p = ca_params(name); + change(&mut p); + issued(p, key(&rcgen::PKCS_ECDSA_P256_SHA256), by) +} + +fn signer_by(name: &str, address: &str, by: &Made) -> Made { + issued(signer_params(name, address), key(&rcgen::PKCS_ECDSA_P256_SHA256), by) +} + +/// The verdict for a message by `leaf` carrying `chain`, against `root`. +fn path_verdict(leaf: &Made, chain: &[&Made], root: &Made, from: &str) -> (Verdict, Option) { + let mut certs = vec![leaf]; + certs.extend_from_slice(chain); + let cms = sign(CONTENT, leaf, &certs, false); + verdict(&cms, CONTENT, &Anchors::new([&root.der]), from) +} + +#[test] +fn name_constraints_on_mail_addresses_are_kept() { + let root = root("Example Root"); + let corp = authority("Corp CA", &root, |p| { + p.name_constraints = Some(rcgen::NameConstraints { + permitted_subtrees: vec![rcgen::GeneralSubtree::Rfc822Name("corp.example".into())], + excluded_subtrees: vec![rcgen::GeneralSubtree::Rfc822Name("ceo@corp.example".into())], + }) + }); + let inside = signer_by("Ada", "ada@corp.example", &corp); + assert_eq!(path_verdict(&inside, &[&corp], &root, "ada@corp.example"), (Verdict::Verified, None)); + let outside = signer_by("CEO", "ceo@bank.example", &corp); + assert_eq!(path_verdict(&outside, &[&corp], &root, "ceo@bank.example"), (Verdict::NotVerified, Some(Why::Constrained))); + let excluded = signer_by("CEO", "ceo@corp.example", &corp); + assert_eq!(path_verdict(&excluded, &[&corp], &root, "ceo@corp.example"), (Verdict::NotVerified, Some(Why::Constrained))); + // A leading dot: any host under the domain, not the domain itself. + let sub = authority("Sub CA", &root, |p| { + p.name_constraints = Some(rcgen::NameConstraints { + permitted_subtrees: vec![rcgen::GeneralSubtree::Rfc822Name(".corp.example".into())], + excluded_subtrees: vec![], + }) + }); + let mail = signer_by("Ada", "ada@mail.corp.example", &sub); + assert_eq!(path_verdict(&mail, &[&sub], &root, "ada@mail.corp.example"), (Verdict::Verified, None)); + let bare = signer_by("Ada", "ada@corp.example", &sub); + assert_eq!(path_verdict(&bare, &[&sub], &root, "ada@corp.example"), (Verdict::NotVerified, Some(Why::Constrained))); + assert!(crate::cert::mail_within("Ada@Corp.Example", "corp.example")); + assert!(!crate::cert::mail_within("ada@evilcorp.example", ".corp.example")); +} + +#[test] +fn name_constraints_on_directory_names_are_kept() { + let root = root("Example Root"); + let mut corp_dn = rcgen::DistinguishedName::new(); + corp_dn.push(rcgen::DnType::OrganizationName, "Corp"); + let corp = authority("Corp CA", &root, |p| { + p.name_constraints = Some(rcgen::NameConstraints { + permitted_subtrees: vec![rcgen::GeneralSubtree::DirectoryName(corp_dn.clone())], + excluded_subtrees: vec![], + }) + }); + let mut inside = signer_params("Ada", "ada@corp.example"); + inside.distinguished_name = rcgen::DistinguishedName::new(); + inside.distinguished_name.push(rcgen::DnType::OrganizationName, "Corp"); + inside.distinguished_name.push(rcgen::DnType::CommonName, "Ada"); + let inside = issued(inside, key(&rcgen::PKCS_ECDSA_P256_SHA256), &corp); + assert_eq!(path_verdict(&inside, &[&corp], &root, "ada@corp.example"), (Verdict::Verified, None)); + let outside = signer_by("Mallory", "mallory@corp.example", &corp); + assert_eq!(path_verdict(&outside, &[&corp], &root, "mallory@corp.example"), (Verdict::NotVerified, Some(Why::Constrained))); +} + +#[test] +fn an_excluded_directory_name_written_another_way_is_still_excluded() { + let root = root("Example Root"); + let mut rogue = rcgen::DistinguishedName::new(); + rogue.push(rcgen::DnType::OrganizationName, "Rogue Unit"); + let ca = authority("Corp CA", &root, |p| { + p.name_constraints = + Some(rcgen::NameConstraints { permitted_subtrees: vec![], excluded_subtrees: vec![rcgen::GeneralSubtree::DirectoryName(rogue)] }) + }); + // The same name in another string type, case and spacing (RFC 5280 §7.1). + let mut dressed = signer_params("Mallory", "mallory@corp.example"); + dressed.distinguished_name = rcgen::DistinguishedName::new(); + dressed.distinguished_name.push(rcgen::DnType::OrganizationName, rcgen::DnValue::PrintableString(" ROGUE unit ".try_into().unwrap())); + dressed.distinguished_name.push(rcgen::DnType::CommonName, "Mallory"); + let dressed = issued(dressed, key(&rcgen::PKCS_ECDSA_P256_SHA256), &ca); + assert_eq!(path_verdict(&dressed, &[&ca], &root, "mallory@corp.example"), (Verdict::NotVerified, Some(Why::Constrained))); + let other = signer_by("Ada", "ada@corp.example", &ca); + assert_eq!(path_verdict(&other, &[&ca], &root, "ada@corp.example"), (Verdict::Verified, None)); +} + +#[test] +fn an_unknown_critical_extension_is_refused() { + let root = root("Example Root"); + let mut odd = signer_params("Ada", "ada@example.org"); + let mut ext = rcgen::CustomExtension::from_oid_content(&[1, 3, 6, 1, 4, 1, 99999, 1], vec![0x05, 0x00]); + ext.set_criticality(true); + odd.custom_extensions = vec![ext]; + let odd = issued(odd, key(&rcgen::PKCS_ECDSA_P256_SHA256), &root); + assert_eq!(path_verdict(&odd, &[], &root, "ada@example.org"), (Verdict::NotVerified, Some(Why::Constrained))); + // On an authority on the way too. + let ca = authority("Odd CA", &root, |p| { + let mut ext = rcgen::CustomExtension::from_oid_content(&[1, 3, 6, 1, 4, 1, 99999, 2], vec![0x05, 0x00]); + ext.set_criticality(true); + p.custom_extensions = vec![ext]; + }); + let ada = signer_by("Ada", "ada@example.org", &ca); + assert_eq!(path_verdict(&ada, &[&ca], &root, "ada@example.org"), (Verdict::NotVerified, Some(Why::Constrained))); +} + +#[test] +fn a_path_length_constraint_is_kept() { + let root = root("Example Root"); + let ca = authority("Mail CA", &root, |p| p.is_ca = rcgen::IsCa::Ca(rcgen::BasicConstraints::Constrained(0))); + let rogue = authority("Rogue CA", &ca, |_| {}); + let leaf = signer_by("Ada", "ada@example.org", &rogue); + assert_eq!(path_verdict(&leaf, &[&rogue, &ca], &root, "ada@example.org"), (Verdict::NotVerified, Some(Why::Constrained))); + // Directly below it, a signer is fine. + let direct = signer_by("Ada", "ada@example.org", &ca); + assert_eq!(path_verdict(&direct, &[&ca], &root, "ada@example.org"), (Verdict::Verified, None)); +} + +#[test] +fn an_authority_not_for_mail_cant_vouch_for_a_mail_certificate() { + let root = root("Example Root"); + let web = authority("Web CA", &root, |p| p.extended_key_usages = vec![rcgen::ExtendedKeyUsagePurpose::ServerAuth]); + let leaf = signer_by("Ada", "ada@example.org", &web); + assert_eq!(path_verdict(&leaf, &[&web], &root, "ada@example.org"), (Verdict::NotVerified, Some(Why::Constrained))); + let mail = authority("Mail CA", &root, |p| p.extended_key_usages = vec![rcgen::ExtendedKeyUsagePurpose::EmailProtection]); + let leaf = signer_by("Ada", "ada@example.org", &mail); + assert_eq!(path_verdict(&leaf, &[&mail], &root, "ada@example.org"), (Verdict::Verified, None)); +} + +#[test] +fn another_path_is_tried_when_the_first_doesnt_hold() { + let root = root("Example Root"); + let shared = key(&rcgen::PKCS_ECDSA_P256_SHA256); + let again = || rcgen::KeyPair::try_from(shared.serialize_der().as_slice()).unwrap(); + // The same authority, its key and name, in two certificates: one ran out, one is current. + let mut old = ca_params("Mail CA"); + old.not_after = rcgen::date_time_ymd(2021, 1, 1); + let old = issued(old, again(), &root); + let current = issued(ca_params("Mail CA"), again(), &root); + let leaf = signer_by("Ada", "ada@example.org", ¤t); + assert_eq!(path_verdict(&leaf, &[&old, ¤t], &root, "ada@example.org"), (Verdict::Verified, None)); + assert_eq!(path_verdict(&leaf, &[&old], &root, "ada@example.org"), (Verdict::NotVerified, Some(Why::Expired))); +} + +#[test] +fn the_search_for_a_path_keeps_to_its_budget() { + let root = root("Example Root"); + let a = authority("A CA", &root, |_| {}); + let b = authority("B CA", &a, |_| {}); + let leaf = signer_by("Ada", "ada@example.org", &b); + let pool: Vec = [&b, &a].iter().map(|m| crate::cert::Cert::from_der(&m.der).unwrap()).collect(); + let leaf = crate::cert::Cert::from_der(&leaf.der).unwrap(); + let anchors = Anchors::new([&root.der]); + let mut budget = 3; + assert_eq!(crate::chain::trust(&leaf, &pool, &anchors, NOW, &mut budget), Ok(())); + assert_eq!(budget, 0, "three links, three signatures"); + let mut budget = 2; + assert_eq!(crate::chain::trust(&leaf, &pool, &anchors, NOW, &mut budget), Err(Why::TooMuch), "stops when it runs out, and says so"); + assert_eq!(crate::MAX_VERIFICATIONS, 32); +} + +/// `cms` with its signers' information put in place of its own, in this order. +fn with_signers(cms: &[u8], infos: &[&[u8]]) -> Vec { + let (info, _) = craft_ber::read(cms).unwrap(); + let fields = craft_ber::children(info.value).unwrap(); + let (sd, _) = craft_ber::read(fields[1].value).unwrap(); + let parts = craft_ber::children(sd.value).unwrap(); + let mut inner: Vec = parts[..parts.len() - 1].iter().flat_map(|p| p.whole.to_vec()).collect(); + inner.extend(tlv(0x31, &infos.concat())); + let mut ci = fields[0].whole.to_vec(); + ci.extend(tlv(0xa0, &tlv(0x30, &inner))); + tlv(0x30, &ci) +} + +/// The first signer's information in `cms`, as it is written. +fn first_signer(cms: &[u8]) -> Vec { + let (info, _) = craft_ber::read(cms).unwrap(); + let fields = craft_ber::children(info.value).unwrap(); + let (sd, _) = craft_ber::read(fields[1].value).unwrap(); + let parts = craft_ber::children(sd.value).unwrap(); + craft_ber::children(parts.last().unwrap().value).unwrap()[0].whole.to_vec() +} + +/// The second try of a signature without signed attributes, over the content in its canonical +/// form, is a verification of its own, paid from the budget (#30 review 6). +#[test] +fn the_canonical_try_is_paid_from_the_budget() { + const LF: &[u8] = b"Content-Type: text/plain\n\nThe accounts are ready.\n"; + let root = root("Example Root"); + let mail = authority("Mail CA", &root, |_| {}); + let ada = signer_by("Ada", "ada@example.org", &mail); + // Without its signed attributes, the signature (made over them) fails as it came and in the + // canonical form alike. + let cms = sign_with(LF, &ada, &[&ada], false, |i| i.signed_attrs = None); + let anchors = Anchors::default(); + let context = Context { anchors: &anchors, from: "ada@example.org", now: NOW, known: &[], coverage: Coverage::Whole }; + let signed = Signed::Detached { content: LF, signature: &cms }; + let one = crate::verify::check_within(signed, &context, 1).unwrap(); + assert_eq!((one.signature.verdict, one.signature.why), (Verdict::Unchecked, Some(Why::TooMuch)), "one verification: no canonical try"); + let two = crate::verify::check_within(signed, &context, 2).unwrap(); + assert_eq!(two.signature.verdict, Verdict::Changed); +} + +/// A signer's name and issuer are shown without format characters: no bidirectional override +/// reorders them and no zero-width space hides in them (#30 review 6). +#[test] +fn a_certificates_names_lose_their_format_characters() { + let root = root("Example Root"); + let mail = authority("Mail\u{202e} CA\u{200b}", &root, |_| {}); + let ada = signer_by("Ada\u{202e}gpj.exe\u{200b}", "ada@example.org", &mail); + let cms = sign(CONTENT, &ada, &[&ada], false); + let anchors = Anchors::default(); + let context = Context { anchors: &anchors, from: "ada@example.org", now: NOW, known: &[], coverage: Coverage::Whole }; + let c = check(Signed::Detached { content: CONTENT, signature: &cms }, &context).unwrap(); + let signer = c.signature.signer.unwrap(); + assert_eq!(signer.name, "Adagpj.exe"); + assert!(signer.issuer.contains("Mail CA") && !signer.issuer.contains(['\u{202e}', '\u{200b}']), "{:?}", signer.issuer); +} + +#[test] +fn a_message_with_too_much_to_check_is_said_so() { + let root = root("Example Root"); + // Thirty authorities of the right name with the wrong keys come before the one that signed: + // the first signer's path takes all the budget, and the second signer is left with none. + let mut known: Vec = (0..30).map(|_| authority("Mail CA", &root, |_| {})).collect(); + let mail = authority("Mail CA", &root, |_| {}); + let ada = signer_by("Ada", "ada@example.org", &mail); + // A signer this computer trusts itself: no link to check, only its signature. + let trusted = issued(signer_params("Ada", "ada@example.org"), key(&rcgen::PKCS_ECDSA_P256_SHA256), &root); + known.push(mail); + let first = sign(CONTENT, &ada, &[&ada], false); + let second = sign(CONTENT, &trusted, &[], false); + let cms = with_signers(&first, &[&first_signer(&first), &first_signer(&second)]); + let known: Vec<&[u8]> = known.iter().map(|m| m.der.as_slice()).chain([trusted.der.as_slice()]).collect(); + let anchors = Anchors::new([&root.der, &trusted.der]); + let c = check( + Signed::Detached { content: CONTENT, signature: &cms }, + &Context { anchors: &anchors, from: "ada@example.org", now: NOW, known: &known, coverage: Coverage::Whole }, + ) + .unwrap(); + assert_eq!((c.signature.verdict, c.signature.why), (Verdict::Unchecked, Some(Why::TooMuch))); + // With the budget to spare, the trusted signer alone is verified. + let alone = with_signers(&first, &[&first_signer(&second)]); + let c = check( + Signed::Detached { content: CONTENT, signature: &alone }, + &Context { anchors: &anchors, from: "ada@example.org", now: NOW, known: &known, coverage: Coverage::Whole }, + ) + .unwrap(); + assert_eq!((c.signature.verdict, c.signature.why), (Verdict::Verified, None)); +} + +#[test] +fn an_authoritys_certificate_never_signs_mail_and_the_matching_address_is_said() { + let root = root("Example Root"); + let mut ca_signer = signer_params("Ada", "ada@example.org"); + ca_signer.is_ca = rcgen::IsCa::Ca(rcgen::BasicConstraints::Unconstrained); + let ca_signer = issued(ca_signer, key(&rcgen::PKCS_ECDSA_P256_SHA256), &root); + assert_eq!(path_verdict(&ca_signer, &[], &root, "ada@example.org"), (Verdict::NotVerified, Some(Why::NotForEmail))); + let mut two = signer_params("Ada", "other@example.org"); + two.subject_alt_names.push(rcgen::SanType::Rfc822Name("ada@example.org".try_into().unwrap())); + let two = issued(two, key(&rcgen::PKCS_ECDSA_P256_SHA256), &root); + let cms = sign(CONTENT, &two, &[&two], false); + let anchors = Anchors::new([&root.der]); + let c = check( + Signed::Detached { content: CONTENT, signature: &cms }, + &Context { anchors: &anchors, from: "ADA@example.org", now: NOW, known: &[], coverage: Coverage::Whole }, + ) + .unwrap(); + assert_eq!(c.signature.verdict, Verdict::Verified); + assert_eq!(c.signature.signer.unwrap().addresses.first().map(String::as_str), Some("ada@example.org")); +} + +#[test] +fn an_address_is_compared_as_it_is_written() { + let root = root("Example Root"); + let mut spaced = signer_params("Ada", "ada@example.org"); + spaced.subject_alt_names = vec![rcgen::SanType::Rfc822Name("ada@example.org ".try_into().unwrap())]; + let spaced = issued(spaced, key(&rcgen::PKCS_ECDSA_P256_SHA256), &root); + assert_eq!(path_verdict(&spaced, &[], &root, "ada@example.org"), (Verdict::NotVerified, Some(Why::AddressMismatch))); + let ada = crate::cert::Cert::from_der(&signer_by("Ada", "ada@example.org", &root).der).unwrap(); + assert!(ada.is_for("ADA@EXAMPLE.ORG")); + assert!(!ada.is_for("ada@example.org\n")); + assert!(!ada.is_for("")); +} + +// ---- #30 review: SignedData read strictly ---- + +/// A DER element of `tag` holding `content`. +fn tlv(tag: u8, content: &[u8]) -> Vec { + let mut out = vec![tag]; + let n = content.len(); + if n < 0x80 { + out.push(n as u8); + } else if n < 0x100 { + out.extend([0x81, n as u8]); + } else { + out.extend([0x82, (n >> 8) as u8, n as u8]); + } + out.extend_from_slice(content); + out +} + +/// `cms` with `extra` put into its SignedData just before the signers. +fn smuggled(cms: &[u8], extra: &[u8]) -> Vec { + let (info, _) = craft_ber::read(cms).unwrap(); + let fields = craft_ber::children(info.value).unwrap(); + let (sd, _) = craft_ber::read(fields[1].value).unwrap(); + let parts = craft_ber::children(sd.value).unwrap(); + let mut inner = Vec::new(); + for (i, p) in parts.iter().enumerate() { + if i == parts.len() - 1 { + inner.extend_from_slice(extra); + } + inner.extend_from_slice(p.whole); + } + let sd = tlv(0x30, &inner); + let mut ci = fields[0].whole.to_vec(); + ci.extend(tlv(0xa0, &sd)); + tlv(0x30, &ci) +} + +#[test] +fn signed_data_with_anything_else_in_it_cant_be_checked() { + let root = root("Example Root"); + let ada = signer_by("Ada", "ada@example.org", &root); + let cms = sign(CONTENT, &ada, &[&ada], false); + let anchors = Anchors::new([&root.der]); + assert_eq!(verdict(&cms, CONTENT, &anchors, "ada@example.org"), (Verdict::Verified, None)); + // A field smuggled in, an OCTET STRING with other content, is refused, not passed over. + let forged = smuggled(&cms, &tlv(0x04, b"

Wire 10000 EUR to Mallory

")); + assert_eq!(verdict(&forged, CONTENT, &anchors, "ada@example.org"), (Verdict::Unchecked, Some(Why::Unreadable))); + // And after the signers, where nothing may follow. + let signers = first_signer(&cms); + let mut after = with_signers(&cms, &[&signers]); + assert_eq!(verdict(&after, CONTENT, &anchors, "ada@example.org"), (Verdict::Verified, None)); + after = { + let (info, _) = craft_ber::read(&after).unwrap(); + let fields = craft_ber::children(info.value).unwrap(); + let (sd, _) = craft_ber::read(fields[1].value).unwrap(); + let mut inner = sd.value.to_vec(); + inner.extend(tlv(0x04, b"after")); + let mut ci = fields[0].whole.to_vec(); + ci.extend(tlv(0xa0, &tlv(0x30, &inner))); + tlv(0x30, &ci) + }; + assert_eq!(verdict(&after, CONTENT, &anchors, "ada@example.org"), (Verdict::Unchecked, Some(Why::Unreadable))); + // A version that isn't one, and a detached signature that carries content too. + let versioned = sign_data_with(CONTENT, &ada, &[&ada], false, |_| {}, |d| d.version = CmsVersion::V2); + assert_eq!(verdict(&versioned, CONTENT, &anchors, "ada@example.org"), (Verdict::Unchecked, Some(Why::Unreadable))); + let carrying = sign_data_with( + CONTENT, + &ada, + &[&ada], + false, + |_| {}, + |d| d.encap_content_info.econtent = Some(Any::encode_from(&OctetString::new(b"other".to_vec()).unwrap()).unwrap()), + ); + assert_eq!(verdict(&carrying, CONTENT, &anchors, "ada@example.org"), (Verdict::Unchecked, Some(Why::Unreadable))); + // What mail signs is id-data. + let other_type = sign_data_with( + CONTENT, + &ada, + &[&ada], + false, + |_| {}, + |d| d.encap_content_info.econtent_type = ObjectIdentifier::new_unwrap("1.2.840.113549.1.9.16.1.4"), + ); + assert_eq!(verdict(&other_type, CONTENT, &anchors, "ada@example.org"), (Verdict::Unchecked, Some(Why::Unreadable))); +} + +#[test] +fn an_opaque_signatures_content_is_given_for_showing() { + let cms = base64(body(OPAQUE)); + let content = craft_ber::signed_content(&cms).unwrap(); + assert!(String::from_utf8_lossy(&content).contains("Hello Bob"), "the signed MIME entity"); + let ber = base64(body(OPAQUE_BER)); + assert_eq!(craft_ber::signed_content(&ber), Some(content)); + let (_, detached) = halves(DETACHED); + assert_eq!(craft_ber::signed_content(&detached), None); +} + +#[test] +fn the_ber_reader_keeps_der_as_it_is_and_joins_pieces() { + assert_eq!(craft_ber::to_der(CA).as_deref(), Some(CA)); + // SEQUENCE (indefinite) { OCTET STRING in pieces "ab" "c" }. + let ber = [0x30, 0x80, 0x24, 0x80, 0x04, 0x02, b'a', b'b', 0x04, 0x01, b'c', 0x00, 0x00, 0x00, 0x00]; + assert_eq!(craft_ber::to_der(&ber), Some(vec![0x30, 0x05, 0x04, 0x03, b'a', b'b', b'c'])); + // A definite length inside, written longer than it need be (a certificate's, say, which its + // signature covers), is kept as it was written. + let ber = [0x30, 0x80, 0x30, 0x81, 0x03, 0x02, 0x01, 0x05, 0x00, 0x00]; + assert_eq!(craft_ber::to_der(&ber), Some(vec![0x30, 0x06, 0x30, 0x81, 0x03, 0x02, 0x01, 0x05])); + // Nesting past the bound is refused, not followed. + let deep: Vec = std::iter::repeat_n([0x30u8, 0x80], 200).flatten().chain(std::iter::repeat_n(0u8, 400)).collect(); + assert_eq!(craft_ber::to_der(&deep), None); +} + +proptest! { + #![proptest_config(ProptestConfig::with_cases(512))] + + #[test] + fn any_bytes_never_panic(bytes in proptest::collection::vec(any::(), 0..4096)) { + let anchors = Anchors::new([CA]); + let context = Context { anchors: &anchors, from: "alice@smime.example", now: NOW, known: &[&bytes], coverage: Coverage::Whole }; + let _ = check(Signed::Opaque(&bytes), &context); + let _ = check(Signed::Detached { content: b"x", signature: &bytes }, &context); + let _ = craft_ber::to_der(&bytes); + let _ = Anchors::new([&bytes]); + } + + #[test] + fn a_damaged_cms_never_panics(flip in 0usize..3000, byte in any::(), cut in 0usize..3000) { + let mut cms = base64(body(OPAQUE_BER)); + if let Some(b) = cms.get_mut(flip) { + *b = byte; + } + cms.truncate(cut); + let anchors = Anchors::new([CA]); + let context = Context { anchors: &anchors, from: "alice@smime.example", now: NOW, known: &[], coverage: Coverage::Whole }; + let _ = check(Signed::Opaque(&cms), &context); + let (content, signature) = halves(DETACHED); + let mut signature = signature; + if let Some(b) = signature.get_mut(flip) { + *b = byte; + } + let _ = check(Signed::Detached { content: &content, signature: &signature }, &context); + } +} + +#[test] +fn certificate_rejects_mismatched_outer_signature_algorithm() { + assert!(crate::cert::Cert::from_der(CA).is_some()); + let (outer, _) = craft_ber::read(CA).unwrap(); + let fields = craft_ber::children(outer.value).unwrap(); + let (algorithm, _) = craft_ber::read(fields[1].value).unwrap(); + assert_eq!(algorithm.tag, 0x06); + let offset = CA.len() - outer.value.len() + fields[0].whole.len() + fields[1].whole.len() - fields[1].value.len() + algorithm.whole.len() - 1; + let mut changed = CA.to_vec(); + changed[offset] ^= 1; + // The mutation remains a syntactically valid certificate: rejection must come from + // algorithm agreement, not a DER decoding error. Without that guard Cert accepts it. + let decoded = Certificate::from_der(&changed).unwrap(); + assert_ne!(decoded.signature_algorithm(), decoded.tbs_certificate().signature()); + assert!(crate::cert::Cert::from_der(&changed).is_none()); +} + +#[test] +fn shared_result_preserves_partial_coverage_and_name_bounds() { + use crate::digital_signature::{DigitalSignature, MAX_SIGNER_TEXT, SignatureFormat, signer_text}; + let signature = DigitalSignature::bare(SignatureFormat::Smime, Verdict::Verified, Why::PartlySigned).covering(Coverage::Part); + assert_eq!(signature.verdict, Verdict::NotVerified); + assert_eq!(signature.why, Some(Why::PartlySigned)); + assert_eq!(signer_text("Alice\u{202e}\u{200b}\nBob"), "Alice Bob"); + assert_eq!(signer_text(&"A".repeat(1000)).chars().count(), MAX_SIGNER_TEXT); +} + +#[test] +fn name_constraints_cover_addresses_beyond_the_display_limit() { + let root = root("Example Root"); + let corp = authority("Corp CA", &root, |p| { + p.name_constraints = Some(rcgen::NameConstraints { + permitted_subtrees: vec![rcgen::GeneralSubtree::Rfc822Name("corp.example".into())], + excluded_subtrees: vec![], + }); + }); + let mut params = signer_params("Many names", "ada@corp.example"); + for n in 1..crate::digital_signature::MAX_SIGNER_ADDRESSES { + params.subject_alt_names.push(rcgen::SanType::Rfc822Name(format!("alias{n}@corp.example").try_into().unwrap())); + } + params.subject_alt_names.push(rcgen::SanType::Rfc822Name("ceo@bank.example".try_into().unwrap())); + let signer = issued(params, key(&rcgen::PKCS_ECDSA_P256_SHA256), &corp); + assert_eq!(path_verdict(&signer, &[&corp], &root, "ada@corp.example"), (Verdict::NotVerified, Some(Why::Constrained))); +} + +#[test] +fn pss_restricted_public_keys_are_not_treated_as_unrestricted_rsa() { + use crate::algorithms::{Fault, Hash}; + let certificate = crate::cert::Cert::from_der(ALICE).unwrap(); + for message in [NO_ATTRIBUTES, PSS] { + let (content, cms) = halves(message); + let info = SignerInfo::from_der(&first_signer(&cms)).unwrap(); + let signed = info.signed_attrs.as_ref().map(|a| a.to_der().unwrap()).unwrap_or(content); + let hash = Hash::of(&info.digest_alg).unwrap(); + let mut key = certificate.public_key().clone(); + assert_eq!(crate::algorithms::verify(&key, &info.signature_algorithm, Some(hash), &signed, info.signature.as_bytes()), Ok(())); + key.algorithm.oid = ObjectIdentifier::new_unwrap("1.2.840.113549.1.1.10"); + // An empty PSS parameter sequence restricts the key to SHA-1 defaults, not + // the SHA-256 signature above. PKCS#1 v1.5 is never allowed for a PSS key. + key.algorithm.parameters = Some(Any::from_der(&[0x30, 0]).unwrap()); + assert_eq!(crate::algorithms::verify(&key, &info.signature_algorithm, Some(hash), &signed, info.signature.as_bytes()), Err(Fault::Unknown)); + } +} + +#[test] +fn malformed_critical_san_is_not_an_absent_identity() { + let root = root("Example Root"); + let mut params = signer_params("Ada", "ada@example.org"); + params.subject_alt_names.clear(); + params + .distinguished_name + .push(rcgen::DnType::CustomDnType(vec![1, 2, 840, 113549, 1, 9, 1]), rcgen::DnValue::Ia5String("ada@example.org".try_into().unwrap())); + let mut san = rcgen::CustomExtension::from_oid_content(&[2, 5, 29, 17], vec![0x05, 0]); + san.set_criticality(true); + params.custom_extensions.push(san); + let signer = issued(params, key(&rcgen::PKCS_ECDSA_P256_SHA256), &root); + assert!(Certificate::from_der(&signer.der).is_ok(), "outer certificate is valid DER"); + assert!(crate::cert::Cert::from_der(&signer.der).is_none()); + assert_ne!(path_verdict(&signer, &[], &root, "ada@example.org").0, Verdict::Verified); +} + +#[test] +fn excluded_directory_san_is_checked_even_with_empty_subject() { + let root = root("Example Root"); + let mut rogue = rcgen::DistinguishedName::new(); + rogue.push(rcgen::DnType::OrganizationName, "Rogue"); + let ca = authority("Corp CA", &root, |p| { + p.name_constraints = + Some(rcgen::NameConstraints { permitted_subtrees: vec![], excluded_subtrees: vec![rcgen::GeneralSubtree::DirectoryName(rogue)] }); + }); + let directory: x509_cert::name::Name = "O=Rogue".parse().unwrap(); + for empty_subject in [false, true] { + let mut params = signer_params("Ada", "ada@example.org"); + if empty_subject { + params.distinguished_name = rcgen::DistinguishedName::new(); + } + params.subject_alt_names.clear(); + let mut names = tlv(0x81, b"ada@example.org"); + names.extend(tlv(0xa4, &directory.to_der().unwrap())); + let mut san = rcgen::CustomExtension::from_oid_content(&[2, 5, 29, 17], tlv(0x30, &names)); + san.set_criticality(true); + params.custom_extensions.push(san); + let signer = issued(params, key(&rcgen::PKCS_ECDSA_P256_SHA256), &ca); + assert_eq!(path_verdict(&signer, &[&ca], &root, "ada@example.org"), (Verdict::NotVerified, Some(Why::Constrained))); + } +} + +#[test] +fn unsupported_unicode_directory_normalization_fails_closed() { + let root = root("Example Root"); + let mut excluded = rcgen::DistinguishedName::new(); + excluded.push(rcgen::DnType::OrganizationName, "STRASSE"); + let ca = authority("Corp CA", &root, |p| { + p.name_constraints = + Some(rcgen::NameConstraints { permitted_subtrees: vec![], excluded_subtrees: vec![rcgen::GeneralSubtree::DirectoryName(excluded)] }); + }); + let mut params = signer_params("Ada", "ada@example.org"); + params.distinguished_name = rcgen::DistinguishedName::new(); + params.distinguished_name.push(rcgen::DnType::OrganizationName, "Straße"); + let signer = issued(params, key(&rcgen::PKCS_ECDSA_P256_SHA256), &ca); + assert_eq!(path_verdict(&signer, &[&ca], &root, "ada@example.org"), (Verdict::NotVerified, Some(Why::Constrained))); +} + +#[test] +fn opaque_binary_content_is_verified_as_exact_octets_with_or_without_attributes() { + const BINARY: &[u8] = b"Content-Type: application/octet-stream\r\nContent-Transfer-Encoding: binary\r\n\r\nA\r\nB"; + const CHANGED: &[u8] = b"Content-Type: application/octet-stream\r\nContent-Transfer-Encoding: binary\r\n\r\nA\nB"; + let root = root("Example Root"); + let signer = signer_by("Ada", "ada@example.org", &root); + let anchors = Anchors::new([&root.der]); + let context = Context { anchors: &anchors, from: "ada@example.org", now: NOW, known: &[], coverage: Coverage::Whole }; + for bare in [false, true] { + let cms = sign_data_with( + BINARY, + &signer, + &[&signer], + false, + |info| { + if bare { + let rng = ring::rand::SystemRandom::new(); + let pair = ring::signature::EcdsaKeyPair::from_pkcs8( + &ring::signature::ECDSA_P256_SHA256_ASN1_SIGNING, + &signer.key.serialize_der(), + &rng, + ) + .unwrap(); + info.signed_attrs = None; + info.signature = OctetString::new(pair.sign(&rng, BINARY).unwrap().as_ref().to_vec()).unwrap(); + } + }, + |data| data.encap_content_info.econtent = Some(Any::encode_from(&OctetString::new(BINARY.to_vec()).unwrap()).unwrap()), + ); + assert_eq!(check(Signed::Opaque(&cms), &context).unwrap().signature.verdict, Verdict::Verified); + let info = ContentInfo::from_der(&cms).unwrap(); + let mut data = info.content.decode_as::().unwrap(); + data.encap_content_info.econtent = Some(Any::encode_from(&OctetString::new(CHANGED.to_vec()).unwrap()).unwrap()); + let changed = ContentInfo { content_type: info.content_type, content: Any::encode_from(&data).unwrap() }.to_der().unwrap(); + assert_eq!(craft_ber::signed_content(&changed).unwrap(), CHANGED); + assert_eq!(check(Signed::Opaque(&changed), &context).unwrap().signature.verdict, Verdict::Changed); + } +} + +#[test] +fn unsupported_name_constraints_fail_closed_for_dns_ip_and_uri() { + // Critical excludedSubtrees for each unsupported form, alongside valid email identity. + for (tag, excluded, presented) in [ + (0x82, b"blocked.example".as_slice(), b"blocked.example".as_slice()), + (0x87, &[192, 0, 2, 0, 255, 255, 255, 0][..], &[192, 0, 2, 1][..]), + (0x86, b"blocked.example".as_slice(), b"https://blocked.example/path".as_slice()), + ] { + let root = root("Root"); + let ca = authority("Constrained CA", &root, |params| { + let subtree = tlv(0x30, &tlv(tag, excluded)); + let mut extension = rcgen::CustomExtension::from_oid_content(&[2, 5, 29, 30], tlv(0x30, &tlv(0xa1, &subtree))); + extension.set_criticality(true); + params.custom_extensions.push(extension); + }); + let mut params = signer_params("Ada", "ada@example.org"); + params.subject_alt_names.clear(); + let mut names = tlv(0x81, b"ada@example.org"); + names.extend(tlv(tag, presented)); + params.custom_extensions.push(rcgen::CustomExtension::from_oid_content(&[2, 5, 29, 17], tlv(0x30, &names))); + let signer = issued(params, key(&rcgen::PKCS_ECDSA_P256_SHA256), &ca); + assert_eq!(path_verdict(&signer, &[&ca], &root, "ada@example.org"), (Verdict::NotVerified, Some(Why::Constrained))); + } +} + +#[test] +fn later_matching_certificates_are_checked_for_trust_usage_and_address() { + let root = root("Renewal Root"); + let id = b"same-key-after-renewal"; + let with_id = |mut params: rcgen::CertificateParams| { + params.custom_extensions.push(rcgen::CustomExtension::from_oid_content(&[2, 5, 29, 14], tlv(0x04, id))); + params + }; + let current = issued(with_id(signer_params("Ada", "ada@example.org")), key(&rcgen::PKCS_ECDSA_P256_SHA256), &root); + let cms = sign_with(CONTENT, ¤t, &[], false, |info| { + info.version = CmsVersion::V3; + info.sid = SignerIdentifier::SubjectKeyIdentifier(x509_cert::ext::pkix::SubjectKeyIdentifier(OctetString::new(id.to_vec()).unwrap())); + }); + let anchors = Anchors::new([&root.der]); + for kind in 0..3 { + let mut params = signer_params("Ada", "ada@example.org"); + match kind { + 0 => params.not_after = rcgen::date_time_ymd(2021, 1, 1), + 1 => params.extended_key_usages = vec![rcgen::ExtendedKeyUsagePurpose::ServerAuth], + _ => params.subject_alt_names = vec![rcgen::SanType::Rfc822Name("other@example.org".try_into().unwrap())], + } + let issuer = rcgen::Issuer::new(root.params.clone(), &root.key); + let first = with_id(params).signed_by(¤t.key, &issuer).unwrap(); + let known: &[&[u8]] = &[first.der().as_ref(), ¤t.der]; + let context = Context { anchors: &anchors, from: "ada@example.org", now: NOW, known, coverage: Coverage::Whole }; + let checked = check(Signed::Detached { content: CONTENT, signature: &cms }, &context).unwrap(); + assert_eq!((checked.signature.verdict, checked.signature.why), (Verdict::Verified, None)); + assert_eq!(checked.certificate.as_deref(), Some(current.der.as_slice())); + // A later trusted certificate never excuses changed signed content. + let changed = check(Signed::Detached { content: b"changed", signature: &cms }, &context).unwrap(); + assert_eq!(changed.signature.verdict, Verdict::Changed); + } +} diff --git a/crates/smime/src/verify.rs b/crates/smime/src/verify.rs new file mode 100644 index 000000000..c2f9af084 --- /dev/null +++ b/crates/smime/src/verify.rs @@ -0,0 +1,478 @@ +// SPDX-FileCopyrightText: MailCraft contributors +// SPDX-License-Identifier: MIT OR Apache-2.0 +//! Checking CMS SignedData (RFC 5652 §5) as S/MIME carries it (RFC 8551 §3.5): the signer's +//! digest of what was signed, their signature over it, and whether their certificate is trusted +//! and for the message's sender. + +use crate::Timestamp; +use crate::digital_signature::{Coverage, DigitalSignature, SignatureFormat, Signer, Verdict, Why}; +use cms::signed_data::{EncapsulatedContentInfo, SignerIdentifier, SignerInfo}; +use const_oid::ObjectIdentifier; +use der::asn1::OctetString; +use der::{Decode, Encode}; + +use crate::algorithms::{self, Fault, Hash}; +use crate::cert::Cert; +use crate::chain::{self, Anchors}; +use craft_ber::{self as ber, Tlv}; + +/// The most certificates read from one message. +pub const MAX_CERTS: usize = 32; +/// The most signers of one message that are checked. +pub const MAX_SIGNERS: usize = 8; +/// The most signatures checked for one message, its signers' and their certificates' together +/// (#30): an RSA key of 8192 bits takes a while, and a message may carry many. +pub const MAX_VERIFICATIONS: usize = 32; +/// The most certificates tried for one signer: those that its identifier names (the message +/// may carry several of one name; only the one whose key made the signature is the signer's). +pub const MAX_CANDIDATES: usize = 4; + +const SIGNED_DATA: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.2.840.113549.1.7.2"); +const DATA: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.2.840.113549.1.7.1"); +const CONTENT_TYPE: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.2.840.113549.1.9.3"); +const MESSAGE_DIGEST: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.2.840.113549.1.9.4"); +const SIGNING_TIME: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.2.840.113549.1.9.5"); + +/// What a check is made against. +#[derive(Clone, Copy, Debug)] +pub struct Context<'a> { + /// The certificates the host trusts. + pub anchors: &'a Anchors, + /// The message's From address. + pub from: &'a str, + /// The time of the check, seconds since 1970. + pub now: Timestamp, + /// Certificates kept for the sender already, in DER: a message that doesn't carry its + /// signer's certificate may be checked with one of them. + pub known: &'a [&'a [u8]], + /// How much of the message the signed part is: the whole of it only when it is the + /// message's top level. A part is never verified for the message. + pub coverage: Coverage, +} + +/// A Digitally signed message's two halves. +#[derive(Clone, Copy, Debug)] +pub enum Signed<'a> { + /// `multipart/signed`: the signed part as it came (its MIME header and body) and the + /// signature part's bytes (the CMS SignedData, decoded from base64). + Detached { content: &'a [u8], signature: &'a [u8] }, + /// `application/pkcs7-mime; smime-type=signed-data`: the CMS SignedData holding what was + /// signed (decoded from base64). + Opaque(&'a [u8]), +} + +/// What a check found. +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct Checked { + pub signature: DigitalSignature, + /// The signer's certificate, in DER, when the signature over the message is the signer's + /// and the certificate is for the From address: worth keeping for that address (#30 R9). + pub certificate: Option>, +} + +/// Check `signed` against `context`. `None` when the CMS isn't SignedData at all (an Encrypted +/// message's enveloped data, say): not a Digital signature. Never fails otherwise: what can't be +/// read is [`Verdict::Unchecked`]. +pub fn check(signed: Signed<'_>, context: &Context<'_>) -> Option { + check_within(signed, context, MAX_VERIFICATIONS) +} + +/// [`check`] with at most `verifications` signatures checked (for the tests, which spend a +/// smaller budget). +pub(crate) fn check_within(signed: Signed<'_>, context: &Context<'_>, verifications: usize) -> Option { + let blob = match signed { + Signed::Detached { signature, .. } => signature, + Signed::Opaque(blob) => blob, + }; + let unreadable = || Some(unchecked(Why::Unreadable)); + let Some(der) = ber::to_der(blob) else { return unreadable() }; + let Some(parts) = content_info(&der) else { return unreadable() }; + if parts.content_type != SIGNED_DATA { + return None; + } + let Some(data) = signed_data(parts.content) else { return unreadable() }; + let Ok(eci) = EncapsulatedContentInfo::from_der(data.encap.whole) else { return unreadable() }; + // What mail signs is MIME, id-data (RFC 8551 §3.5); a detached signature carries none of it + // and an opaque one all of it. + if eci.econtent_type != DATA { + return unreadable(); + } + let content: &[u8] = match (signed, econtent(&data.encap)) { + (Signed::Detached { content, .. }, None) if eci.econtent.is_none() => content, + (Signed::Opaque(_), Some(c)) => c, + _ => return unreadable(), + }; + let mut pool: Vec = data.certificates.iter().take(MAX_CERTS).filter_map(|c| Cert::from_der(c.whole)).collect(); + pool.extend(context.known.iter().take(MAX_CERTS).filter_map(|c| Cert::from_der(c))); + let mut digests = Digests::new(content, matches!(signed, Signed::Detached { .. })); + let mut budget = verifications; + let mut best: Option = None; + for signer in data.signers.iter().take(MAX_SIGNERS) { + let found = one_signer(signer, &eci, &mut digests, &pool, context, &mut budget); + best = Some(match best { + Some(b) if b.signature.verdict <= found.signature.verdict => b, + _ => found, + }); + } + best.or_else(unreadable).map(|mut c| { + c.signature = c.signature.covering(context.coverage); + c + }) +} + +/// What was signed and its digests, each worked out once (#30: a long message isn't hashed +/// again for every signer and key tried), as it came and in its canonical form. +struct Digests<'a> { + content: &'a [u8], + allow_transport_normalization: bool, + /// The content with lone LFs made CRLF, when it has any: worked out at its first use. + canonical: Option>>, + plain: Vec<(Hash, Vec)>, + crlf: Vec<(Hash, Vec)>, +} + +impl<'a> Digests<'a> { + fn new(content: &'a [u8], allow_transport_normalization: bool) -> Self { + Digests { content, allow_transport_normalization, canonical: None, plain: Vec::new(), crlf: Vec::new() } + } + + fn of(&mut self, hash: Hash) -> Vec { + if let Some((_, d)) = self.plain.iter().find(|(h, _)| *h == hash) { + return d.clone(); + } + let d = hash.digest(self.content); + self.plain.push((hash, d.clone())); + d + } + + /// The digest of the canonical form; `None` when the content has no lone LF (it is its own). + fn of_canonical(&mut self, hash: Hash) -> Option> { + // Encapsulated content is already the exact signed octet sequence. Rewriting + // binary payload newlines would authenticate different bytes than we expose. + if !self.allow_transport_normalization { + return None; + } + if let Some((_, d)) = self.crlf.iter().find(|(h, _)| *h == hash) { + return Some(d.clone()); + } + let content = self.content; + let canonical = self.canonical.get_or_insert_with(|| canonical(content)).as_ref()?; + let d = hash.digest(canonical); + self.crlf.push((hash, d.clone())); + Some(d) + } + + /// Whether `said` is the digest of the content as it came or in its canonical form. + fn matches(&mut self, hash: Hash, said: &[u8]) -> bool { + self.of(hash) == said || self.of_canonical(hash).is_some_and(|d| d == said) + } +} + +fn unchecked(why: Why) -> Checked { + Checked { signature: DigitalSignature::bare(SignatureFormat::Smime, Verdict::Unchecked, why), certificate: None } +} + +struct ContentInfoParts<'a> { + content_type: ObjectIdentifier, + content: &'a [u8], +} + +/// ContentInfo: its type, and the value inside its `[0] EXPLICIT`. +fn content_info(der: &[u8]) -> Option> { + let (outer, rest) = ber::read(der)?; + if outer.tag != 0x30 || !rest.is_empty() { + return None; + } + let fields = ber::children(outer.value)?; + let [oid, explicit] = fields.as_slice() else { return None }; + if oid.tag != 0x06 || explicit.tag != 0xa0 { + return None; + } + let content_type = ObjectIdentifier::from_der(oid.whole).ok()?; + Some(ContentInfoParts { content_type, content: explicit.value }) +} + +/// SignedData's parts as they came, so that signatures are checked over the bytes the signer +/// wrote: what is inside, the certificates, and the signers. +struct SignedDataParts<'a> { + encap: Tlv<'a>, + certificates: Vec>, + signers: Vec>, +} + +/// SignedData read strictly (RFC 5652 §5.1): its version one of those defined, its digest +/// algorithms a SET of algorithm identifiers, encapContentInfo, the certificates and the +/// revocation lists when they are there, in that order, and the signers last: nothing else, and +/// nothing after. +fn signed_data(content: &[u8]) -> Option> { + let (outer, rest) = ber::read(content)?; + if outer.tag != 0x30 || !rest.is_empty() { + return None; + } + let fields = ber::children(outer.value)?; + let mut fields = fields.into_iter(); + let version = fields.next().filter(|f| f.tag == 0x02)?; + if !matches!(version.value, [1] | [3] | [4] | [5]) { + return None; + } + let digests = fields.next().filter(|f| f.tag == 0x31)?; + for d in ber::children(digests.value)? { + spki::AlgorithmIdentifierOwned::from_der(d.whole).ok()?; + } + let encap = fields.next().filter(|f| f.tag == 0x30)?; + let mut next = fields.next()?; + let mut certificates = Vec::new(); + if next.tag == 0xa0 { + // (Other kinds of certificate, [0]..[3] IMPLICIT, are left out; they are never a path.) + certificates = ber::children(next.value)?.into_iter().filter(|c| c.tag == 0x30).collect(); + next = fields.next()?; + } + if next.tag == 0xa1 { + next = fields.next()?; + } + if next.tag != 0x31 || fields.next().is_some() { + return None; + } + Some(SignedDataParts { encap, certificates, signers: ber::children(next.value)? }) +} + +/// The OCTET STRING inside encapContentInfo's `[0] EXPLICIT eContent`, when there is one (and +/// nothing else is there). +fn econtent<'a>(encap: &Tlv<'a>) -> Option<&'a [u8]> { + let fields = ber::children(encap.value)?; + let explicit = fields.get(1).filter(|f| f.tag == 0xa0)?; + let (octets, rest) = ber::read(explicit.value)?; + (octets.tag == 0x04 && rest.is_empty()).then_some(octets.value) +} + +/// The value of the signed attribute `oid`, in DER (its one value), when there is one. +fn attribute(info: &SignerInfo, oid: ObjectIdentifier) -> Option> { + let attrs = info.signed_attrs.as_ref()?; + let attr = attrs.iter().find(|a| a.oid == oid)?; + if attr.values.len() != 1 { + return None; + } + attr.values.iter().next()?.to_der().ok() +} + +/// The bytes a signer with signed attributes signed (RFC 5652 §5.4): the attributes as they came, +/// with their `[0] IMPLICIT` tag made the SET OF's. +fn signed_attributes(raw: &Tlv<'_>) -> Option> { + let fields = ber::children(raw.value)?; + let attrs = fields.iter().find(|f| f.tag == 0xa0)?; + let mut out = attrs.whole.to_vec(); + *out.first_mut()? = 0x31; + Some(out) +} + +/// `content` with every lone LF made CRLF (RFC 8551 §3.1.1's canonical form), when it has one. +fn canonical(content: &[u8]) -> Option> { + let mut lone = false; + let mut out = Vec::with_capacity(content.len().saturating_add(content.len() / 32)); + let mut previous = 0u8; + for &b in content { + if b == b'\n' && previous != b'\r' { + out.push(b'\r'); + lone = true; + } + out.push(b); + previous = b; + } + lone.then_some(out) +} + +fn one_signer( + raw: &Tlv<'_>, + eci: &EncapsulatedContentInfo, + digests: &mut Digests<'_>, + pool: &[Cert], + context: &Context<'_>, + budget: &mut usize, +) -> Checked { + let Ok(info) = SignerInfo::from_der(raw.whole) else { return unchecked(Why::Unreadable) }; + let hash = match Hash::of(&info.digest_alg) { + Ok(hash) => hash, + Err(fault) => return unchecked(why_not(fault)), + }; + let candidates = signer_certs(&info.sid, pool); + if candidates.is_empty() { + return unchecked(Why::NoPublicKey); + } + let signature = info.signature.as_bytes(); + // What the signer's key signed: the signed attributes (which hold the content's digest), or + // without them the content itself, as it came or in its canonical form. + let attributes = match &info.signed_attrs { + Some(_) => match signed_attributes(raw) { + Some(bytes) => Some(bytes), + None => return unchecked(Why::Unreadable), + }, + None => None, + }; + // The signer is the certificate whose key made the signature, of those its identifier names: + // another one of the same name (any can be put in a message) makes no difference. + let mut fault: Option = None; + let mut signer: Option<(&Cert, Result<(), Why>)> = None; + let mut ran_out = false; + for cert in candidates { + let Some(left) = budget.checked_sub(1) else { + ran_out = true; + break; + }; + *budget = left; + let verified = match &attributes { + Some(bytes) => algorithms::verify(cert.public_key(), &info.signature_algorithm, Some(hash), bytes, signature), + None => { + let plain = algorithms::verify_hashed(cert.public_key(), &info.signature_algorithm, Some(hash), &mut |h| digests.of(h), signature); + // (Signed in its canonical form, perhaps: another verification, from the budget.) + if plain == Err(Fault::Invalid) && digests.of_canonical(hash).is_some() { + let Some(left) = budget.checked_sub(1) else { + ran_out = true; + break; + }; + *budget = left; + algorithms::verify_hashed( + cert.public_key(), + &info.signature_algorithm, + Some(hash), + &mut |h| digests.of_canonical(h).unwrap_or_default(), + signature, + ) + } else { + plain + } + } + }; + match verified { + Ok(()) => { + // Matching keys can occur in expired or renewed certificates. A valid + // signature alone does not select the certificate we can trust for mail. + let for_email = cert.for_email() && !cert.is_authority(); + let trust = chain::trust(cert, pool, context.anchors, context.now, budget) + .and_then(|()| for_email.then_some(()).ok_or(Why::NotForEmail)) + .and_then(|()| if cert.is_for(context.from) { Ok(()) } else { Err(Why::AddressMismatch) }); + if trust.is_ok() { + signer = Some((cert, trust)); + break; + } + if signer.is_none() { + signer = Some((cert, trust)); + } + if trust == Err(Why::TooMuch) { + ran_out = true; + break; + } + } + // (Of several faults, what says most: an algorithm, then a malformed key, then no + // match.) + Err(f) => fault = Some(fault.map_or(f, |g| worse(g, f))), + } + } + let Some((cert, mut trust)) = signer else { + return match fault { + // (A certificate not tried may have made it: no answer.) + _ if ran_out => unchecked(Why::TooMuch), + // No key it names made it: changed after signing, or never signed by any of them; + // nobody is named, since none of them fits. + Some(Fault::Invalid) | None => { + Checked { signature: DigitalSignature::bare(SignatureFormat::Smime, Verdict::Changed, Why::Altered), certificate: None } + } + Some(f) => unchecked(why_not(f)), + }; + }; + let result = |verdict: Verdict, why: Option| Checked { + signature: DigitalSignature { + format: SignatureFormat::Smime, + verdict, + why, + signer: Some(signer_of(cert)), + signed_at: signing_time(&info), + revocation_checked: false, + // (`check` says, from where in the message the signed part sat.) + coverage: Coverage::Part, + }, + certificate: None, + }; + if attributes.is_some() { + // The attributes are the signer's own words now: what they say of the content holds. + let Some(said_type) = attribute(&info, CONTENT_TYPE).and_then(|d| ObjectIdentifier::from_der(&d).ok()) else { + return unchecked(Why::Unreadable); + }; + let Some(said_digest) = attribute(&info, MESSAGE_DIGEST).and_then(|d| OctetString::from_der(&d).ok()) else { + return unchecked(Why::Unreadable); + }; + if said_type != eci.econtent_type || !digests.matches(hash, said_digest.as_bytes()) { + return result(Verdict::Changed, Some(Why::Altered)); + } + } + // A candidate left untried may be acceptable. Do not report the first + // refusal as definitive when the shared verification budget was exhausted. + if ran_out { + trust = Err(Why::TooMuch); + } + let mut r = match trust { + Ok(()) => result(Verdict::Verified, None), + Err(Why::TooMuch) => result(Verdict::Unchecked, Some(Why::TooMuch)), + // (An algorithm that's no longer safe on the way to a trust anchor: the certificate can't + // be relied on, but the message is as it was signed.) + Err(why) => result(Verdict::NotVerified, Some(why)), + }; + // Kept for the sender only when it is trusted, valid now and theirs: it is what mail to them + // will be encrypted with. + if trust.is_ok() { + r.certificate = Some(cert.der().to_vec()); + } + // The signer's address that is the sender's comes first: it is the one said. + if let (Some(address), Some(signer)) = (cert.address_for(context.from), r.signature.signer.as_mut()) { + let shown = crate::digital_signature::signer_text(&address); + signer.addresses.retain(|a| !a.eq_ignore_ascii_case(&shown)); + signer.addresses.insert(0, shown); + } + r +} + +/// Of two faults, the one that says most of why a signature can't be relied on. +fn worse(a: Fault, b: Fault) -> Fault { + let rank = |f: Fault| match f { + Fault::Weak => 0, + Fault::Unknown => 1, + Fault::Malformed => 2, + Fault::Invalid => 3, + }; + if rank(b) < rank(a) { b } else { a } +} + +fn why_not(fault: Fault) -> Why { + match fault { + Fault::Weak => Why::WeakAlgorithm, + Fault::Unknown => Why::UnknownAlgorithm, + Fault::Invalid => Why::Altered, + Fault::Malformed => Why::Unreadable, + } +} + +/// The certificates in `pool` that `sid` names, at most [`MAX_CANDIDATES`]. +fn signer_certs<'a>(sid: &SignerIdentifier, pool: &'a [Cert]) -> Vec<&'a Cert> { + match sid { + SignerIdentifier::IssuerAndSerialNumber(isn) => { + let Ok(issuer) = isn.issuer.to_der() else { return Vec::new() }; + let serial = isn.serial_number.as_bytes(); + pool.iter().filter(|c| c.issuer() == issuer.as_slice() && c.serial() == serial).take(MAX_CANDIDATES).collect() + } + SignerIdentifier::SubjectKeyIdentifier(ski) => { + let id = ski.0.as_bytes(); + pool.iter().filter(|c| c.key_id().as_deref() == Some(id)).take(MAX_CANDIDATES).collect() + } + } +} + +fn signer_of(cert: &Cert) -> Signer { + let (not_before, not_after) = cert.validity(); + Signer { name: cert.name(), addresses: cert.addresses(), fingerprint: cert.fingerprint(), issuer: cert.issuer_name(), not_before, not_after } +} + +/// The signing time the signer gives (RFC 5652 §11.3): their word, unchecked. +fn signing_time(info: &SignerInfo) -> Option { + let der = attribute(info, SIGNING_TIME)?; + let time = x509_cert::time::Time::from_der(&der).ok()?; + Timestamp::try_from(time.to_unix_duration().as_secs()).ok() +} diff --git a/crates/smime/testdata/README.md b/crates/smime/testdata/README.md new file mode 100644 index 000000000..9200f2cc1 --- /dev/null +++ b/crates/smime/testdata/README.md @@ -0,0 +1,7 @@ +# S/MIME test vectors + +Restored from `UCS-Care-Group/mailcraft` commit +`240d1d42fe394cf3274402b180663ba9b43ca180`, `crates/smime/testdata`. +The source test suite identifies these as RFC 9216 example certificates and +OpenSSL-generated message vectors. These are public examples, not user mail or keys. +Source attribution: MailCraft contributors, MIT OR Apache-2.0. diff --git a/crates/smime/testdata/alice.sign.der b/crates/smime/testdata/alice.sign.der new file mode 100644 index 000000000..9bff7d1b3 Binary files /dev/null and b/crates/smime/testdata/alice.sign.der differ diff --git a/crates/smime/testdata/ca.rsa.der b/crates/smime/testdata/ca.rsa.der new file mode 100644 index 000000000..193b9ab9f Binary files /dev/null and b/crates/smime/testdata/ca.rsa.der differ diff --git a/crates/smime/testdata/detached.eml b/crates/smime/testdata/detached.eml new file mode 100644 index 000000000..51e8d3204 --- /dev/null +++ b/crates/smime/testdata/detached.eml @@ -0,0 +1,60 @@ +To: bob@smime.example +From: alice@smime.example +Subject: Signed minutes +MIME-Version: 1.0 +Content-Type: multipart/signed; protocol="application/pkcs7-signature"; micalg="sha-256"; boundary="----011A3E8D1DC66D3261BBFB3EB4674ACD" + +This is an S/MIME signed message + +------011A3E8D1DC66D3261BBFB3EB4674ACD +Content-Type: text/plain; charset=us-ascii + +Hello Bob, + +The minutes of Tuesday are attached in spirit. + +Alice + +------011A3E8D1DC66D3261BBFB3EB4674ACD +Content-Type: application/pkcs7-signature; name="smime.p7s" +Content-Transfer-Encoding: base64 +Content-Disposition: attachment; filename="smime.p7s" + +MIIGiQYJKoZIhvcNAQcCoIIGejCCBnYCAQExDTALBglghkgBZQMEAgEwCwYJKoZI +hvcNAQcBoIID0zCCA88wggK3oAMCAQICEzdBBXntdX9CqaJcOvT4as6aqdcwDQYJ +KoZIhvcNAQENBQAwVTENMAsGA1UEChMESUVURjERMA8GA1UECxMITEFNUFMgV0cx +MTAvBgNVBAMTKFNhbXBsZSBMQU1QUyBSU0EgQ2VydGlmaWNhdGlvbiBBdXRob3Jp +dHkwIBcNMTkxMTIwMDY1NDE4WhgPMjA1MjA5MjcwNjU0MThaMDsxDTALBgNVBAoT +BElFVEYxETAPBgNVBAsTCExBTVBTIFdHMRcwFQYDVQQDEw5BbGljZSBMb3ZlbGFj +ZTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALT0iehYOBY+TZp/T5K2 +KNI05Hwr+E3wP6XTvyi6WWyTgBK9LCOwI2juwdRrjFBSXkk7pWpjXwsA3A5GOtz0 +FpfgyC7OxsVcF7q4WHWZWleYXFKlQHJD73nQwXP968+A/3rBX7PhO0DBbZnfitOL +PgPEwjTtdg0VQQ6Wz+CRQ/YbHPKaw7aRphZO63dKvIKp4cQVtkWQHi6syTjGsgkL +cLNau5LZDQUdsGV+SAo3nBdWCRYV+I65x8Kf4hCxqqmjV3d/2NKRu0BXnDe/N+iD +z3X0zEoj0fqXgq4SWcC0nsG1lyyXt1TL270I6ATKRGJWiQVCCpDtc0NT6vdJ45bC +SzsCAwEAAaOBrzCBrDAMBgNVHRMBAf8EAjAAMBcGA1UdIAQQMA4wDAYKYIZIAWUD +AgEwATAeBgNVHREEFzAVgRNhbGljZUBzbWltZS5leGFtcGxlMBMGA1UdJQQMMAoG +CCsGAQUFBwMEMA4GA1UdDwEB/wQEAwIGwDAdBgNVHQ4EFgQUu/bMsi0dBhIcl64p +apAQ0yBmZnMwHwYDVR0jBBgwFoAUkTCOfAcXDKfxCShlNhpnHGh29FkwDQYJKoZI +hvcNAQENBQADggEBAHOJojanzqmgaSN3/gqSQ4cbbmdj/R40BEPr+gXT+xiidfZ2 +iLNwYyTneuK6AChwKfnNvOFb8lV1iffRTF/KtmVEDMR/sYeqAH83KM5p3el2lVh4 +OHhyI0qNuz5oShNaACSioQ23WxHGVy9vsdVfnbhsplrWg9NQ2WbpCmK+2oMh2oYl +0Z/wvXMt9cG6jbMvcdH4z0IOvg6mrYkKTM/RCGnumghxwYToj1OyD5Gs4D2IJCw+ +fX5ODxh52MbNRYXTus2ZPRPM8JXNQC4GWv4km3M4rKnJDd6hnoQ9rNeozIcBVyyb +QYjfrgg4DRvw9Ksk22OH4ConlB8f7R7s1LM2cSYxggJ8MIICeAIBATBsMFUxDTAL +BgNVBAoTBElFVEYxETAPBgNVBAsTCExBTVBTIFdHMTEwLwYDVQQDEyhTYW1wbGUg +TEFNUFMgUlNBIENlcnRpZmljYXRpb24gQXV0aG9yaXR5AhM3QQV57XV/QqmiXDr0 ++GrOmqnXMAsGCWCGSAFlAwQCAaCB5DAYBgkqhkiG9w0BCQMxCwYJKoZIhvcNAQcB +MBwGCSqGSIb3DQEJBTEPFw0yNjExMDkxMjA5NTBaMC8GCSqGSIb3DQEJBDEiBCCl +3jtcr1bjeDRcGd4HoRLXWhkBqvOm0Ywlw7H6AYF2pzB5BgkqhkiG9w0BCQ8xbDBq +MAsGCWCGSAFlAwQBKjALBglghkgBZQMEARYwCwYJYIZIAWUDBAECMAoGCCqGSIb3 +DQMHMA4GCCqGSIb3DQMCAgIAgDANBggqhkiG9w0DAgIBQDAHBgUrDgMCBzANBggq +hkiG9w0DAgIBKDANBgkqhkiG9w0BAQEFAASCAQCda8b7o1a3/12TBKbRDLoAW5sm +1MBd1j0huWs+wTdj6G3q0cOAPJ2OxZuNfZnUwce+CNAWsKyNyPXIm9k997yW837b +e//lUIXPh8b12hUM6te298xvNqCdNNA0Y3/ihNZvb0fbl4nJfu0X+QMo2VqcFI6w +cSRBcbMB1/pB47AZF1qOR1+WlvxWTfJ1gHRMvpgtmd5NwNx96jM4i8yMxa4zoXmW +ROlOHYcNSDpVkkuhH+m60zxk52vOdTmOdg6CY+rFcMrgY6R2qZu/sfQrWAFiKOYl +CSgqvp/pPEty15Kt8inC+DYrIDNdlLg9A1RPpV+H4XxTSgRiEPTFbPKdOjG/ + +------011A3E8D1DC66D3261BBFB3EB4674ACD-- + diff --git a/crates/smime/testdata/noattr.eml b/crates/smime/testdata/noattr.eml new file mode 100644 index 000000000..0a5d7dad1 --- /dev/null +++ b/crates/smime/testdata/noattr.eml @@ -0,0 +1,56 @@ +To: bob@smime.example +From: alice@smime.example +Subject: No attributes +MIME-Version: 1.0 +Content-Type: multipart/signed; protocol="application/pkcs7-signature"; micalg="sha-256"; boundary="----9D215F381F61DA9DBEC8E6CEAF3E2E88" + +This is an S/MIME signed message + +------9D215F381F61DA9DBEC8E6CEAF3E2E88 +Content-Type: text/plain; charset=us-ascii + +Hello Bob, + +The minutes of Tuesday are attached in spirit. + +Alice + +------9D215F381F61DA9DBEC8E6CEAF3E2E88 +Content-Type: application/pkcs7-signature; name="smime.p7s" +Content-Transfer-Encoding: base64 +Content-Disposition: attachment; filename="smime.p7s" + +MIIFogYJKoZIhvcNAQcCoIIFkzCCBY8CAQExDTALBglghkgBZQMEAgEwCwYJKoZI +hvcNAQcBoIID0zCCA88wggK3oAMCAQICEzdBBXntdX9CqaJcOvT4as6aqdcwDQYJ +KoZIhvcNAQENBQAwVTENMAsGA1UEChMESUVURjERMA8GA1UECxMITEFNUFMgV0cx +MTAvBgNVBAMTKFNhbXBsZSBMQU1QUyBSU0EgQ2VydGlmaWNhdGlvbiBBdXRob3Jp +dHkwIBcNMTkxMTIwMDY1NDE4WhgPMjA1MjA5MjcwNjU0MThaMDsxDTALBgNVBAoT +BElFVEYxETAPBgNVBAsTCExBTVBTIFdHMRcwFQYDVQQDEw5BbGljZSBMb3ZlbGFj +ZTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALT0iehYOBY+TZp/T5K2 +KNI05Hwr+E3wP6XTvyi6WWyTgBK9LCOwI2juwdRrjFBSXkk7pWpjXwsA3A5GOtz0 +FpfgyC7OxsVcF7q4WHWZWleYXFKlQHJD73nQwXP968+A/3rBX7PhO0DBbZnfitOL +PgPEwjTtdg0VQQ6Wz+CRQ/YbHPKaw7aRphZO63dKvIKp4cQVtkWQHi6syTjGsgkL +cLNau5LZDQUdsGV+SAo3nBdWCRYV+I65x8Kf4hCxqqmjV3d/2NKRu0BXnDe/N+iD +z3X0zEoj0fqXgq4SWcC0nsG1lyyXt1TL270I6ATKRGJWiQVCCpDtc0NT6vdJ45bC +SzsCAwEAAaOBrzCBrDAMBgNVHRMBAf8EAjAAMBcGA1UdIAQQMA4wDAYKYIZIAWUD +AgEwATAeBgNVHREEFzAVgRNhbGljZUBzbWltZS5leGFtcGxlMBMGA1UdJQQMMAoG +CCsGAQUFBwMEMA4GA1UdDwEB/wQEAwIGwDAdBgNVHQ4EFgQUu/bMsi0dBhIcl64p +apAQ0yBmZnMwHwYDVR0jBBgwFoAUkTCOfAcXDKfxCShlNhpnHGh29FkwDQYJKoZI +hvcNAQENBQADggEBAHOJojanzqmgaSN3/gqSQ4cbbmdj/R40BEPr+gXT+xiidfZ2 +iLNwYyTneuK6AChwKfnNvOFb8lV1iffRTF/KtmVEDMR/sYeqAH83KM5p3el2lVh4 +OHhyI0qNuz5oShNaACSioQ23WxHGVy9vsdVfnbhsplrWg9NQ2WbpCmK+2oMh2oYl +0Z/wvXMt9cG6jbMvcdH4z0IOvg6mrYkKTM/RCGnumghxwYToj1OyD5Gs4D2IJCw+ +fX5ODxh52MbNRYXTus2ZPRPM8JXNQC4GWv4km3M4rKnJDd6hnoQ9rNeozIcBVyyb +QYjfrgg4DRvw9Ksk22OH4ConlB8f7R7s1LM2cSYxggGVMIIBkQIBATBsMFUxDTAL +BgNVBAoTBElFVEYxETAPBgNVBAsTCExBTVBTIFdHMTEwLwYDVQQDEyhTYW1wbGUg +TEFNUFMgUlNBIENlcnRpZmljYXRpb24gQXV0aG9yaXR5AhM3QQV57XV/QqmiXDr0 ++GrOmqnXMAsGCWCGSAFlAwQCATANBgkqhkiG9w0BAQEFAASCAQB424lCX+hFmHkC +NtPDglt4jFneZge6fSFGI898+4Ve5+SehVpM2pmyugnk9NvpiEqI9ywInDENgbPc +lDxTkNSWoFRMAvexvyK91CLZ6E8oRur8unC6ZMMxcnpqbJqgJgW9BR4j8Q2octPv +IFwERtqcsNLuDx9kUh+MR6Z66rELQAesXzOiWMhqDwJKmQxNZqVu4k+BQqLmyHbK +BRS6uDN54Xgs7tHdFKhewEwoMLA+PEOTCpLcFRzWydywlxTJMMivqmEdvPC4R8pA +8XKDYA4k++6y9wjiq4e1Uc/+Ex/n6CgcJZNAo2qS8u0wIGfBL9xW9qEOnAI8wZPp +IoaGX1Qa + +------9D215F381F61DA9DBEC8E6CEAF3E2E88-- + diff --git a/crates/smime/testdata/nocerts.eml b/crates/smime/testdata/nocerts.eml new file mode 100644 index 000000000..69741fc90 --- /dev/null +++ b/crates/smime/testdata/nocerts.eml @@ -0,0 +1,40 @@ +To: bob@smime.example +From: alice@smime.example +Subject: No certificate +MIME-Version: 1.0 +Content-Type: multipart/signed; protocol="application/pkcs7-signature"; micalg="sha-256"; boundary="----C714793EB4AEA5E36741725AF174BFC1" + +This is an S/MIME signed message + +------C714793EB4AEA5E36741725AF174BFC1 +Content-Type: text/plain; charset=us-ascii + +Hello Bob, + +The minutes of Tuesday are attached in spirit. + +Alice + +------C714793EB4AEA5E36741725AF174BFC1 +Content-Type: application/pkcs7-signature; name="smime.p7s" +Content-Transfer-Encoding: base64 +Content-Disposition: attachment; filename="smime.p7s" + +MIICsgYJKoZIhvcNAQcCoIICozCCAp8CAQExDTALBglghkgBZQMEAgEwCwYJKoZI +hvcNAQcBMYICfDCCAngCAQEwbDBVMQ0wCwYDVQQKEwRJRVRGMREwDwYDVQQLEwhM +QU1QUyBXRzExMC8GA1UEAxMoU2FtcGxlIExBTVBTIFJTQSBDZXJ0aWZpY2F0aW9u +IEF1dGhvcml0eQITN0EFee11f0Kpolw69Phqzpqp1zALBglghkgBZQMEAgGggeQw +GAYJKoZIhvcNAQkDMQsGCSqGSIb3DQEHATAcBgkqhkiG9w0BCQUxDxcNMjYxMTA5 +MTIwOTUxWjAvBgkqhkiG9w0BCQQxIgQgpd47XK9W43g0XBneB6ES11oZAarzptGM +JcOx+gGBdqcweQYJKoZIhvcNAQkPMWwwajALBglghkgBZQMEASowCwYJYIZIAWUD +BAEWMAsGCWCGSAFlAwQBAjAKBggqhkiG9w0DBzAOBggqhkiG9w0DAgICAIAwDQYI +KoZIhvcNAwICAUAwBwYFKw4DAgcwDQYIKoZIhvcNAwICASgwDQYJKoZIhvcNAQEB +BQAEggEAnQNd8e5Phn1idVWgZqoGUqKXZQF2ojmQ9duGv5gAIzTmOpI6l4WaKj4t +T2EFa8cwQaIVhFz9ZKshEPSDep9y7IukzVi379CuHRonelJ9rwPQhkX7KLJVfnmh +AFc5XH9AdVxHPvpnP59ZankXO6MvzVO9kYKQdflZC8gv5Bl7Sh+FpS/0VGPEXNH+ +tkRGeX2jo5YY5Xsj2gGTBbiZQ07urn+dcETJxeGI+cLa5tkg3YBeLKthGEMekv9t +JakkfMsvpMW5m4TsiOz0A8gBrk5zP5YWEU+h+jKvSlQXyYcGbU04+Ir+y0HSa2ob +KUozlJlOmmhYzeok0wAsFf+V6qipCg== + +------C714793EB4AEA5E36741725AF174BFC1-- + diff --git a/crates/smime/testdata/opaque-ber.eml b/crates/smime/testdata/opaque-ber.eml new file mode 100644 index 000000000..e6b171749 --- /dev/null +++ b/crates/smime/testdata/opaque-ber.eml @@ -0,0 +1,47 @@ +To: bob@smime.example +From: alice@smime.example +Subject: Opaque minutes +MIME-Version: 1.0 +Content-Disposition: attachment; filename="smime.p7m" +Content-Type: application/pkcs7-mime; smime-type=signed-data; name="smime.p7m" +Content-Transfer-Encoding: base64 + +MIAGCSqGSIb3DQEHAqCAMIACAQExDTALBglghkgBZQMEAgEwgAYJKoZIhvcNAQcB +oIAkgAR1Q29udGVudC1UeXBlOiB0ZXh0L3BsYWluOyBjaGFyc2V0PXVzLWFzY2lp +DQoNCkhlbGxvIEJvYiwNCg0KVGhlIG1pbnV0ZXMgb2YgVHVlc2RheSBhcmUgYXR0 +YWNoZWQgaW4gc3Bpcml0Lg0KDQpBbGljZQ0KAAAAAAAAoIID0zCCA88wggK3oAMC +AQICEzdBBXntdX9CqaJcOvT4as6aqdcwDQYJKoZIhvcNAQENBQAwVTENMAsGA1UE +ChMESUVURjERMA8GA1UECxMITEFNUFMgV0cxMTAvBgNVBAMTKFNhbXBsZSBMQU1Q +UyBSU0EgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwIBcNMTkxMTIwMDY1NDE4WhgP +MjA1MjA5MjcwNjU0MThaMDsxDTALBgNVBAoTBElFVEYxETAPBgNVBAsTCExBTVBT +IFdHMRcwFQYDVQQDEw5BbGljZSBMb3ZlbGFjZTCCASIwDQYJKoZIhvcNAQEBBQAD +ggEPADCCAQoCggEBALT0iehYOBY+TZp/T5K2KNI05Hwr+E3wP6XTvyi6WWyTgBK9 +LCOwI2juwdRrjFBSXkk7pWpjXwsA3A5GOtz0FpfgyC7OxsVcF7q4WHWZWleYXFKl +QHJD73nQwXP968+A/3rBX7PhO0DBbZnfitOLPgPEwjTtdg0VQQ6Wz+CRQ/YbHPKa +w7aRphZO63dKvIKp4cQVtkWQHi6syTjGsgkLcLNau5LZDQUdsGV+SAo3nBdWCRYV ++I65x8Kf4hCxqqmjV3d/2NKRu0BXnDe/N+iDz3X0zEoj0fqXgq4SWcC0nsG1lyyX +t1TL270I6ATKRGJWiQVCCpDtc0NT6vdJ45bCSzsCAwEAAaOBrzCBrDAMBgNVHRMB +Af8EAjAAMBcGA1UdIAQQMA4wDAYKYIZIAWUDAgEwATAeBgNVHREEFzAVgRNhbGlj +ZUBzbWltZS5leGFtcGxlMBMGA1UdJQQMMAoGCCsGAQUFBwMEMA4GA1UdDwEB/wQE +AwIGwDAdBgNVHQ4EFgQUu/bMsi0dBhIcl64papAQ0yBmZnMwHwYDVR0jBBgwFoAU +kTCOfAcXDKfxCShlNhpnHGh29FkwDQYJKoZIhvcNAQENBQADggEBAHOJojanzqmg +aSN3/gqSQ4cbbmdj/R40BEPr+gXT+xiidfZ2iLNwYyTneuK6AChwKfnNvOFb8lV1 +iffRTF/KtmVEDMR/sYeqAH83KM5p3el2lVh4OHhyI0qNuz5oShNaACSioQ23WxHG +Vy9vsdVfnbhsplrWg9NQ2WbpCmK+2oMh2oYl0Z/wvXMt9cG6jbMvcdH4z0IOvg6m +rYkKTM/RCGnumghxwYToj1OyD5Gs4D2IJCw+fX5ODxh52MbNRYXTus2ZPRPM8JXN +QC4GWv4km3M4rKnJDd6hnoQ9rNeozIcBVyybQYjfrgg4DRvw9Ksk22OH4ConlB8f +7R7s1LM2cSYxggJ8MIICeAIBATBsMFUxDTALBgNVBAoTBElFVEYxETAPBgNVBAsT +CExBTVBTIFdHMTEwLwYDVQQDEyhTYW1wbGUgTEFNUFMgUlNBIENlcnRpZmljYXRp +b24gQXV0aG9yaXR5AhM3QQV57XV/QqmiXDr0+GrOmqnXMAsGCWCGSAFlAwQCAaCB +5DAYBgkqhkiG9w0BCQMxCwYJKoZIhvcNAQcBMBwGCSqGSIb3DQEJBTEPFw0yNjEx +MDkxMjA5NTFaMC8GCSqGSIb3DQEJBDEiBCCl3jtcr1bjeDRcGd4HoRLXWhkBqvOm +0Ywlw7H6AYF2pzB5BgkqhkiG9w0BCQ8xbDBqMAsGCWCGSAFlAwQBKjALBglghkgB +ZQMEARYwCwYJYIZIAWUDBAECMAoGCCqGSIb3DQMHMA4GCCqGSIb3DQMCAgIAgDAN +BggqhkiG9w0DAgIBQDAHBgUrDgMCBzANBggqhkiG9w0DAgIBKDANBgkqhkiG9w0B +AQEFAASCAQCdA13x7k+GfWJ1VaBmqgZSopdlAXaiOZD124a/mAAjNOY6kjqXhZoq +Pi1PYQVrxzBBohWEXP1kqyEQ9IN6n3Lsi6TNWLfv0K4dGid6Un2vA9CGRfsoslV+ +eaEAVzlcf0B1XEc++mc/n1lqeRc7oy/NU72RgpB1+VkLyC/kGXtKH4WlL/RUY8Rc +0f62REZ5faOjlhjleyPaAZMFuJlDTu6uf51wRMnF4Yj5wtrm2SDdgF4sq2EYQx6S +/20lqSR8yy+kxbmbhOyI7PQDyAGuTnM/lhYRT6H6Mq9KVBfJhwZtTTj4iv7LQdJr +ahspSjOUmU6aaFjN6iTTACwV/5XqqKkKAAAAAAAA + diff --git a/crates/smime/testdata/opaque.eml b/crates/smime/testdata/opaque.eml new file mode 100644 index 000000000..226af352b --- /dev/null +++ b/crates/smime/testdata/opaque.eml @@ -0,0 +1,47 @@ +To: bob@smime.example +From: alice@smime.example +Subject: Opaque minutes +MIME-Version: 1.0 +Content-Disposition: attachment; filename="smime.p7m" +Content-Type: application/pkcs7-mime; smime-type=signed-data; name="smime.p7m" +Content-Transfer-Encoding: base64 + +MIIHAwYJKoZIhvcNAQcCoIIG9DCCBvACAQExDTALBglghkgBZQMEAgEwgYQGCSqG +SIb3DQEHAaB3BHVDb250ZW50LVR5cGU6IHRleHQvcGxhaW47IGNoYXJzZXQ9dXMt +YXNjaWkNCg0KSGVsbG8gQm9iLA0KDQpUaGUgbWludXRlcyBvZiBUdWVzZGF5IGFy +ZSBhdHRhY2hlZCBpbiBzcGlyaXQuDQoNCkFsaWNlDQqgggPTMIIDzzCCAregAwIB +AgITN0EFee11f0Kpolw69Phqzpqp1zANBgkqhkiG9w0BAQ0FADBVMQ0wCwYDVQQK +EwRJRVRGMREwDwYDVQQLEwhMQU1QUyBXRzExMC8GA1UEAxMoU2FtcGxlIExBTVBT +IFJTQSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAgFw0xOTExMjAwNjU0MThaGA8y +MDUyMDkyNzA2NTQxOFowOzENMAsGA1UEChMESUVURjERMA8GA1UECxMITEFNUFMg +V0cxFzAVBgNVBAMTDkFsaWNlIExvdmVsYWNlMIIBIjANBgkqhkiG9w0BAQEFAAOC +AQ8AMIIBCgKCAQEAtPSJ6Fg4Fj5Nmn9PkrYo0jTkfCv4TfA/pdO/KLpZbJOAEr0s +I7AjaO7B1GuMUFJeSTulamNfCwDcDkY63PQWl+DILs7GxVwXurhYdZlaV5hcUqVA +ckPvedDBc/3rz4D/esFfs+E7QMFtmd+K04s+A8TCNO12DRVBDpbP4JFD9hsc8prD +tpGmFk7rd0q8gqnhxBW2RZAeLqzJOMayCQtws1q7ktkNBR2wZX5ICjecF1YJFhX4 +jrnHwp/iELGqqaNXd3/Y0pG7QFecN7836IPPdfTMSiPR+peCrhJZwLSewbWXLJe3 +VMvbvQjoBMpEYlaJBUIKkO1zQ1Pq90njlsJLOwIDAQABo4GvMIGsMAwGA1UdEwEB +/wQCMAAwFwYDVR0gBBAwDjAMBgpghkgBZQMCATABMB4GA1UdEQQXMBWBE2FsaWNl +QHNtaW1lLmV4YW1wbGUwEwYDVR0lBAwwCgYIKwYBBQUHAwQwDgYDVR0PAQH/BAQD +AgbAMB0GA1UdDgQWBBS79syyLR0GEhyXrilqkBDTIGZmczAfBgNVHSMEGDAWgBSR +MI58BxcMp/EJKGU2GmccaHb0WTANBgkqhkiG9w0BAQ0FAAOCAQEAc4miNqfOqaBp +I3f+CpJDhxtuZ2P9HjQEQ+v6BdP7GKJ19naIs3BjJOd64roAKHAp+c284VvyVXWJ +99FMX8q2ZUQMxH+xh6oAfzcozmnd6XaVWHg4eHIjSo27PmhKE1oAJKKhDbdbEcZX +L2+x1V+duGymWtaD01DZZukKYr7agyHahiXRn/C9cy31wbqNsy9x0fjPQg6+Dqat +iQpMz9EIae6aCHHBhOiPU7IPkazgPYgkLD59fk4PGHnYxs1FhdO6zZk9E8zwlc1A +LgZa/iSbczisqckN3qGehD2s16jMhwFXLJtBiN+uCDgNG/D0qyTbY4fgKieUHx/t +HuzUszZxJjGCAnwwggJ4AgEBMGwwVTENMAsGA1UEChMESUVURjERMA8GA1UECxMI +TEFNUFMgV0cxMTAvBgNVBAMTKFNhbXBsZSBMQU1QUyBSU0EgQ2VydGlmaWNhdGlv +biBBdXRob3JpdHkCEzdBBXntdX9CqaJcOvT4as6aqdcwCwYJYIZIAWUDBAIBoIHk +MBgGCSqGSIb3DQEJAzELBgkqhkiG9w0BBwEwHAYJKoZIhvcNAQkFMQ8XDTI2MTEw +OTEyMDk1MVowLwYJKoZIhvcNAQkEMSIEIKXeO1yvVuN4NFwZ3gehEtdaGQGq86bR +jCXDsfoBgXanMHkGCSqGSIb3DQEJDzFsMGowCwYJYIZIAWUDBAEqMAsGCWCGSAFl +AwQBFjALBglghkgBZQMEAQIwCgYIKoZIhvcNAwcwDgYIKoZIhvcNAwICAgCAMA0G +CCqGSIb3DQMCAgFAMAcGBSsOAwIHMA0GCCqGSIb3DQMCAgEoMA0GCSqGSIb3DQEB +AQUABIIBAJ0DXfHuT4Z9YnVVoGaqBlKil2UBdqI5kPXbhr+YACM05jqSOpeFmio+ +LU9hBWvHMEGiFYRc/WSrIRD0g3qfcuyLpM1Yt+/Qrh0aJ3pSfa8D0IZF+yiyVX55 +oQBXOVx/QHVcRz76Zz+fWWp5FzujL81TvZGCkHX5WQvIL+QZe0ofhaUv9FRjxFzR +/rZERnl9o6OWGOV7I9oBkwW4mUNO7q5/nXBEycXhiPnC2ubZIN2AXiyrYRhDHpL/ +bSWpJHzLL6TFuZuE7Ijs9APIAa5Ocz+WFhFPofoyr0pUF8mHBm1NOPiK/stB0mtq +GylKM5SZTppoWM3qJNMALBX/leqoqQo= + diff --git a/crates/smime/testdata/pss.eml b/crates/smime/testdata/pss.eml new file mode 100644 index 000000000..1fa054da5 --- /dev/null +++ b/crates/smime/testdata/pss.eml @@ -0,0 +1,62 @@ +To: bob@smime.example +From: alice@smime.example +Subject: PSS minutes +MIME-Version: 1.0 +Content-Type: multipart/signed; protocol="application/pkcs7-signature"; micalg="sha-384"; boundary="----E33A7E587DACB5F6484402726C200129" + +This is an S/MIME signed message + +------E33A7E587DACB5F6484402726C200129 +Content-Type: text/plain; charset=us-ascii + +Hello Bob, + +The minutes of Tuesday are attached in spirit. + +Alice + +------E33A7E587DACB5F6484402726C200129 +Content-Type: application/pkcs7-signature; name="smime.p7s" +Content-Transfer-Encoding: base64 +Content-Disposition: attachment; filename="smime.p7s" + +MIIGzQYJKoZIhvcNAQcCoIIGvjCCBroCAQExDTALBglghkgBZQMEAgIwCwYJKoZI +hvcNAQcBoIID0zCCA88wggK3oAMCAQICEzdBBXntdX9CqaJcOvT4as6aqdcwDQYJ +KoZIhvcNAQENBQAwVTENMAsGA1UEChMESUVURjERMA8GA1UECxMITEFNUFMgV0cx +MTAvBgNVBAMTKFNhbXBsZSBMQU1QUyBSU0EgQ2VydGlmaWNhdGlvbiBBdXRob3Jp +dHkwIBcNMTkxMTIwMDY1NDE4WhgPMjA1MjA5MjcwNjU0MThaMDsxDTALBgNVBAoT +BElFVEYxETAPBgNVBAsTCExBTVBTIFdHMRcwFQYDVQQDEw5BbGljZSBMb3ZlbGFj +ZTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALT0iehYOBY+TZp/T5K2 +KNI05Hwr+E3wP6XTvyi6WWyTgBK9LCOwI2juwdRrjFBSXkk7pWpjXwsA3A5GOtz0 +FpfgyC7OxsVcF7q4WHWZWleYXFKlQHJD73nQwXP968+A/3rBX7PhO0DBbZnfitOL +PgPEwjTtdg0VQQ6Wz+CRQ/YbHPKaw7aRphZO63dKvIKp4cQVtkWQHi6syTjGsgkL +cLNau5LZDQUdsGV+SAo3nBdWCRYV+I65x8Kf4hCxqqmjV3d/2NKRu0BXnDe/N+iD +z3X0zEoj0fqXgq4SWcC0nsG1lyyXt1TL270I6ATKRGJWiQVCCpDtc0NT6vdJ45bC +SzsCAwEAAaOBrzCBrDAMBgNVHRMBAf8EAjAAMBcGA1UdIAQQMA4wDAYKYIZIAWUD +AgEwATAeBgNVHREEFzAVgRNhbGljZUBzbWltZS5leGFtcGxlMBMGA1UdJQQMMAoG +CCsGAQUFBwMEMA4GA1UdDwEB/wQEAwIGwDAdBgNVHQ4EFgQUu/bMsi0dBhIcl64p +apAQ0yBmZnMwHwYDVR0jBBgwFoAUkTCOfAcXDKfxCShlNhpnHGh29FkwDQYJKoZI +hvcNAQENBQADggEBAHOJojanzqmgaSN3/gqSQ4cbbmdj/R40BEPr+gXT+xiidfZ2 +iLNwYyTneuK6AChwKfnNvOFb8lV1iffRTF/KtmVEDMR/sYeqAH83KM5p3el2lVh4 +OHhyI0qNuz5oShNaACSioQ23WxHGVy9vsdVfnbhsplrWg9NQ2WbpCmK+2oMh2oYl +0Z/wvXMt9cG6jbMvcdH4z0IOvg6mrYkKTM/RCGnumghxwYToj1OyD5Gs4D2IJCw+ +fX5ODxh52MbNRYXTus2ZPRPM8JXNQC4GWv4km3M4rKnJDd6hnoQ9rNeozIcBVyyb +QYjfrgg4DRvw9Ksk22OH4ConlB8f7R7s1LM2cSYxggLAMIICvAIBATBsMFUxDTAL +BgNVBAoTBElFVEYxETAPBgNVBAsTCExBTVBTIFdHMTEwLwYDVQQDEyhTYW1wbGUg +TEFNUFMgUlNBIENlcnRpZmljYXRpb24gQXV0aG9yaXR5AhM3QQV57XV/QqmiXDr0 ++GrOmqnXMAsGCWCGSAFlAwQCAqCB9DAYBgkqhkiG9w0BCQMxCwYJKoZIhvcNAQcB +MBwGCSqGSIb3DQEJBTEPFw0yNjExMDkxMjA5NTFaMD8GCSqGSIb3DQEJBDEyBDD4 +2qGCADijATcenlkhPijI4rlMODPEVAYYj23MDi+U5OoGk43dPeqaLE2/OuP3d9Ew +eQYJKoZIhvcNAQkPMWwwajALBglghkgBZQMEASowCwYJYIZIAWUDBAEWMAsGCWCG +SAFlAwQBAjAKBggqhkiG9w0DBzAOBggqhkiG9w0DAgICAIAwDQYIKoZIhvcNAwIC +AUAwBwYFKw4DAgcwDQYIKoZIhvcNAwICASgwQQYJKoZIhvcNAQEKMDSgDzANBglg +hkgBZQMEAgIFAKEcMBoGCSqGSIb3DQEBCDANBglghkgBZQMEAgIFAKIDAgEwBIIB +AFYJfuEecetLuIAZBdhyppBpqzeF9JN9RuGyi7qmrUFFU8xSyNh8/NFFE7UJ91Eo ++/zbQkuz0lfak8NSA1dw+qr2LnmnvpjD7LelEDJawTWJwzFnAVQaW7PaduLBwxZU +WmJRV6h4UZ1YEh8XEjpCqeUHTfqSiEyCaw0XOct6UoPOZQ64/7ytBOwrMUdMZNO5 +upqKR/NZSTwG91Izy78ORpW97ckbFcsklPOedHypUuecJTK5gzMEh2w5TGYZGRNs +x2kz6OqzzdhMUdT9DG84PGmZDTrp+Gw8lBWCUJs/1AMYm8ZKx/eSJwasJpeGaFUS +gPrYtiiA1mEl+vujBbhlwSo= + +------E33A7E587DACB5F6484402726C200129-- + diff --git a/crates/smime/testdata/sha1.eml b/crates/smime/testdata/sha1.eml new file mode 100644 index 000000000..3a25ad941 --- /dev/null +++ b/crates/smime/testdata/sha1.eml @@ -0,0 +1,60 @@ +To: bob@smime.example +From: alice@smime.example +Subject: Old minutes +MIME-Version: 1.0 +Content-Type: multipart/signed; protocol="application/pkcs7-signature"; micalg="sha1"; boundary="----C0EDEE0A5F012496F372EFC5533B6179" + +This is an S/MIME signed message + +------C0EDEE0A5F012496F372EFC5533B6179 +Content-Type: text/plain; charset=us-ascii + +Hello Bob, + +The minutes of Tuesday are attached in spirit. + +Alice + +------C0EDEE0A5F012496F372EFC5533B6179 +Content-Type: application/pkcs7-signature; name="smime.p7s" +Content-Transfer-Encoding: base64 +Content-Disposition: attachment; filename="smime.p7s" + +MIIGdQYJKoZIhvcNAQcCoIIGZjCCBmICAQExCTAHBgUrDgMCGjALBgkqhkiG9w0B +BwGgggPTMIIDzzCCAregAwIBAgITN0EFee11f0Kpolw69Phqzpqp1zANBgkqhkiG +9w0BAQ0FADBVMQ0wCwYDVQQKEwRJRVRGMREwDwYDVQQLEwhMQU1QUyBXRzExMC8G +A1UEAxMoU2FtcGxlIExBTVBTIFJTQSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAg +Fw0xOTExMjAwNjU0MThaGA8yMDUyMDkyNzA2NTQxOFowOzENMAsGA1UEChMESUVU +RjERMA8GA1UECxMITEFNUFMgV0cxFzAVBgNVBAMTDkFsaWNlIExvdmVsYWNlMIIB +IjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAtPSJ6Fg4Fj5Nmn9PkrYo0jTk +fCv4TfA/pdO/KLpZbJOAEr0sI7AjaO7B1GuMUFJeSTulamNfCwDcDkY63PQWl+DI +Ls7GxVwXurhYdZlaV5hcUqVAckPvedDBc/3rz4D/esFfs+E7QMFtmd+K04s+A8TC +NO12DRVBDpbP4JFD9hsc8prDtpGmFk7rd0q8gqnhxBW2RZAeLqzJOMayCQtws1q7 +ktkNBR2wZX5ICjecF1YJFhX4jrnHwp/iELGqqaNXd3/Y0pG7QFecN7836IPPdfTM +SiPR+peCrhJZwLSewbWXLJe3VMvbvQjoBMpEYlaJBUIKkO1zQ1Pq90njlsJLOwID +AQABo4GvMIGsMAwGA1UdEwEB/wQCMAAwFwYDVR0gBBAwDjAMBgpghkgBZQMCATAB +MB4GA1UdEQQXMBWBE2FsaWNlQHNtaW1lLmV4YW1wbGUwEwYDVR0lBAwwCgYIKwYB +BQUHAwQwDgYDVR0PAQH/BAQDAgbAMB0GA1UdDgQWBBS79syyLR0GEhyXrilqkBDT +IGZmczAfBgNVHSMEGDAWgBSRMI58BxcMp/EJKGU2GmccaHb0WTANBgkqhkiG9w0B +AQ0FAAOCAQEAc4miNqfOqaBpI3f+CpJDhxtuZ2P9HjQEQ+v6BdP7GKJ19naIs3Bj +JOd64roAKHAp+c284VvyVXWJ99FMX8q2ZUQMxH+xh6oAfzcozmnd6XaVWHg4eHIj +So27PmhKE1oAJKKhDbdbEcZXL2+x1V+duGymWtaD01DZZukKYr7agyHahiXRn/C9 +cy31wbqNsy9x0fjPQg6+DqatiQpMz9EIae6aCHHBhOiPU7IPkazgPYgkLD59fk4P +GHnYxs1FhdO6zZk9E8zwlc1ALgZa/iSbczisqckN3qGehD2s16jMhwFXLJtBiN+u +CDgNG/D0qyTbY4fgKieUHx/tHuzUszZxJjGCAmwwggJoAgEBMGwwVTENMAsGA1UE +ChMESUVURjERMA8GA1UECxMITEFNUFMgV0cxMTAvBgNVBAMTKFNhbXBsZSBMQU1Q +UyBSU0EgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkCEzdBBXntdX9CqaJcOvT4as6a +qdcwBwYFKw4DAhqggdgwGAYJKoZIhvcNAQkDMQsGCSqGSIb3DQEHATAcBgkqhkiG +9w0BCQUxDxcNMjYxMTA5MTIwOTUxWjAjBgkqhkiG9w0BCQQxFgQU7fMLLzqCEOLs +sYLIvwK6bSUQpwQweQYJKoZIhvcNAQkPMWwwajALBglghkgBZQMEASowCwYJYIZI +AWUDBAEWMAsGCWCGSAFlAwQBAjAKBggqhkiG9w0DBzAOBggqhkiG9w0DAgICAIAw +DQYIKoZIhvcNAwICAUAwBwYFKw4DAgcwDQYIKoZIhvcNAwICASgwDQYJKoZIhvcN +AQEBBQAEggEApwr9S+87L4Z+UZdVtuNmWH0eLmERMX6KTQ+zrlDxpXCq0ZPFkB7E +UijWdUoaWHOuwQbQac1tAoC9jP5cdpI9S3BB4QySECdzDOg6djzEnFEYrqddCKGY +nQswbRP/+mTMzN+lxO4kYjiHfb34egKPjgBiX6kUCpoxEZeV6joAtFRgBnkbUL4H +B2R+aiYiJt5jO1kB5beMf/gSFoIaycOf3EuTifNpPm2LsNGuEFZ72CRl2aHs2njc +O6XSZr8kODvUsPKJlXeqtThamr7Iy3NRvxQjDPFiW6i3TW9eo1/1LKSpDjjP8qet +p+iNds1neRoqaaDEkLifdykzuBLA0Sig8Q== + +------C0EDEE0A5F012496F372EFC5533B6179-- +