mtc_worker: Return MTC validity window on add entry

Add the MTC validity window to `AddEntryResponse`. In case the entry was
cached, it would be necessary to parse the validity window from the
entry itself. However, for now we don't actually want to cache MTC
entries, so remove caching for now.

Author: cjpatton

crates/mtc_api/src/lib.rs

@@ -119,8 +119,15 @@ pub struct AddEntryRequest {
 #[serde_as]
 #[derive(Serialize)]
 pub struct AddEntryResponse {
+    /// The index of the entry in the log.
     pub leaf_index: LeafIndex,
+
+    /// The time at which the entry was added to the log.
     pub timestamp: UnixTimestamp,
+
+    /// The validity period of the certificate.
+    pub not_before: UnixTimestamp,
+    pub not_after: UnixTimestamp,
 }
 
 /// Get-roots response. This is in the same format as the RFC 6962 get-roots
@@ -684,7 +691,7 @@ pub fn validate_chain(
     raw_chain: &[Vec<u8>],
     roots: &CertPool,
     issuer: RdnSequence,
-    mut validity: Validity,
+    validity: &mut Validity,
 ) -> Result<(BootstrapMtcPendingLogEntry, Option<usize>), MtcError> {
     // We will run the ordinary chain validation on our input, but we have some post-processing we
     // need to do too. Namely we need to adjust the validity period of the provided bootstrap cert,
@@ -741,7 +748,7 @@ pub fn validate_chain(
                 data: MerkleTreeCertEntry::TbsCertEntry(tbs_cert_to_log_entry(
                     leaf.tbs_certificate,
                     issuer,
-                    validity,
+                    *validity,
                 )?)
                 .encode()?,
             },

crates/mtc_worker/src/batcher_do.rs

@@ -18,11 +18,14 @@ impl DurableObject for Batcher {
                 .map(|(name, params)| (name.as_str(), params.num_batchers)),
         );
         let params = &CONFIG.logs[name];
+        if params.enable_dedup {
+            log::warn!("ignored enable_dedup: this feature is not implemented by mtc_worker");
+        }
         let config = BatcherConfig {
             name: name.to_string(),
             max_batch_entries: params.max_batch_entries,
             batch_timeout_millis: params.batch_timeout_millis,
-            enable_dedup: params.enable_dedup,
+            enable_dedup: false,
             location_hint: params.location_hint.clone(),
         };
         Batcher(GenericBatcher::new(env, config))

crates/mtc_worker/src/frontend_worker.rs

@@ -12,8 +12,8 @@ use der::{
     Any, Encode, Tag,
 };
 use generic_log_worker::{
-    batcher_id_from_lookup_key, deserialize, get_cached_metadata, get_durable_object_stub,
-    init_logging, load_cache_kv, load_public_bucket,
+    batcher_id_from_lookup_key, deserialize, get_durable_object_stub, init_logging, load_cache_kv,
+    load_public_bucket,
     log_ops::{
         prove_subtree_consistency, prove_subtree_inclusion, read_leaf, ProofError, CHECKPOINT_KEY,
     },
@@ -333,7 +333,7 @@ async fn add_entry(mut req: Request, env: &Env, name: &str) -> Result<Response>
     )]);
 
     let now = Duration::from_millis(now_millis());
-    let validity = Validity {
+    let mut validity = Validity {
         not_before: Time::UtcTime(UtcTime::from_unix_duration(now).map_err(|e| e.to_string())?),
         not_after: Time::UtcTime(
             UtcTime::from_unix_duration(
@@ -345,7 +345,7 @@ async fn add_entry(mut req: Request, env: &Env, name: &str) -> Result<Response>
 
     let roots = load_roots(env, name).await?;
     let (pending_entry, found_root_idx) =
-        match mtc_api::validate_chain(&req.chain, roots, issuer, validity) {
+        match mtc_api::validate_chain(&req.chain, roots, issuer, &mut validity) {
             Ok(v) => v,
             Err(e) => {
                 log::warn!("{name}: Bad request: {e}");
@@ -357,18 +357,6 @@ async fn add_entry(mut req: Request, env: &Env, name: &str) -> Result<Response>
     // deduplication cache and then sending a request to the DO to sequence the entry.
     let lookup_key = pending_entry.lookup_key();
 
-    // Check if entry is cached and return right away if so.
-    if params.enable_dedup {
-        if let Some(metadata) = get_cached_metadata(&load_cache_kv(env, name)?, &lookup_key).await?
-        {
-            log::debug!("{name}: Entry is cached");
-            return Response::from_json(&AddEntryResponse {
-                leaf_index: metadata.0,
-                timestamp: metadata.1,
-            });
-        }
-    }
-
     // Entry is not cached, so we need to sequence it.
 
     // First persist issuers. Use a block so memory is deallocated sooner.
@@ -438,6 +426,8 @@ async fn add_entry(mut req: Request, env: &Env, name: &str) -> Result<Response>
     Response::from_json(&AddEntryResponse {
         leaf_index: metadata.0,
         timestamp: metadata.1,
+        not_before: validity.not_before.to_unix_duration().as_secs(),
+        not_after: validity.not_after.to_unix_duration().as_secs(),
     })
 }