Add opaque porep_id as public input and use when constructing replica…

…_id.

fil-proofs-tooling/src/bin/benchy/prodbench.rs

@@ -179,13 +179,15 @@ pub fn run(
     let mut outputs = ProdbenchOutputs::default();
 
     let sector_size = SectorSize(inputs.sector_size_bytes());
+    let arbitrary_porep_id = [123; 32];
 
     assert!(inputs.num_sectors > 0, "Missing num_sectors");
 
     let (cfg, repls) = create_replicas::<DefaultOctLCTree>(
         sector_size,
         inputs.num_sectors as usize,
         only_add_piece,
+        arbitrary_porep_id,
     );
 
     if only_add_piece || only_replicate {
@@ -315,10 +317,12 @@ fn generate_params(i: &ProdbenchInputs) {
         "generating params: porep: (size: {:?}, partitions: {:?})",
         &sector_size, &partitions
     );
+    let dummy_porep_id = [0; 32];
 
     cache_porep_params(PoRepConfig {
         sector_size,
         partitions,
+        porep_id: dummy_porep_id,
     });
 }
 

fil-proofs-tooling/src/bin/benchy/stacked.rs

@@ -154,11 +154,14 @@ where
                         replica_path.clone(),
                     )?;
 
+                let arbitrary_porep_id = [88; 32];
+
                 let pb = stacked::PublicInputs::<H::Domain, <Sha256Hasher as Hasher>::Domain> {
                     replica_id,
                     seed,
                     tau: Some(tau),
                     k: Some(0),
+                    porep_id: arbitrary_porep_id,
                 };
 
                 // Convert TemporaryAux to TemporaryAuxCache, which instantiates all

fil-proofs-tooling/src/bin/benchy/window_post.rs

@@ -102,6 +102,8 @@ pub fn run_window_post_bench<Tree: 'static + MerkleTreeTrait>(
 
     let piece_infos = vec![piece_info];
 
+    let arbitrary_porep_id = [99; 32];
+
     // Replicate the staged sector, write the replica file to `sealed_path`.
     let porep_config = PoRepConfig {
         sector_size: SectorSize(sector_size),
@@ -112,6 +114,7 @@ pub fn run_window_post_bench<Tree: 'static + MerkleTreeTrait>(
                 .get(&(sector_size))
                 .unwrap(),
         ),
+        porep_id: arbitrary_porep_id,
     };
     let cache_dir = tempfile::tempdir().unwrap();
     let sector_id = SectorId::from(SECTOR_ID);

fil-proofs-tooling/src/bin/benchy/winning_post.rs

@@ -53,7 +53,8 @@ pub fn run_fallback_post_bench<Tree: 'static + MerkleTreeTrait>(
             "This benchmark only works with WINNING_POST_SECTOR_COUNT == 1"
         ));
     }
-    let (sector_id, replica_output) = create_replica::<Tree>(sector_size);
+    let arbitrary_porep_id = [66; 32];
+    let (sector_id, replica_output) = create_replica::<Tree>(sector_size, arbitrary_porep_id);
 
     // Store the replica's private and publicly facing info for proving and verifying respectively.
     let pub_replica_info = vec![(sector_id, replica_output.public_replica_info)];

fil-proofs-tooling/src/bin/gpu-cpu-test/main.rs

