fmt

Author: 0x676e67

src/tls/x509/mod.rs

@@ -1,4 +1,5 @@
 mod identity;
+mod parser;
 mod store;
 
 use boring2::x509::X509;

src/tls/x509/store/parser.rs src/tls/x509/parser.rssrc/tls/x509/store/parser.rs renamed to src/tls/x509/parser.rs

@@ -1,36 +1,34 @@
-use std::sync::Arc;
+use boring2::x509::store::{X509Store, X509StoreBuilder};
 
-use boring2::x509::store::X509StoreBuilder;
+use super::{Certificate, CertificateInput};
+use crate::{Error, Result};
 
-use super::{CertStore, Certificate, CertificateInput};
-use crate::Error;
-
-pub fn parse_certs_with_iter<'c, I>(
+pub fn parse_certs<'c, I>(
     certs: I,
     parser: fn(&'c [u8]) -> crate::Result<Certificate>,
-) -> crate::Result<CertStore>
+) -> Result<X509Store>
 where
     I: IntoIterator,
     I::Item: Into<CertificateInput<'c>>,
 {
     let mut store = X509StoreBuilder::new().map_err(Error::tls)?;
     let certs = filter_map_certs(certs, parser);
-    process_certs_with_builder(certs.into_iter(), &mut store)?;
-    Ok(CertStore(Arc::new(store.build())))
+    process_certs(certs.into_iter(), &mut store)?;
+    Ok(store.build())
 }
 
-pub fn parse_certs_with_stack<C, F>(certs: C, x509: F) -> crate::Result<CertStore>
+pub fn parse_certs_with_stack<C, F>(certs: C, parse: F) -> Result<X509Store>
 where
     C: AsRef<[u8]>,
-    F: Fn(C) -> crate::Result<Vec<Certificate>>,
+    F: Fn(C) -> Result<Vec<Certificate>>,
 {
     let mut store = X509StoreBuilder::new().map_err(Error::tls)?;
-    let certs = x509(certs)?;
-    process_certs_with_builder(certs.into_iter(), &mut store)?;
-    Ok(CertStore(Arc::new(store.build())))
+    let certs = parse(certs)?;
+    process_certs(certs.into_iter(), &mut store)?;
+    Ok(store.build())
 }
 
