conformance: staging, initial trustroot support

Signed-off-by: Andrew Pan <[email protected]>

Author: tnytown

Cargo.toml

@@ -40,11 +40,11 @@ rekor-native-tls = ["reqwest/native-tls", "rekor"]
 rekor-rustls-tls = ["reqwest/rustls-tls", "rekor"]
 rekor = ["reqwest"]
 
-sign = ["sigstore_protobuf_specs", "fulcio", "rekor", "cert"]
-verify = ["sigstore_protobuf_specs", "fulcio", "rekor", "cert"]
+sign = ["fulcio", "rekor", "cert"]
+verify = ["fulcio", "rekor", "cert"]
 bundle = ["sign", "verify"]
 
-sigstore-trust-root = ["sigstore_protobuf_specs", "futures-util", "tough", "regex", "tokio/sync"]
+sigstore-trust-root = ["futures-util", "tough", "regex", "tokio/sync"]
 
 cosign-native-tls = [
   "oci-distribution/native-tls",
@@ -116,7 +116,7 @@ serde_json = "1.0.79"
 serde_with = { version = "3.4", features = ["base64", "json"], optional = true }
 sha2 = { version = "0.10.6", features = ["oid"] }
 signature = { version = "2.0" }
-sigstore_protobuf_specs = { version = "0.3", optional = true }
+sigstore_protobuf_specs = "0.3"
 thiserror = "1.0.30"
 tokio = { version = "1.17.0", features = ["rt"] }
 tokio-util = { version = "0.7.10", features = ["io-util"] }

examples/cosign/verify/main.rs

@@ -22,7 +22,7 @@ use sigstore::cosign::{CosignCapabilities, SignatureLayer};
 use sigstore::crypto::SigningScheme;
 use sigstore::errors::SigstoreVerifyConstraintsError;
 use sigstore::registry::{ClientConfig, ClientProtocol, OciReference};
-use sigstore::trust::sigstore::SigstoreTrustRoot;
+use sigstore::trust::sigstore::{Instance, TrustRootOptions};
 use std::time::Instant;
 
 extern crate anyhow;
@@ -107,7 +107,7 @@ struct Cli {
 
 async fn run_app(
     cli: &Cli,
-    frd: &dyn sigstore::trust::TrustRoot,
+    frd: &dyn sigstore::trust::RawTrustRoot,
 ) -> anyhow::Result<(Vec<SignatureLayer>, VerificationConstraintVec)> {
     // Note well: this a limitation deliberately introduced by this example.
     if cli.cert_email.is_some() && cli.cert_url.is_some() {
@@ -184,7 +184,7 @@ async fn run_app(
     }
     if let Some(path_to_cert) = cli.cert.as_ref() {
         let cert = fs::read(path_to_cert).map_err(|e| anyhow!("Cannot read cert: {:?}", e))?;
-        let require_rekor_bundle = if !frd.rekor_keys()?.is_empty() {
+        let require_rekor_bundle = if !frd.raw_tlog_keys().is_empty() {
             true
         } else {
             warn!("certificate based verification is weaker when Rekor integration is disabled");
@@ -225,21 +225,23 @@ async fn run_app(
     Ok((trusted_layers, verification_constraints))
 }
 
-async fn fulcio_and_rekor_data(cli: &Cli) -> anyhow::Result<Box<dyn sigstore::trust::TrustRoot>> {
+async fn fulcio_and_rekor_data(
+    cli: &Cli,
+) -> anyhow::Result<Box<dyn sigstore::trust::RawTrustRoot>> {
     if cli.use_sigstore_tuf_data {
         info!("Downloading data from Sigstore TUF repository");
 
-        let repo: sigstore::errors::Result<SigstoreTrustRoot> = SigstoreTrustRoot::new(None).await;
+        let repo = Instance::Prod
+            .trust_config(TrustRootOptions { cache_dir: None })
+            .await?;
 
-        return Ok(Box::new(repo?));
+        return Ok(Box::new(repo.trust_root));
     };
 
     let mut data = sigstore::trust::ManualTrustRoot::default();
     if let Some(path) = cli.rekor_pub_key.as_ref() {
-        data.rekor_key = Some(
-            fs::read(path)
-                .map_err(|e| anyhow!("Error reading rekor public key from disk: {}", e))?,
-        );
+        data.tlog_keys = vec![fs::read(path)
+            .map_err(|e| anyhow!("Error reading rekor public key from disk: {}", e))?];
     }
 
     if let Some(path) = cli.fulcio_cert.as_ref() {
@@ -250,9 +252,7 @@ async fn fulcio_and_rekor_data(cli: &Cli) -> anyhow::Result<Box<dyn sigstore::tr
             encoding: sigstore::registry::CertificateEncoding::Pem,
             data: cert_data,
         };
-        data.fulcio_certs
-            .get_or_insert(Vec::new())
-            .push(certificate.try_into()?);
+        data.ca_certs.push(certificate.try_into()?);
     }
 
     Ok(Box::new(data))

src/bundle/sign.rs

@@ -14,6 +14,7 @@
 
 //! Types for signing artifacts and producing Sigstore bundles.
 
+use std::error::Error;
 use std::io::{self, Read};
 use std::time::SystemTime;
 
@@ -39,19 +40,15 @@ use x509_cert::builder::{Builder, RequestBuilder as CertRequestBuilder};
 use x509_cert::ext::pkix as x509_ext;
 
 use crate::bundle::models::Version;
-use crate::crypto::keyring::Keyring;
 use crate::crypto::transparency::{verify_sct, CertificateEmbeddedSCT};
 use crate::errors::{Result as SigstoreResult, SigstoreError};
 use crate::fulcio::oauth::OauthTokenProvider;
-use crate::fulcio::{self, FulcioClient, FULCIO_ROOT};
+use crate::fulcio::{self, FulcioClient};
 use crate::oauth::IdentityToken;
 use crate::rekor::apis::configuration::Configuration as RekorConfiguration;
 use crate::rekor::apis::entries_api::create_log_entry;
 use crate::rekor::models::{hashedrekord, proposed_entry::ProposedEntry as ProposedLogEntry};
-use crate::trust::TrustRoot;
-
-#[cfg(feature = "sigstore-trust-root")]
-use crate::trust::sigstore::SigstoreTrustRoot;
+use crate::trust::{CTFEKeyring, TrustConfig, TrustRoot};
 
 /// An asynchronous Sigstore signing session.
 ///
@@ -85,25 +82,27 @@ impl<'ctx> SigningSession<'ctx> {
         fulcio: &FulcioClient,
         token: &IdentityToken,
     ) -> SigstoreResult<(ecdsa::SigningKey<NistP256>, fulcio::CertificateResponse)> {
-        let subject =
-                // SEQUENCE OF RelativeDistinguishedName
-                vec![
-                    // SET OF AttributeTypeAndValue
-                    vec![
-                        // AttributeTypeAndValue, `emailAddress=...`
-                        AttributeTypeAndValue {
-                            oid: const_oid::db::rfc3280::EMAIL_ADDRESS,
-                            value: AttributeValue::new(
-                                pkcs8::der::Tag::Utf8String,
-                                token.unverified_claims().email.as_ref(),
-                            )?,
-                        }
-                    ].try_into()?
-                ].into();
+        let subject = token
+            .unverified_claims()
+            .subject()
+            .ok_or(SigstoreError::UnexpectedError(
+                "OIDC token does not contain a subject".into(),
+            ))?;
+        // AttributeTypeAndValue, `emailAddress=...`
+        let subject_attr = AttributeTypeAndValue {
+            oid: const_oid::db::rfc3280::EMAIL_ADDRESS,
+            value: AttributeValue::new(pkcs8::der::Tag::Utf8String, subject.as_ref())?,
+        };
+        // SEQUENCE OF RelativeDistinguishedName
+        let subject_seq = vec![
+            // SET OF AttributeTypeAndValue
+            vec![subject_attr].try_into()?,
+        ]
+        .into();
 
         let mut rng = rand::thread_rng();
         let private_key = ecdsa::SigningKey::from(p256::SecretKey::random(&mut rng));
-        let mut builder = CertRequestBuilder::new(subject, &private_key)?;
+        let mut builder = CertRequestBuilder::new(subject_seq, &private_key)?;
         builder.add_extension(&x509_ext::BasicConstraints {
             ca: false,
             path_len_constraint: None,
@@ -258,49 +257,30 @@ pub mod blocking {
 pub struct SigningContext {
     fulcio: FulcioClient,
     rekor_config: RekorConfiguration,
-    ctfe_keyring: Keyring,
+    ctfe_keyring: CTFEKeyring,
 }
 
 impl SigningContext {
-    /// Manually constructs a [`SigningContext`] from its constituent data.
-    pub fn new(
-        fulcio: FulcioClient,
-        rekor_config: RekorConfiguration,
-        ctfe_keyring: Keyring,
-    ) -> Self {
-        Self {
+    pub fn new<R>(trust: TrustConfig<R>) -> Result<Self, Box<dyn Error + Send + Sync>>
+    where
+        R: TrustRoot,
+    {
+        let fulcio_url = Url::parse(&trust.signing_config.ca_url)?;
+        let oauth = OauthTokenProvider::default().with_issuer(&trust.signing_config.oidc_url);
+        let fulcio = FulcioClient::new(fulcio_url, crate::fulcio::TokenProvider::Oauth(oauth));
+
+        let mut rekor_config: RekorConfiguration = Default::default();
+        // XX: At the time of writing, the ecosystem only uses one log. In the future, we
+        // may want to check multiple logs to mitigate split-view attacks.
+        rekor_config.base_path = trust.signing_config.tlog_urls[0].clone();
+
+        let ctfe_keyring = trust.trust_root.ctfe_keys()?;
+
+        Ok(Self {
             fulcio,
             rekor_config,
             ctfe_keyring,
-        }
-    }
-
-    /// Returns a [`SigningContext`] configured against the public-good production Sigstore
-    /// infrastructure.
-    #[cfg(feature = "sigstore-trust-root")]
-    pub async fn async_production() -> SigstoreResult<Self> {
-        let trust_root = SigstoreTrustRoot::new(None).await?;
-        Ok(Self::new(
-            FulcioClient::new(
-                Url::parse(FULCIO_ROOT).expect("constant FULCIO root fails to parse!"),
-                crate::fulcio::TokenProvider::Oauth(OauthTokenProvider::default()),
-            ),
-            Default::default(),
-            Keyring::new(trust_root.ctfe_keys()?)?,
-        ))
-    }
-
-    /// Returns a [`SigningContext`] configured against the public-good production Sigstore
-    /// infrastructure.
-    ///
-    /// Async callers should use [`SigningContext::async_production`].
-    #[cfg(feature = "sigstore-trust-root")]
-    pub fn production() -> SigstoreResult<Self> {
-        let rt = tokio::runtime::Builder::new_current_thread()
-            .enable_all()
-            .build()?;
-
-        rt.block_on(Self::async_production())
+        })
     }
 
     /// Configures and returns a [`SigningSession`] with the held context.

src/bundle/verify/verifier.rs

@@ -25,18 +25,13 @@ use x509_cert::der::Encode;
 use crate::{
     bundle::Bundle,
     crypto::{
-        keyring::Keyring,
         transparency::{verify_sct, CertificateEmbeddedSCT},
         CertificatePool, CosignVerificationKey, Signature,
     },
-    errors::Result as SigstoreResult,
     rekor::apis::configuration::Configuration as RekorConfiguration,
-    trust::TrustRoot,
+    trust::{CTFEKeyring, TrustConfig, TrustRoot, TrustRootError},
 };
 
-#[cfg(feature = "sigstore-trust-root")]
-use crate::trust::sigstore::SigstoreTrustRoot;
-
 use super::{
     models::{CertificateErrorKind, CheckedBundle, SignatureErrorKind},
     policy::VerificationPolicy,
@@ -50,19 +45,16 @@ pub struct Verifier {
     #[allow(dead_code)]
     rekor_config: RekorConfiguration,
     cert_pool: CertificatePool,
-    ctfe_keyring: Keyring,
+    ctfe_keyring: CTFEKeyring,
 }
 
 impl Verifier {
-    /// Constructs a [`Verifier`].
-    ///
-    /// For verifications against the public-good trust root, use [`Verifier::production()`].
-    pub fn new<R: TrustRoot>(
+    fn new_with_rekor_config<R: TrustRoot>(
         rekor_config: RekorConfiguration,
         trust_repo: R,
-    ) -> SigstoreResult<Self> {
-        let cert_pool = CertificatePool::from_certificates(trust_repo.fulcio_certs()?, [])?;
-        let ctfe_keyring = Keyring::new(trust_repo.ctfe_keys()?)?;
+    ) -> Result<Self, TrustRootError> {
+        let cert_pool = trust_repo.ca_certs()?;
+        let ctfe_keyring = trust_repo.ctfe_keys()?;
 
         Ok(Self {
             rekor_config,
@@ -71,6 +63,21 @@ impl Verifier {
         })
     }
 
+    /// Constructs a [`Verifier`].
+    ///
+    pub fn new<R>(trust: TrustConfig<R>) -> Result<Self, TrustRootError>
+    where
+        R: TrustRoot,
+    {
+        let mut rekor_config: RekorConfiguration = Default::default();
+
+        // XX: At the time of writing, the ecosystem only uses one log. In the future, we
+        // may want to check multiple logs to mitigate split-view attacks.
+        rekor_config.base_path = trust.signing_config.tlog_urls[0].clone();
+
+        Self::new_with_rekor_config(rekor_config, trust.trust_root)
+    }
+
     /// Verifies an input digest against the given Sigstore Bundle, ensuring conformance to the
     /// provided [`VerificationPolicy`].
     pub async fn verify_digest<P>(
@@ -214,17 +221,9 @@ impl Verifier {
     }
 }
 
-impl Verifier {
-    /// Constructs an [`Verifier`] against the public-good trust root.
-    #[cfg(feature = "sigstore-trust-root")]
-    pub async fn production() -> SigstoreResult<Verifier> {
-        let updater = SigstoreTrustRoot::new(None).await?;
-
-        Verifier::new(Default::default(), updater)
-    }
-}
-
 pub mod blocking {
+    use std::error::Error;
+
     use super::{Verifier as AsyncVerifier, *};
 
     /// A synchronous Sigstore verifier.
@@ -235,16 +234,14 @@ pub mod blocking {
 
     impl Verifier {
         /// Constructs a synchronous Sigstore verifier.
-        ///
-        /// For verifications against the public-good trust root, use [`Verifier::production()`].
-        pub fn new<R: TrustRoot>(
-            rekor_config: RekorConfiguration,
-            trust_repo: R,
-        ) -> SigstoreResult<Self> {
+        pub fn new<R>(trust: TrustConfig<R>) -> Result<Self, Box<dyn Error>>
+        where
+            R: TrustRoot,
+        {
             let rt = tokio::runtime::Builder::new_current_thread()
                 .enable_all()
                 .build()?;
-            let inner = AsyncVerifier::new(rekor_config, trust_repo)?;
+            let inner = AsyncVerifier::new(trust)?;
 
             Ok(Self { rt, inner })
         }
@@ -286,17 +283,4 @@ pub mod blocking {
             self.verify_digest(hasher, bundle, policy, offline)
         }
     }
-
-    impl Verifier {
-        /// Constructs a synchronous [`Verifier`] against the public-good trust root.
-        #[cfg(feature = "sigstore-trust-root")]
-        pub fn production() -> SigstoreResult<Verifier> {
-            let rt = tokio::runtime::Builder::new_current_thread()
-                .enable_all()
-                .build()?;
-            let inner = rt.block_on(AsyncVerifier::production())?;
-
-            Ok(Verifier { inner, rt })
-        }
-    }
 }