@@ -129,9 +129,10 @@ fn threads_mode(parallel: u8, gpu_stealing: bool) {
     let mut senders = Vec::new();
     // All thread handles that get terminated
     let mut threads: Vec<Option<thread::JoinHandle<_>>> = Vec::new();
+    let arbitrary_porep_id = [234; 32];
 
     // Create fixtures only once for both threads
-    let (sector_id, replica_output) = create_replica::<MerkleTree>(SECTOR_SIZE);
+    let (sector_id, replica_output) = create_replica::<MerkleTree>(SECTOR_SIZE, arbitrary_porep_id);
     let priv_replica_info = (sector_id, replica_output.private_replica_info);
 
     // Put each proof into it's own scope (the other one is due to the if statement)

fil-proofs-tooling/src/shared.rs

@@ -64,8 +64,10 @@ pub fn create_piece(piece_bytes: UnpaddedBytesAmount) -> NamedTempFile {
 /// Create a replica for a single sector
 pub fn create_replica<Tree: 'static + MerkleTreeTrait>(
     sector_size: u64,
+    porep_id: [u8; 32],
 ) -> (SectorId, PreCommitReplicaOutput<Tree>) {
-    let (_porep_config, result) = create_replicas::<Tree>(SectorSize(sector_size), 1, false);
+    let (_porep_config, result) =
+        create_replicas::<Tree>(SectorSize(sector_size), 1, false, porep_id);
     // Extract the sector ID and replica output out of the result
     result
         .unwrap()
@@ -79,6 +81,7 @@ pub fn create_replicas<Tree: 'static + MerkleTreeTrait>(
     sector_size: SectorSize,
     qty_sectors: usize,
     only_add: bool,
+    porep_id: [u8; 32],
 ) -> (
     PoRepConfig,
     Option<(
@@ -99,6 +102,7 @@ pub fn create_replicas<Tree: 'static + MerkleTreeTrait>(
                 .get(&u64::from(sector_size))
                 .expect("unknown sector size"),
         ),
+        porep_id,
     };
 
     let mut out: Vec<(SectorId, PreCommitReplicaOutput<Tree>)> = Default::default();

filecoin-proofs/src/api/mod.rs

@@ -131,8 +131,13 @@ where
     let comm_d =
         as_safe_commitment::<<DefaultPieceHasher as Hasher>::Domain, _>(&comm_d, "comm_d")?;
 
-    let replica_id =
-        generate_replica_id::<Tree::Hasher, _>(&prover_id, sector_id.into(), &ticket, comm_d);
+    let replica_id = generate_replica_id::<Tree::Hasher, _>(
+        &prover_id,
+        sector_id.into(),
+        &ticket,
+        comm_d,
+        &porep_config.porep_id,
+    );
 
     let mut data = Vec::new();
     sealed_sector.read_to_end(&mut data)?;
@@ -559,6 +564,7 @@ mod tests {
         let out = bytes_into_fr(&not_convertible_to_fr_bytes);
         assert!(out.is_err(), "tripwire");
 
+        let arbitrary_porep_id = [87; 32];
         {
             let result = verify_seal::<DefaultOctLCTree>(
                 PoRepConfig {
@@ -570,6 +576,7 @@ mod tests {
                             .get(&SECTOR_SIZE_2_KIB)
                             .unwrap(),
                     ),
+                    porep_id: arbitrary_porep_id,
                 },
                 not_convertible_to_fr_bytes,
                 convertible_to_fr_bytes,
@@ -604,6 +611,7 @@ mod tests {
                             .get(&SECTOR_SIZE_2_KIB)
                             .unwrap(),
                     ),
+                    porep_id: arbitrary_porep_id,
                 },
                 convertible_to_fr_bytes,
                 not_convertible_to_fr_bytes,

filecoin-proofs/src/api/seal.rs

@@ -149,8 +149,13 @@ where
         "pieces and comm_d do not match"
     );
 
-    let replica_id =
-        generate_replica_id::<Tree::Hasher, _>(&prover_id, sector_id.into(), &ticket, comm_d);
+    let replica_id = generate_replica_id::<Tree::Hasher, _>(
+        &prover_id,
+        sector_id.into(),
+        &ticket,
+        comm_d,
+        &porep_config.porep_id,
+    );
 
     let labels = StackedDrg::<Tree, DefaultPieceHasher>::replicate_phase1(
         &compound_public_params.vanilla_params,
@@ -327,11 +332,17 @@ pub fn seal_commit_phase1<T: AsRef<Path>, Tree: 'static + MerkleTreeTrait>(
     let comm_r_safe = as_safe_commitment(&comm_r, "comm_r")?;
     let comm_d_safe = DefaultPieceDomain::try_from_bytes(&comm_d)?;
 
-    let replica_id =
-        generate_replica_id::<Tree::Hasher, _>(&prover_id, sector_id.into(), &ticket, comm_d_safe);
+    let replica_id = generate_replica_id::<Tree::Hasher, _>(
+        &prover_id,
+        sector_id.into(),
+        &ticket,
+        comm_d_safe,
+        &porep_config.porep_id,
+    );
 
     let public_inputs = stacked::PublicInputs {
         replica_id,
+        porep_id: porep_config.porep_id,
         tau: Some(stacked::Tau {
             comm_d: comm_d_safe,
             comm_r: comm_r_safe,
@@ -411,6 +422,7 @@ pub fn seal_commit_phase2<Tree: 'static + MerkleTreeTrait>(
 
     let public_inputs = stacked::PublicInputs {
         replica_id,
+        porep_id: porep_config.porep_id,
         tau: Some(stacked::Tau {
             comm_d: comm_d_safe,
             comm_r: comm_r_safe,
@@ -517,8 +529,13 @@ pub fn verify_seal<Tree: 'static + MerkleTreeTrait>(
     let comm_r: <Tree::Hasher as Hasher>::Domain = as_safe_commitment(&comm_r_in, "comm_r")?;
     let comm_d: DefaultPieceDomain = as_safe_commitment(&comm_d_in, "comm_d")?;
 
-    let replica_id =
-        generate_replica_id::<Tree::Hasher, _>(&prover_id, sector_id.into(), &ticket, comm_d);
+    let replica_id = generate_replica_id::<Tree::Hasher, _>(
+        &prover_id,
+        sector_id.into(),
+        &ticket,
+        comm_d,
+        &porep_config.porep_id,
+    );
 
     let compound_setup_params = compound_proof::SetupParams {
         vanilla_params: setup_params(
@@ -537,6 +554,7 @@ pub fn verify_seal<Tree: 'static + MerkleTreeTrait>(
     let public_inputs =
         stacked::PublicInputs::<<Tree::Hasher as Hasher>::Domain, DefaultPieceDomain> {
             replica_id,
+            porep_id: porep_config.porep_id,
             tau: Some(Tau { comm_r, comm_d }),
             seed,
             k: None,
@@ -650,13 +668,15 @@ pub fn verify_batch_seal<Tree: 'static + MerkleTreeTrait>(
             sector_ids[i].into(),
             &tickets[i],
             comm_d,
+            &porep_config.porep_id,
         );
 
         public_inputs.push(stacked::PublicInputs::<
             <Tree::Hasher as Hasher>::Domain,
             DefaultPieceDomain,
         > {
             replica_id,
+            porep_id: porep_config.porep_id,
             tau: Some(Tau { comm_r, comm_d }),
             seed: seeds[i],
             k: None,

filecoin-proofs/src/bin/paramcache.rs

@@ -216,6 +216,7 @@ fn generate_params_porep(sector_size: u64) {
                     .get(&sector_size)
                     .expect("missing sector size"),
             ),
+            porep_id: [0; 32],
         }
     );
 }

filecoin-proofs/src/bin/phase2.rs

@@ -178,6 +178,7 @@ fn blank_porep_poseidon_circuit<Tree: MerkleTreeTrait>(
     let porep_config = PoRepConfig {
         sector_size: SectorSize(sector_size),
         partitions: PoRepProofPartitions(n_partitions),
+        porep_id: [0; 32],
     };
 
     let setup_params = compound_proof::SetupParams {

filecoin-proofs/src/types/porep_config.rs

@@ -11,6 +11,7 @@ use crate::types::*;
 pub struct PoRepConfig {
     pub sector_size: SectorSize,
     pub partitions: PoRepProofPartitions,
+    pub porep_id: [u8; 32],
 }
 
 impl From<PoRepConfig> for PaddedBytesAmount {

filecoin-proofs/src/types/sector_class.rs

@@ -4,17 +4,20 @@ use crate::types::*;
 pub struct SectorClass {
     pub sector_size: SectorSize,
     pub partitions: PoRepProofPartitions,
+    pub porep_id: [u8; 32],
 }
 
 impl From<SectorClass> for PoRepConfig {
     fn from(x: SectorClass) -> Self {
         let SectorClass {
             sector_size,
             partitions,
+            porep_id,
         } = x;
         PoRepConfig {
             sector_size,
             partitions,
+            porep_id,
         }
     }
 }

filecoin-proofs/tests/api.rs

@@ -349,14 +349,15 @@ fn create_seal<R: Rng, Tree: 'static + MerkleTreeTrait>(
     )?;
 
     let piece_infos = vec![piece_info];
-
+    let arbitrary_porep_id = [28; 32];
     let sealed_sector_file = NamedTempFile::new()?;
     let mut unseal_file = NamedTempFile::new()?;
     let config = PoRepConfig {
         sector_size: SectorSize(sector_size.clone()),
         partitions: PoRepProofPartitions(
             *POREP_PARTITIONS.read().unwrap().get(&sector_size).unwrap(),
         ),
+        porep_id: arbitrary_porep_id,
     };
 
     let cache_dir = tempfile::tempdir().unwrap();

storage-proofs/porep/src/stacked/circuit/proof.rs

@@ -443,10 +443,11 @@ mod tests {
         assert_ne!(data, copied, "replication did not change data");
 
         let seed = rng.gen();
-
+        let arbitrary_porep_id = [44; 32];
         let pub_inputs =
             PublicInputs::<<Tree::Hasher as Hasher>::Domain, <Sha256Hasher as Hasher>::Domain> {
                 replica_id: replica_id.into(),
+                porep_id: arbitrary_porep_id,
                 seed,
                 tau: Some(tau.into()),
                 k: None,
@@ -632,10 +633,11 @@ mod tests {
         assert_ne!(data, copied, "replication did not change data");
 
         let seed = rng.gen();
-
+        let arbitrary_porep_id = [55; 32];
         let public_inputs =
             PublicInputs::<<Tree::Hasher as Hasher>::Domain, <Sha256Hasher as Hasher>::Domain> {
                 replica_id: replica_id.into(),
+                porep_id: arbitrary_porep_id,
                 seed,
                 tau: Some(tau),
                 k: None,

storage-proofs/porep/src/stacked/vanilla/params.rs

@@ -109,6 +109,7 @@ where
 pub struct PublicInputs<T: Domain, S: Domain> {
     pub replica_id: T,
     pub seed: [u8; 32],
+    pub porep_id: [u8; 32],
     pub tau: Option<Tau<T, S>>,
     /// Partition index
     pub k: Option<usize>,
@@ -725,6 +726,7 @@ pub fn generate_replica_id<H: Hasher, T: AsRef<[u8]>>(
     sector_id: u64,
     ticket: &[u8; 32],
     comm_d: T,
+    porep_seed: &[u8; 32],
 ) -> H::Domain {
     use sha2::{Digest, Sha256};
 
@@ -733,6 +735,7 @@ pub fn generate_replica_id<H: Hasher, T: AsRef<[u8]>>(
         .chain(&sector_id.to_be_bytes()[..])
         .chain(ticket)
         .chain(AsRef::<[u8]>::as_ref(&comm_d))
+        .chain(porep_seed)
         .result();
 
     bytes_into_fr_repr_safe(hash.as_ref()).into()

storage-proofs/porep/src/stacked/vanilla/proof.rs

@@ -1208,10 +1208,11 @@ mod tests {
         assert_ne!(data, copied, "replication did not change data");
 
         let seed = rng.gen();
-
+        let arbitrary_porep_id = [92; 32];
         let pub_inputs =
             PublicInputs::<<Tree::Hasher as Hasher>::Domain, <Blake2sHasher as Hasher>::Domain> {
                 replica_id,
+                porep_id: arbitrary_porep_id,
                 seed,
                 tau: Some(tau),
                 k: None,

storage-proofs/porep/src/stacked/vanilla/proof_scheme.rs

@@ -142,6 +142,7 @@ impl<'a, 'c, Tree: 'static + MerkleTreeTrait, G: 'static + Hasher> ProofScheme<'
         self::PublicInputs {
             replica_id: pub_in.replica_id,
             seed: pub_in.seed,
+            porep_id: pub_in.porep_id,
             tau: pub_in.tau,
             k,
         }