-pub fn process_certs_with_builder<I>(iter: I, store: &mut X509StoreBuilder) -> crate::Result<()>
+pub fn process_certs<I>(iter: I, store: &mut X509StoreBuilder) -> Result<()>
 where
     I: Iterator<Item = Certificate>,
 {
@@ -54,7 +52,7 @@ where
 
 pub fn filter_map_certs<'c, I>(
     certs: I,
-    parser: fn(&'c [u8]) -> crate::Result<Certificate>,
+    parser: fn(&'c [u8]) -> Result<Certificate>,
 ) -> impl Iterator<Item = Certificate>
 where
     I: IntoIterator,

src/tls/x509/store/mod.rs src/tls/x509/store.rssrc/tls/x509/store/mod.rs renamed to src/tls/x509/store.rs

@@ -1,27 +1,27 @@
-mod parser;
-
-use std::{fmt::Debug, path::Path, sync::Arc};
+use std::sync::Arc;
 
 use boring2::{
     ssl::SslConnectorBuilder,
     x509::store::{X509Store, X509StoreBuilder},
 };
-use parser::{
-    filter_map_certs, parse_certs_with_iter, parse_certs_with_stack, process_certs_with_builder,
-};
 
-use super::{Certificate, CertificateInput};
-use crate::Error;
+use super::{
+    Certificate, CertificateInput,
+    parser::{filter_map_certs, parse_certs, parse_certs_with_stack, process_certs},
+};
+use crate::{Error, Result};
 
 /// A builder for constructing a `CertStore`.
 ///
 /// This builder provides methods to add certificates to the store from various formats,
 /// and to set default paths for the certificate store. Once all desired certificates
 /// have been added, the `build` method can be used to create the `CertStore`.
 pub struct CertStoreBuilder {
-    builder: crate::Result<X509StoreBuilder>,
+    builder: Result<X509StoreBuilder>,
 }
 
+// ====== impl CertStoreBuilder ======
+
 impl CertStoreBuilder {
     /// Adds a DER-encoded certificate to the certificate store.
     #[inline]
@@ -68,7 +68,7 @@ impl CertStoreBuilder {
     {
         if let Ok(ref mut builder) = self.builder {
             let result = Certificate::stack_from_pem(certs.as_ref())
-                .and_then(|certs| process_certs_with_builder(certs.into_iter(), builder));
+                .and_then(|certs| process_certs(certs.into_iter(), builder));
 
             if let Err(err) = result {
                 self.builder = Err(err);
@@ -77,23 +77,6 @@ impl CertStoreBuilder {
         self
     }
 
-    /// Adds PEM-encoded certificates from a file to the certificate store.
-    ///
-    /// This method reads the file at the specified path, expecting it to contain a PEM-encoded
-    /// certificate stack, and then adds the certificates to the store.
-    pub fn add_file_pem_certs<P>(mut self, path: P) -> Self
-    where
-        P: AsRef<Path>,
-    {
-        match std::fs::read(path) {
-            Ok(data) => return self.add_stack_pem_certs(data),
-            Err(err) => {
-                self.builder = Err(Error::builder(err));
-            }
-        }
-        self
-    }
-
     /// Load certificates from their default locations.
     ///
     /// These locations are read from the `SSL_CERT_FILE` and `SSL_CERT_DIR`
@@ -112,15 +95,20 @@ impl CertStoreBuilder {
     ///
     /// This method finalizes the builder and constructs the `CertStore`
     /// containing all the added certificates.
-    pub fn build(self) -> crate::Result<CertStore> {
-        let builder = self.builder?;
-        Ok(CertStore(Arc::new(builder.build())))
+    #[inline]
+    pub fn build(self) -> Result<CertStore> {
+        self.builder
+            .map(X509StoreBuilder::build)
+            .map(Arc::new)
+            .map(CertStore)
     }
+}
 
+impl CertStoreBuilder {
     fn parse_cert<'c, C, P>(mut self, cert: C, parser: P) -> Self
     where
         C: Into<CertificateInput<'c>>,
-        P: Fn(&'c [u8]) -> crate::Result<Certificate>,
+        P: Fn(&'c [u8]) -> Result<Certificate>,
     {
         if let Ok(ref mut builder) = self.builder {
             let input = cert.into();
@@ -135,18 +123,14 @@ impl CertStoreBuilder {
         self
     }
 
-    fn parse_certs<'c, I>(
-        mut self,
-        certs: I,
-        parser: fn(&'c [u8]) -> crate::Result<Certificate>,
-    ) -> Self
+    fn parse_certs<'c, I>(mut self, certs: I, parser: fn(&'c [u8]) -> Result<Certificate>) -> Self
     where
         I: IntoIterator,
         I::Item: Into<CertificateInput<'c>>,
     {
         if let Ok(ref mut builder) = self.builder {
             let certs = filter_map_certs(certs, parser);
-            if let Err(err) = process_certs_with_builder(certs, builder) {
+            if let Err(err) = process_certs(certs, builder) {
                 self.builder = Err(err);
             }
         }
@@ -158,37 +142,8 @@ impl CertStoreBuilder {
 #[derive(Clone)]
 pub struct CertStore(Arc<X509Store>);
 
-impl Default for CertStore {
-    fn default() -> Self {
-        #[cfg(feature = "webpki-roots")]
-        pub(super) static LOAD_CERTS: std::sync::LazyLock<CertStore> =
-            std::sync::LazyLock::new(|| {
-                CertStore::builder()
-                    .add_der_certs(webpki_root_certs::TLS_SERVER_ROOT_CERTS)
-                    .build()
-                    .expect("failed to load default cert store")
-            });
-
-        #[cfg(not(feature = "webpki-roots"))]
-        {
-            CertStore::builder()
-                .set_default_paths()
-                .build()
-                .expect("failed to load default cert store")
-        }
+// ====== impl CertStore ======
 
-        #[cfg(feature = "webpki-roots")]
-        LOAD_CERTS.clone()
-    }
-}
-
-impl Debug for CertStore {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("CertStore").finish()
-    }
-}
-
-/// ====== impl CertStore ======
 impl CertStore {
     /// Creates a new `CertStoreBuilder`.
     #[inline]
@@ -200,45 +155,37 @@ impl CertStore {
 
     /// Creates a new `CertStore` from a collection of DER-encoded certificates.
     #[inline]
-    pub fn from_der_certs<'c, C>(certs: C) -> crate::Result<CertStore>
+    pub fn from_der_certs<'c, C>(certs: C) -> Result<CertStore>
     where
         C: IntoIterator,
         C::Item: Into<CertificateInput<'c>>,
     {
-        parse_certs_with_iter(certs, Certificate::from_der)
+        parse_certs(certs, Certificate::from_der)
+            .map(Arc::new)
+            .map(CertStore)
     }
 
     /// Creates a new `CertStore` from a collection of PEM-encoded certificates.
     #[inline]
-    pub fn from_pem_certs<'c, C>(certs: C) -> crate::Result<CertStore>
+    pub fn from_pem_certs<'c, C>(certs: C) -> Result<CertStore>
     where
         C: IntoIterator,
         C::Item: Into<CertificateInput<'c>>,
     {
-        parse_certs_with_iter(certs, Certificate::from_pem)
+        parse_certs(certs, Certificate::from_pem)
+            .map(Arc::new)
+            .map(CertStore)
     }
 
     /// Creates a new `CertStore` from a PEM-encoded certificate stack.
     #[inline]
-    pub fn from_pem_stack<C>(certs: C) -> crate::Result<CertStore>
+    pub fn from_pem_stack<C>(certs: C) -> Result<CertStore>
     where
         C: AsRef<[u8]>,
     {
         parse_certs_with_stack(certs, Certificate::stack_from_pem)
-    }
-
-    /// Creates a new `CertStore` from a PEM-encoded certificate file.
-    ///
-    /// This method reads the file at the specified path, expecting it to contain a PEM-encoded
-    /// certificate stack, and then constructs a `CertStore` from it.
-    #[inline]
-    pub fn from_pem_file<P>(path: P) -> crate::Result<CertStore>
-    where
-        P: AsRef<Path>,
-    {
-        std::fs::read(path)
-            .map_err(Error::builder)
-            .and_then(Self::from_pem_stack)
+            .map(Arc::new)
+            .map(CertStore)
     }
 }
 
@@ -248,3 +195,27 @@ impl CertStore {
         tls.set_cert_store_ref(&self.0);
     }
 }
+
+impl Default for CertStore {
+    fn default() -> Self {
+        #[cfg(feature = "webpki-roots")]
+        pub(super) static LOAD_CERTS: std::sync::LazyLock<CertStore> =
+            std::sync::LazyLock::new(|| {
+                CertStore::builder()
+                    .add_der_certs(webpki_root_certs::TLS_SERVER_ROOT_CERTS)
+                    .build()
+                    .expect("failed to load default cert store")
+            });
+
+        #[cfg(not(feature = "webpki-roots"))]
+        {
+            CertStore::builder()
+                .set_default_paths()
+                .build()
+                .expect("failed to load default cert store")
+        }
+
+        #[cfg(feature = "webpki-roots")]
+        LOAD_CERTS.clone()
+    }
+}