Generate Feistel key from porep_id.

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

@@ -272,7 +272,6 @@ fn run_measure_circuits(i: &ProdbenchInputs) -> CircuitOutputs {
 }
 
 fn measure_porep_circuit(i: &ProdbenchInputs) -> usize {
-    use storage_proofs::drgraph::new_seed;
     use storage_proofs::porep::stacked::{
         LayerChallenges, SetupParams, StackedCompound, StackedDrg,
     };
@@ -284,11 +283,12 @@ fn measure_porep_circuit(i: &ProdbenchInputs) -> usize {
     let nodes = (i.sector_size_bytes() / 32) as usize;
     let layer_challenges = LayerChallenges::new(layers, challenge_count);
 
+    let arbitrary_porep_id = [222; 32];
     let sp = SetupParams {
         nodes,
         degree: drg_degree,
         expansion_degree,
-        seed: new_seed(),
+        porep_id: arbitrary_porep_id,
         layer_challenges,
     };
 

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

@@ -120,11 +120,12 @@ where
         );
 
         let replica_id = H::Domain::random(rng);
+        let arbitrary_porep_id = [11; 32];
         let sp = stacked::SetupParams {
             nodes,
             degree: BASE_DEGREE,
             expansion_degree: EXP_DEGREE,
-            seed: new_seed(),
+            porep_id: arbitrary_porep_id,
             layer_challenges: layer_challenges.clone(),
         };
 

filecoin-proofs/src/parameters.rs

@@ -1,17 +1,11 @@
 use anyhow::{ensure, Result};
-use sha2::{Digest, Sha256};
 use storage_proofs::porep::stacked::{self, LayerChallenges, StackedDrg};
 use storage_proofs::post::fallback;
 use storage_proofs::proof::ProofScheme;
 
 use crate::constants::*;
 use crate::types::{MerkleTreeTrait, PaddedBytesAmount, PoStConfig};
 
-const DRG_NONCE: [u8; 32] = [
-    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
-    26, 27, 28, 30, 30, 31,
-];
-
 type WinningPostSetupParams = fallback::SetupParams;
 pub type WinningPostPublicParams = fallback::PublicParams;
 
@@ -74,15 +68,6 @@ pub fn window_post_setup_params(post_config: &PoStConfig) -> WindowPostSetupPara
     }
 }
 
