diff --git a/fil-proofs-tooling/src/bin/benchy/prodbench.rs b/fil-proofs-tooling/src/bin/benchy/prodbench.rs index 3ec95ae04..4f69484c7 100644 --- a/fil-proofs-tooling/src/bin/benchy/prodbench.rs +++ b/fil-proofs-tooling/src/bin/benchy/prodbench.rs @@ -179,6 +179,7 @@ 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"); @@ -186,6 +187,7 @@ pub fn run( 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: {:?})", §or_size, &partitions ); + let dummy_porep_id = [0; 32]; cache_porep_params(PoRepConfig { sector_size, partitions, + porep_id: dummy_porep_id, }); } diff --git a/fil-proofs-tooling/src/bin/benchy/stacked.rs b/fil-proofs-tooling/src/bin/benchy/stacked.rs index d410dac96..d9f63865a 100644 --- a/fil-proofs-tooling/src/bin/benchy/stacked.rs +++ b/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::::Domain> { replica_id, seed, tau: Some(tau), k: Some(0), + porep_id: arbitrary_porep_id, }; // Convert TemporaryAux to TemporaryAuxCache, which instantiates all diff --git a/fil-proofs-tooling/src/bin/benchy/window_post.rs b/fil-proofs-tooling/src/bin/benchy/window_post.rs index d87acd3ec..d63f120c7 100644 --- a/fil-proofs-tooling/src/bin/benchy/window_post.rs +++ b/fil-proofs-tooling/src/bin/benchy/window_post.rs @@ -102,6 +102,8 @@ pub fn run_window_post_bench( 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( .get(&(sector_size)) .unwrap(), ), + porep_id: arbitrary_porep_id, }; let cache_dir = tempfile::tempdir().unwrap(); let sector_id = SectorId::from(SECTOR_ID); diff --git a/fil-proofs-tooling/src/bin/benchy/winning_post.rs b/fil-proofs-tooling/src/bin/benchy/winning_post.rs index 6f31d0744..beb5b01fd 100644 --- a/fil-proofs-tooling/src/bin/benchy/winning_post.rs +++ b/fil-proofs-tooling/src/bin/benchy/winning_post.rs @@ -53,7 +53,8 @@ pub fn run_fallback_post_bench( "This benchmark only works with WINNING_POST_SECTOR_COUNT == 1" )); } - let (sector_id, replica_output) = create_replica::(sector_size); + let arbitrary_porep_id = [66; 32]; + let (sector_id, replica_output) = create_replica::(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)]; diff --git a/fil-proofs-tooling/src/bin/gpu-cpu-test/main.rs b/fil-proofs-tooling/src/bin/gpu-cpu-test/main.rs index a32b3035a..d4160268a 100644 --- a/fil-proofs-tooling/src/bin/gpu-cpu-test/main.rs +++ b/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>> = Vec::new(); + let arbitrary_porep_id = [234; 32]; // Create fixtures only once for both threads - let (sector_id, replica_output) = create_replica::(SECTOR_SIZE); + let (sector_id, replica_output) = create_replica::(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) diff --git a/fil-proofs-tooling/src/shared.rs b/fil-proofs-tooling/src/shared.rs index 9395a66bf..684c2de56 100644 --- a/fil-proofs-tooling/src/shared.rs +++ b/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( sector_size: u64, + porep_id: [u8; 32], ) -> (SectorId, PreCommitReplicaOutput) { - let (_porep_config, result) = create_replicas::(SectorSize(sector_size), 1, false); + let (_porep_config, result) = + create_replicas::(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( sector_size: SectorSize, qty_sectors: usize, only_add: bool, + porep_id: [u8; 32], ) -> ( PoRepConfig, Option<( @@ -99,6 +102,7 @@ pub fn create_replicas( .get(&u64::from(sector_size)) .expect("unknown sector size"), ), + porep_id, }; let mut out: Vec<(SectorId, PreCommitReplicaOutput)> = Default::default(); diff --git a/filecoin-proofs/src/api/mod.rs b/filecoin-proofs/src/api/mod.rs index 16a6a03e0..c6a5caf77 100644 --- a/filecoin-proofs/src/api/mod.rs +++ b/filecoin-proofs/src/api/mod.rs @@ -131,8 +131,13 @@ where let comm_d = as_safe_commitment::<::Domain, _>(&comm_d, "comm_d")?; - let replica_id = - generate_replica_id::(&prover_id, sector_id.into(), &ticket, comm_d); + let replica_id = generate_replica_id::( + &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(¬_convertible_to_fr_bytes); assert!(out.is_err(), "tripwire"); + let arbitrary_porep_id = [87; 32]; { let result = verify_seal::( 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, diff --git a/filecoin-proofs/src/api/seal.rs b/filecoin-proofs/src/api/seal.rs index 514b09588..605e9ccd3 100644 --- a/filecoin-proofs/src/api/seal.rs +++ b/filecoin-proofs/src/api/seal.rs @@ -149,8 +149,13 @@ where "pieces and comm_d do not match" ); - let replica_id = - generate_replica_id::(&prover_id, sector_id.into(), &ticket, comm_d); + let replica_id = generate_replica_id::( + &prover_id, + sector_id.into(), + &ticket, + comm_d, + &porep_config.porep_id, + ); let labels = StackedDrg::::replicate_phase1( &compound_public_params.vanilla_params, @@ -327,11 +332,17 @@ pub fn seal_commit_phase1, 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::(&prover_id, sector_id.into(), &ticket, comm_d_safe); + let replica_id = generate_replica_id::( + &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( 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( let comm_r: ::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::(&prover_id, sector_id.into(), &ticket, comm_d); + let replica_id = generate_replica_id::( + &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( let public_inputs = stacked::PublicInputs::<::Domain, DefaultPieceDomain> { replica_id, + porep_id: porep_config.porep_id, tau: Some(Tau { comm_r, comm_d }), seed, k: None, @@ -650,6 +668,7 @@ pub fn verify_batch_seal( sector_ids[i].into(), &tickets[i], comm_d, + &porep_config.porep_id, ); public_inputs.push(stacked::PublicInputs::< @@ -657,6 +676,7 @@ pub fn verify_batch_seal( DefaultPieceDomain, > { replica_id, + porep_id: porep_config.porep_id, tau: Some(Tau { comm_r, comm_d }), seed: seeds[i], k: None, diff --git a/filecoin-proofs/src/bin/paramcache.rs b/filecoin-proofs/src/bin/paramcache.rs index 05678bc37..d2154adc5 100644 --- a/filecoin-proofs/src/bin/paramcache.rs +++ b/filecoin-proofs/src/bin/paramcache.rs @@ -216,6 +216,7 @@ fn generate_params_porep(sector_size: u64) { .get(§or_size) .expect("missing sector size"), ), + porep_id: [0; 32], } ); } diff --git a/filecoin-proofs/src/bin/phase2.rs b/filecoin-proofs/src/bin/phase2.rs index d7633563f..75baacc3d 100644 --- a/filecoin-proofs/src/bin/phase2.rs +++ b/filecoin-proofs/src/bin/phase2.rs @@ -178,6 +178,7 @@ fn blank_porep_poseidon_circuit( let porep_config = PoRepConfig { sector_size: SectorSize(sector_size), partitions: PoRepProofPartitions(n_partitions), + porep_id: [0; 32], }; let setup_params = compound_proof::SetupParams { diff --git a/filecoin-proofs/src/types/porep_config.rs b/filecoin-proofs/src/types/porep_config.rs index 53b3fc3e1..ee46785d4 100644 --- a/filecoin-proofs/src/types/porep_config.rs +++ b/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 for PaddedBytesAmount { diff --git a/filecoin-proofs/src/types/sector_class.rs b/filecoin-proofs/src/types/sector_class.rs index 95a002506..42ed93b9d 100644 --- a/filecoin-proofs/src/types/sector_class.rs +++ b/filecoin-proofs/src/types/sector_class.rs @@ -4,6 +4,7 @@ use crate::types::*; pub struct SectorClass { pub sector_size: SectorSize, pub partitions: PoRepProofPartitions, + pub porep_id: [u8; 32], } impl From for PoRepConfig { @@ -11,10 +12,12 @@ impl From for PoRepConfig { let SectorClass { sector_size, partitions, + porep_id, } = x; PoRepConfig { sector_size, partitions, + porep_id, } } } diff --git a/filecoin-proofs/tests/api.rs b/filecoin-proofs/tests/api.rs index af883fc98..79231600a 100644 --- a/filecoin-proofs/tests/api.rs +++ b/filecoin-proofs/tests/api.rs @@ -349,7 +349,7 @@ fn create_seal( )?; 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 { @@ -357,6 +357,7 @@ fn create_seal( partitions: PoRepProofPartitions( *POREP_PARTITIONS.read().unwrap().get(§or_size).unwrap(), ), + porep_id: arbitrary_porep_id, }; let cache_dir = tempfile::tempdir().unwrap(); diff --git a/storage-proofs/porep/src/stacked/circuit/proof.rs b/storage-proofs/porep/src/stacked/circuit/proof.rs index 76a893890..36b1be734 100644 --- a/storage-proofs/porep/src/stacked/circuit/proof.rs +++ b/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::<::Domain, ::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::<::Domain, ::Domain> { replica_id: replica_id.into(), + porep_id: arbitrary_porep_id, seed, tau: Some(tau), k: None, diff --git a/storage-proofs/porep/src/stacked/vanilla/params.rs b/storage-proofs/porep/src/stacked/vanilla/params.rs index 7667a8c4b..665e2f228 100644 --- a/storage-proofs/porep/src/stacked/vanilla/params.rs +++ b/storage-proofs/porep/src/stacked/vanilla/params.rs @@ -109,6 +109,7 @@ where pub struct PublicInputs { pub replica_id: T, pub seed: [u8; 32], + pub porep_id: [u8; 32], pub tau: Option>, /// Partition index pub k: Option, @@ -725,6 +726,7 @@ pub fn generate_replica_id>( 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>( .chain(§or_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() diff --git a/storage-proofs/porep/src/stacked/vanilla/proof.rs b/storage-proofs/porep/src/stacked/vanilla/proof.rs index 165c6fc70..1f409cf30 100644 --- a/storage-proofs/porep/src/stacked/vanilla/proof.rs +++ b/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::<::Domain, ::Domain> { replica_id, + porep_id: arbitrary_porep_id, seed, tau: Some(tau), k: None, diff --git a/storage-proofs/porep/src/stacked/vanilla/proof_scheme.rs b/storage-proofs/porep/src/stacked/vanilla/proof_scheme.rs index b14f8e05b..d9ab40ffe 100644 --- a/storage-proofs/porep/src/stacked/vanilla/proof_scheme.rs +++ b/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, }