1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107
//! # rustls-pemfile //! A basic parser for .pem files containing cryptographic keys and certificates. //! //! The input to this crate is a .pem file containing potentially many sections, //! and the output is those sections as alleged DER-encodings. This crate does //! not decode the actual DER-encoded keys/certificates. //! //! ## Quick start //! Starting with an `io::BufRead` containing the file to be read: //! - Use `read_all()` to ingest the whole file, then work through the contents in-memory, or, //! - Use `read_one()` to stream through the file, processing the items as found, or, //! - Use `certs()` to extract just the certificates (silently discarding other sections), and //! similarly for `rsa_private_keys()` and `pkcs8_private_keys()`. //! //! ## Example code //! ``` //! use std::iter; //! use rustls_pemfile::{Item, read_one}; //! # let mut reader = std::io::BufReader::new(&b"junk\n-----BEGIN RSA PRIVATE KEY-----\nqw\n-----END RSA PRIVATE KEY-----\n"[..]); //! // Assume `reader` is any std::io::BufRead implementor //! for item in iter::from_fn(|| read_one(&mut reader).transpose()) { //! match item.unwrap() { //! Item::X509Certificate(cert) => println!("certificate {:?}", cert), //! Item::RSAKey(key) => println!("rsa pkcs1 key {:?}", key), //! Item::PKCS8Key(key) => println!("pkcs8 key {:?}", key), //! } //! } //! ``` // Require docs for public APIs, deny unsafe code, etc. #![forbid(unsafe_code, unused_must_use, unstable_features)] #![deny( trivial_casts, trivial_numeric_casts, missing_docs, unused_import_braces, unused_extern_crates, unused_qualifications )] #[cfg(test)] mod tests; /// --- Main crate APIs: mod pemfile; pub use pemfile::{ Item, read_one, read_all, }; /// --- Legacy APIs: use std::io; /// Extract all the certificates from `rd`, and return a vec of byte vecs /// containing the der-format contents. /// /// This function does not fail if there are no certificates in the file -- /// it returns an empty vector. pub fn certs(rd: &mut dyn io::BufRead) -> Result<Vec<Vec<u8>>, io::Error> { let mut certs = Vec::<Vec<u8>>::new(); loop { match read_one(rd)? { None => return Ok(certs), Some(Item::X509Certificate(cert)) => certs.push(cert), _ => {} }; } } /// Extract all RSA private keys from `rd`, and return a vec of byte vecs /// containing the der-format contents. /// /// This function does not fail if there are no keys in the file -- it returns an /// empty vector. pub fn rsa_private_keys(rd: &mut dyn io::BufRead) -> Result<Vec<Vec<u8>>, io::Error> { let mut keys = Vec::<Vec<u8>>::new(); loop { match read_one(rd)? { None => return Ok(keys), Some(Item::RSAKey(key)) => keys.push(key), _ => {} }; } } /// Extract all PKCS8-encoded private keys from `rd`, and return a vec of /// byte vecs containing the der-format contents. /// /// This function does not fail if there are no keys in the file -- it returns an /// empty vector. pub fn pkcs8_private_keys(rd: &mut dyn io::BufRead) -> Result<Vec<Vec<u8>>, io::Error> { let mut keys = Vec::<Vec<u8>>::new(); loop { match read_one(rd)? { None => return Ok(keys), Some(Item::PKCS8Key(key)) => keys.push(key), _ => {} }; } }