-fn drg_seed_from_porep_id(porep_id: [u8; 32]) -> [u8; 28] {
-    let mut drg_seed = [0; 28];
-
-    let hash = Sha256::new().chain(porep_id).chain(DRG_NONCE).result();
-
-    drg_seed.copy_from_slice(&hash[..28]);
-    drg_seed
-}
-
 pub fn setup_params(
     sector_bytes: PaddedBytesAmount,
     partitions: usize,
@@ -113,13 +98,11 @@ pub fn setup_params(
     let degree = DRG_DEGREE;
     let expansion_degree = EXP_DEGREE;
 
-    let drg_seed = drg_seed_from_porep_id(porep_id);
-
     Ok(stacked::SetupParams {
         nodes,
         degree,
         expansion_degree,
-        seed: drg_seed,
+        porep_id,
         layer_challenges,
     })
 }

filecoin-proofs/src/pieces.rs

@@ -356,7 +356,7 @@ mod tests {
     use paired::bls12_381::Fr;
     use rand::{Rng, RngCore, SeedableRng};
     use rand_xorshift::XorShiftRng;
-    use storage_proofs::drgraph::{new_seed, Graph};
+    use storage_proofs::drgraph::Graph;
     use storage_proofs::merkle::create_base_merkle_tree;
     use storage_proofs::porep::stacked::StackedBucketGraph;
 
@@ -698,11 +698,12 @@ mod tests {
         sector_size: SectorSize,
     ) -> Result<([u8; 32], Vec<PieceInfo>)> {
         let rng = &mut XorShiftRng::from_seed(crate::TEST_SEED);
+        let porep_id = [32; 32];
         let graph = StackedBucketGraph::<DefaultPieceHasher>::new_stacked(
             u64::from(sector_size) as usize / NODE_SIZE,
             DRG_DEGREE,
             EXP_DEGREE,
-            new_seed(),
+            porep_id,
         )?;
 
         let mut staged_sector = Vec::with_capacity(u64::from(sector_size) as usize);

storage-proofs/core/benches/drgraph.rs

@@ -11,7 +11,7 @@ fn drgraph(c: &mut Criterion) {
             "bucket/m=6",
             |b, n| {
                 let graph =
-                    BucketGraph::<PedersenHasher>::new(*n, BASE_DEGREE, 0, new_seed()).unwrap();
+                    BucketGraph::<PedersenHasher>::new(*n, BASE_DEGREE, 0, [32; 32]).unwrap();
 
                 b.iter(|| {
                     let mut parents = vec![0; 6];

storage-proofs/core/src/crypto/mod.rs

@@ -1,5 +1,14 @@
+use sha2::{Digest, Sha256};
 pub mod aes;
 pub mod feistel;
 pub mod pedersen;
 pub mod sloth;
 pub mod xor;
+
+pub fn derive_porep_domain_seed(domain_separation_tag: &str, porep_id: [u8; 32]) -> [u8; 32] {
+    Sha256::new()
+        .chain(domain_separation_tag)
+        .chain(porep_id)
+        .result()
+        .into()
+}

storage-proofs/core/src/drgraph.rs

@@ -7,6 +7,7 @@ use rand::{rngs::OsRng, Rng, SeedableRng};
 use rand_chacha::ChaCha8Rng;
 use sha2::{Digest, Sha256};
 
+use crate::crypto::derive_porep_domain_seed;
 use crate::error::*;
 use crate::fr32::bytes_into_fr_repr_safe;
 use crate::hasher::{Hasher, PoseidonArity};
@@ -54,7 +55,7 @@ pub trait Graph<H: Hasher>: ::std::fmt::Debug + Clone + PartialEq + Eq {
         nodes: usize,
         base_degree: usize,
         expansion_degree: usize,
-        seed: [u8; 28],
+        porep_id: [u8; 32],
     ) -> Result<Self>;
     fn seed(&self) -> [u8; 28];
 
@@ -203,7 +204,7 @@ impl<H: Hasher> Graph<H> for BucketGraph<H> {
         nodes: usize,
         base_degree: usize,
         expansion_degree: usize,
-        seed: [u8; 28],
+        porep_id: [u8; 32],
     ) -> Result<Self> {
         ensure!(expansion_degree == 0, "Expension degree must be zero.");
 
@@ -216,10 +217,14 @@ impl<H: Hasher> Graph<H> for BucketGraph<H> {
             "The number of metagraph nodes must be precisely castable to `f64`"
         );
 
+        let mut drg_seed = [0; 28];
+        let raw_seed = derive_porep_domain_seed("Filecoin_DRSample", porep_id);
+        drg_seed.copy_from_slice(&raw_seed[..28]);
+
         Ok(BucketGraph {
             nodes,
             base_degree,
-            seed,
+            seed: drg_seed,
             _h: PhantomData,
         })
     }
@@ -237,7 +242,6 @@ mod tests {
     use memmap::MmapOptions;
     use merkletree::store::StoreConfig;
 
-    use crate::drgraph::new_seed;
     use crate::hasher::{
         Blake2sHasher, PedersenHasher, PoseidonArity, PoseidonHasher, Sha256Hasher,
     };
@@ -257,9 +261,10 @@ mod tests {
 
     fn graph_bucket<H: Hasher>() {
         let degree = BASE_DEGREE;
+        let porep_id = [123; 32];
 
         for size in vec![4, 16, 256, 2048] {
-            let g = BucketGraph::<H>::new(size, degree, 0, new_seed()).unwrap();
+            let g = BucketGraph::<H>::new(size, degree, 0, porep_id).unwrap();
 
             assert_eq!(g.size(), size, "wrong nodes count");
 
@@ -309,7 +314,8 @@ mod tests {
 
     fn gen_proof<H: 'static + Hasher, U: 'static + PoseidonArity>(config: Option<StoreConfig>) {
         let leafs = 64;
-        let g = BucketGraph::<H>::new(leafs, BASE_DEGREE, 0, new_seed()).unwrap();
+        let porep_id = [1; 32];
+        let g = BucketGraph::<H>::new(leafs, BASE_DEGREE, 0, porep_id).unwrap();
         let data = vec![2u8; NODE_SIZE * leafs];
 
         let mmapped = &mmap_from(&data);

storage-proofs/core/src/por.rs

@@ -156,7 +156,7 @@ mod tests {
     use rand::SeedableRng;
     use rand_xorshift::XorShiftRng;
 
-    use crate::drgraph::{new_seed, BucketGraph, Graph, BASE_DEGREE};
+    use crate::drgraph::{BucketGraph, Graph, BASE_DEGREE};
     use crate::fr32::fr_into_bytes;
     use crate::hasher::{Blake2sHasher, PedersenHasher, PoseidonHasher, Sha256Hasher};
     use crate::merkle::{create_base_merkle_tree, DiskStore, MerkleProofTrait, MerkleTreeWrapper};
@@ -174,8 +174,8 @@ mod tests {
         let data: Vec<u8> = (0..leaves)
             .flat_map(|_| fr_into_bytes(&Fr::random(rng)))
             .collect();
-
-        let graph = BucketGraph::<Tree::Hasher>::new(leaves, BASE_DEGREE, 0, new_seed()).unwrap();
+        let porep_id = [3; 32];
+        let graph = BucketGraph::<Tree::Hasher>::new(leaves, BASE_DEGREE, 0, porep_id).unwrap();
         let tree = create_base_merkle_tree::<Tree>(None, graph.size(), data.as_slice()).unwrap();
 
         let pub_inputs = PublicInputs {
@@ -265,7 +265,9 @@ mod tests {
             .flat_map(|_| fr_into_bytes(&Fr::random(rng)))
             .collect();
 
-        let graph = BucketGraph::<Tree::Hasher>::new(leaves, BASE_DEGREE, 0, new_seed()).unwrap();
+        let porep_id = [99; 32];
+
+        let graph = BucketGraph::<Tree::Hasher>::new(leaves, BASE_DEGREE, 0, porep_id).unwrap();
         let tree = create_base_merkle_tree::<Tree>(None, graph.size(), data.as_slice()).unwrap();
 
         let pub_inputs = PublicInputs {
@@ -350,7 +352,8 @@ mod tests {
             .flat_map(|_| fr_into_bytes(&Fr::random(rng)))
             .collect();
 
-        let graph = BucketGraph::<Tree::Hasher>::new(leaves, BASE_DEGREE, 0, new_seed()).unwrap();
+        let porep_id = [32; 32];
+        let graph = BucketGraph::<Tree::Hasher>::new(leaves, BASE_DEGREE, 0, porep_id).unwrap();
         let tree = create_base_merkle_tree::<Tree>(None, graph.size(), data.as_slice()).unwrap();
 
         let pub_inputs = PublicInputs {

storage-proofs/porep/benches/encode.rs

@@ -23,7 +23,7 @@ fn pregenerate_data<H: Hasher>(degree: usize) -> Pregenerated<H> {
         .collect();
     let replica_id: H::Domain = H::Domain::random(&mut rng);
 
-    let graph = StackedBucketGraph::<H>::new_stacked(size, 6, 8, new_seed()).unwrap();
+    let graph = StackedBucketGraph::<H>::new_stacked(size, 6, 8, [32; 32]).unwrap();
 
     Pregenerated {
         data,

storage-proofs/porep/benches/parents.rs

@@ -38,7 +38,7 @@ fn stop_profile() {}
 
 fn pregenerate_graph<H: Hasher>(size: usize) -> StackedBucketGraph<H> {
     let seed = [1u8; 28];
-    StackedBucketGraph::<H>::new_stacked(size, BASE_DEGREE, EXP_DEGREE, seed).unwrap()
+    StackedBucketGraph::<H>::new_stacked(size, BASE_DEGREE, EXP_DEGREE, [32; 32]).unwrap()
 }
 
 fn parents_loop<H: Hasher, G: Graph<H>>(graph: &G, parents: &mut [u32]) {

storage-proofs/porep/src/drg/circuit.rs

@@ -314,7 +314,7 @@ mod tests {
     use storage_proofs_core::{
         cache_key::CacheKey,
         compound_proof,
-        drgraph::{graph_height, new_seed, BucketGraph, BASE_DEGREE},
+        drgraph::{graph_height, BucketGraph, BASE_DEGREE},
         fr32::{bytes_into_fr, fr_into_bytes},
         gadgets::TestConstraintSystem,
         hasher::PedersenHasher,
@@ -368,7 +368,7 @@ mod tests {
                 nodes,
                 degree,
                 expansion_degree: 0,
-                seed: new_seed(),
+                porep_id: [32; 32],
             },
             private: false,
             challenges_count: 1,

storage-proofs/porep/src/drg/compound.rs

@@ -289,7 +289,7 @@ mod tests {
     use storage_proofs_core::{
         cache_key::CacheKey,
         compound_proof,
-        drgraph::{new_seed, BucketGraph, BASE_DEGREE},
+        drgraph::{BucketGraph, BASE_DEGREE},
         fr32::fr_into_bytes,
         gadgets::{MetricCS, TestConstraintSystem},
         hasher::{Hasher, PedersenHasher, PoseidonHasher},
@@ -342,16 +342,13 @@ mod tests {
         let replica_path = cache_dir.path().join("replica-path");
         let mut mmapped_data = setup_replica(&data, &replica_path);
 
-        // Only generate seed once. It would be bad if we used different seeds in the same test.
-        let seed = new_seed();
-
         let setup_params = compound_proof::SetupParams {
             vanilla_params: drg::SetupParams {
                 drg: drg::DrgParams {
                     nodes,
                     degree,
                     expansion_degree: 0,
-                    seed,
+                    porep_id: [32; 32],
                 },
                 private: false,
                 challenges_count: 2,
@@ -396,7 +393,7 @@ mod tests {
                     nodes,
                     degree,
                     expansion_degree: 0,
-                    seed,
+                    porep_id: [32; 32],
                 },
                 private: false,
                 challenges_count: 2,

storage-proofs/porep/src/drg/vanilla.rs

@@ -80,8 +80,7 @@ pub struct DrgParams {
 
     pub expansion_degree: usize,
 
-    // Random seed
-    pub seed: [u8; 28],
+    pub porep_id: [u8; 32],
 }
 
 #[derive(Debug, Clone)]
@@ -250,7 +249,7 @@ where
             sp.drg.nodes,
             sp.drg.degree,
             sp.drg.expansion_degree,
-            sp.drg.seed,
+            sp.drg.porep_id,
         )?;
 
         Ok(PublicParams::new(graph, sp.private, sp.challenges_count))
@@ -652,7 +651,7 @@ mod tests {
                 nodes,
                 degree: BASE_DEGREE,
                 expansion_degree: 0,
-                seed: new_seed(),
+                porep_id: [32; 32],
             },
             private: false,
             challenges_count: 1,
@@ -731,7 +730,7 @@ mod tests {
                 nodes: data.len() / 32,
                 degree: BASE_DEGREE,
                 expansion_degree: 0,
-                seed: new_seed(),
+                porep_id: [32; 32],
             },
             private: false,
             challenges_count: 1,
@@ -797,7 +796,6 @@ mod tests {
             let rng = &mut XorShiftRng::from_seed(crate::TEST_SEED);
             let degree = BASE_DEGREE;
             let expansion_degree = 0;
-            let seed = new_seed();
 
             let replica_id: <Tree::Hasher as Hasher>::Domain =
                 <Tree::Hasher as Hasher>::Domain::random(rng);
@@ -825,7 +823,7 @@ mod tests {
                     nodes,
                     degree,
                     expansion_degree,
-                    seed,
+                    porep_id: [32; 32],
                 },
                 private: false,
                 challenges_count: 2,

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

@@ -92,7 +92,7 @@ mod tests {
     use rand::SeedableRng;
     use rand_xorshift::XorShiftRng;
     use storage_proofs_core::{
-        drgraph::{new_seed, Graph, BASE_DEGREE},
+        drgraph::{Graph, BASE_DEGREE},
         fr32::{bytes_into_fr, fr_into_bytes},
         gadgets::TestConstraintSystem,
         hasher::Sha256Hasher,
@@ -110,12 +110,13 @@ mod tests {
         let rng = &mut XorShiftRng::from_seed(crate::TEST_SEED);
 
         let size = 64;
+        let porep_id = [32; 32];
 
         let graph = StackedBucketGraph::<Sha256Hasher>::new_stacked(
             size,
             BASE_DEGREE,
             EXP_DEGREE,
-            new_seed(),
+            porep_id,
         )
         .unwrap();