refactor(patch-testing): sha2, rsa versions (#2240)

leruaa · web-flow · commit 652cc9f374eb · 2025-04-15T03:18:00.000-07:00
diff --git a/patch-testing/Cargo.lock b/patch-testing/Cargo.lock
diff --git a/patch-testing/RustCrypto-rsa/program/Cargo.toml b/patch-testing/RustCrypto-rsa/program/Cargo.toml
@@ -14,5 +14,5 @@ num-bigint = "0.4.0"
 rsa = { version = "=0.9.6", features = ["serde", "sha2"] }
 
 [patch.crates-io]
-rsa = { git = "https://github.com/sp1-patches/RustCrypto-RSA/", tag = "patch-0.9.6-sp1-4.0.0" }
+rsa = { git = "https://github.com/sp1-patches/RustCrypto-RSA/", tag = "patch-0.9.6-sp1-4.0.0-v2" }
 sp1-lib = { path = "../../../crates/zkvm/lib" }
diff --git a/patch-testing/sha/Cargo.toml b/patch-testing/sha/Cargo.toml
@@ -9,8 +9,7 @@ sp1-zkvm.workspace = true
 sp1-sdk.workspace = true
 sp1-core-executor.workspace = true
 
-sha2-v0-9-8 = { version = "0.9.8", package = "sha2" }
-sha2-v0-10-6 = { version = "0.10.6", package = "sha2" }
+sha2 = { version = "0.9.9", package = "sha2" }
 rand = "0.8.5"
 sp1-test.workspace = true
 sha3 = "=0.10.6"
diff --git a/patch-testing/sha/build.rs b/patch-testing/sha/build.rs
@@ -1,3 +1,16 @@
+use sp1_build::BuildArgs;
+
 fn main() {
-    sp1_build::build_program("./program");
+    sp1_build::build_program_with_args(
+        "./program",
+        BuildArgs { features: vec!["v0-9-9".to_string()], ..Default::default() },
+    );
+    sp1_build::build_program_with_args(
+        "./program",
+        BuildArgs { features: vec!["v0-10-6".to_string()], ..Default::default() },
+    );
+    sp1_build::build_program_with_args(
+        "./program",
+        BuildArgs { features: vec!["v0-10-8".to_string()], ..Default::default() },
+    );
 }
diff --git a/patch-testing/sha/program/Cargo.toml b/patch-testing/sha/program/Cargo.toml
@@ -5,8 +5,19 @@ version = "0.1.0"
 edition = "2021"
 
 [[bin]]
-name = "sha2"
+name = "sha2_v0_9_9"
 path = "bin/sha2.rs"
+required-features = ["v0-9-9"]
+
+[[bin]]
+name = "sha2_v0_10_6"
+path = "bin/sha2.rs"
+required-features = ["v0-10-6"]
+
+[[bin]]
+name = "sha2_v0_10_8"
+path = "bin/sha2.rs"
+required-features = ["v0-10-8"]
 
 [[bin]]
 name = "sha3"
@@ -16,15 +27,20 @@ path = "bin/sha3.rs"
 sp1-zkvm = { path = "../../../crates/zkvm/entrypoint" }
 serde = { version = "1.0.215", features = ["derive"] }
 
-# note: 9.8 was yanked 
-sha2-v0-9-8 = { version = "0.9.9", package = "sha2" }
-sha2-v0-10-8 = { version = "0.10.8", package = "sha2" }
+sha2-v0-9-9 = { version = "0.9.9", package = "sha2", optional = true }
+sha2-v0-10-6 = { version = "0.10.6", package = "sha2", optional = true }
+sha2-v0-10-8 = { version = "0.10.8", package = "sha2", optional = true }
 
 sha3 = { version = "0.10.8", package = "sha3" }
 
+[features]
+v0-9-9 = ["dep:sha2-v0-9-9"]
+v0-10-6 = ["dep:sha2-v0-10-6"]
+v0-10-8 = ["dep:sha2-v0-10-8"]
+
 [patch.crates-io]
 sha3 = { git = "https://github.com/sp1-patches/RustCrypto-hashes", package = "sha3", tag = "patch-sha3-0.10.8-sp1-4.0.0" }
 
 sha2-v0-10-8 = { git = "https://github.com/sp1-patches/RustCrypto-hashes", package = "sha2", tag = "patch-sha2-0.10.8-sp1-4.0.0" }
-# todo: 0.9.8 is yanked?
+sha2-v0-10-6 = { git = "https://github.com/sp1-patches/RustCrypto-hashes", package = "sha2", tag = "patch-sha2-0.10.6-sp1-4.0.0" }
 sha2-v0-9-9 = { git = "https://github.com/sp1-patches/RustCrypto-hashes", package = "sha2", tag = "sha2-v0.9.9-patch-v1" }
diff --git a/patch-testing/sha/program/bin/sha2.rs b/patch-testing/sha/program/bin/sha2.rs
@@ -1,8 +1,16 @@
 #![no_main]
 sp1_zkvm::entrypoint!(main);
 
-use sha2_v0_9_8::{Digest as D1, Sha256 as Sha256_9_8};
-use sha2_v0_10_8::{Digest as D2, Sha256 as Sha256_10_8};
+#[cfg(feature = "v0-9-9")]
+extern crate sha2_v0_9_9 as sha2;
+
+#[cfg(feature = "v0-10-6")]
+extern crate sha2_v0_10_6 as sha2;
+
+#[cfg(feature = "v0-10-8")]
+extern crate sha2_v0_10_8 as sha2;
+
+use sha2::{Digest, Sha256};
 
 /// Emits SHA_COMPRESS and SHA_EXTEND syscalls.
 pub fn main() {
@@ -11,15 +19,11 @@ pub fn main() {
     for _ in 0..times {
         let preimage = sp1_zkvm::io::read_vec();
 
-        let mut sha256_9_8 = Sha256_9_8::new();
-        sha256_9_8.update(&preimage);
-
-        let mut sha256_10_6 = Sha256_10_8::new();
-        sha256_10_6.update(&preimage);
+        let mut sha256 = Sha256::new();
+        sha256.update(&preimage);
 
-        let output_9_8: [u8; 32] = sha256_9_8.finalize().into();
-        let output_10_6: [u8; 32] = sha256_10_6.finalize().into();
+        let output: [u8; 32] = sha256.finalize().into();
 
-        sp1_zkvm::io::commit(&(output_9_8, output_10_6));
+        sp1_zkvm::io::commit(&output);
     }
 }
diff --git a/patch-testing/sha/src/lib.rs b/patch-testing/sha/src/lib.rs
@@ -1,83 +1,104 @@
 #[cfg(test)]
-use sp1_sdk::SP1PublicValues;
-use sp1_test::sp1_test;
+mod tests {
+    use sha2::Digest;
+    use sp1_sdk::SP1PublicValues;
+    use sp1_test::sp1_test;
+
+    #[sp1_test("sha2_v0_9_9", syscalls = [SHA_COMPRESS, SHA_EXTEND], gpu, prove)]
+    fn test_sha2_v0_9_9_expected_digest_lte_100_times(
+        stdin: &mut sp1_sdk::SP1Stdin,
+    ) -> impl FnOnce(SP1PublicValues) {
+        sha2_expected_digest_lte_100_times(stdin)
+    }
 
-#[sp1_test("sha2", syscalls = [SHA_COMPRESS, SHA_EXTEND], gpu, prove)]
-fn test_sha2_expected_digest_lte_100_times(
-    stdin: &mut sp1_sdk::SP1Stdin,
-) -> impl FnOnce(SP1PublicValues) {
-    use sha2_v0_10_6::Digest as D2;
-    use sha2_v0_9_8::Digest as D1;
+    #[sp1_test("sha2_v0_10_6", syscalls = [SHA_COMPRESS, SHA_EXTEND], gpu, prove)]
+    fn test_sha2_v0_10_6_expected_digest_lte_100_times(
+        stdin: &mut sp1_sdk::SP1Stdin,
+    ) -> impl FnOnce(SP1PublicValues) {
+        sha2_expected_digest_lte_100_times(stdin)
+    }
 
-    use sp1_test::DEFAULT_CORPUS_COUNT;
-    use sp1_test::DEFAULT_CORPUS_MAX_LEN;
+    #[sp1_test("sha2_v0_10_8", syscalls = [SHA_COMPRESS, SHA_EXTEND], gpu, prove)]
+    fn test_sha2_v0_10_8_expected_digest_lte_100_times(
+        stdin: &mut sp1_sdk::SP1Stdin,
+    ) -> impl FnOnce(SP1PublicValues) {
+        sha2_expected_digest_lte_100_times(stdin)
+    }
 
-    let mut preimages =
-        sp1_test::random_preimages_with_bounded_len(DEFAULT_CORPUS_COUNT, DEFAULT_CORPUS_MAX_LEN);
+    fn sha2_expected_digest_lte_100_times(
+        stdin: &mut sp1_sdk::SP1Stdin,
+    ) -> impl FnOnce(SP1PublicValues) {
+        use sp1_test::DEFAULT_CORPUS_COUNT;
+        use sp1_test::DEFAULT_CORPUS_MAX_LEN;
 
-    sp1_test::add_hash_fn_edge_cases(&mut preimages);
+        let mut preimages = sp1_test::random_preimages_with_bounded_len(
+            DEFAULT_CORPUS_COUNT,
+            DEFAULT_CORPUS_MAX_LEN,
+        );
 
-    let digests = preimages
-        .iter()
-        .map(|preimage| {
-            let mut sha256_9_8 = sha2_v0_9_8::Sha256::new();
-            sha256_9_8.update(preimage);
+        sp1_test::add_hash_fn_edge_cases(&mut preimages);
 
-            let mut sha256_10_6 = sha2_v0_10_6::Sha256::new();
-            sha256_10_6.update(preimage);
+        let digests = preimages
+            .iter()
+            .map(|preimage| {
+                let mut sha256 = sha2::Sha256::new();
+                sha256.update(preimage);
 
-            (sha256_9_8.finalize().into(), sha256_10_6.finalize().into())
-        })
-        .collect::<Vec<([u8; 32], [u8; 32])>>();
+                sha256.finalize().into()
+            })
+            .collect::<Vec<[u8; 32]>>();
 
-    // Write the number of preimages to the SP1Stdin
-    // This should be equal to the number of digests.
-    stdin.write(&preimages.len());
-    preimages.iter().for_each(|preimage| stdin.write_slice(preimage.as_slice()));
+        // Write the number of preimages to the SP1Stdin
+        // This should be equal to the number of digests.
+        stdin.write(&preimages.len());
+        preimages.iter().for_each(|preimage| stdin.write_slice(preimage.as_slice()));
 
-    move |mut public| {
-        for digest in digests {
-            let committed = public.read::<([u8; 32], [u8; 32])>();
+        move |mut public| {
+            for digest in digests {
+                let committed = public.read::<[u8; 32]>();
 
-            assert_eq!(digest, committed);
+                assert_eq!(digest, committed);
+            }
         }
     }
-}
-
-#[sp1_test("sha3", syscalls = [SHA_COMPRESS, SHA_EXTEND], gpu, prove)]
-fn test_sha3_expected_digest_lte_100_times(
-    stdin: &mut sp1_sdk::SP1Stdin,
-) -> impl FnOnce(SP1PublicValues) {
-    use sha3::Digest;
-    use sha3::Sha3_256;
-
-    use sp1_test::DEFAULT_CORPUS_COUNT;
-    use sp1_test::DEFAULT_CORPUS_MAX_LEN;
-
-    let mut preimages: Vec<Vec<u8>> =
-        sp1_test::random_preimages_with_bounded_len(DEFAULT_CORPUS_COUNT, DEFAULT_CORPUS_MAX_LEN);
-
-    sp1_test::add_hash_fn_edge_cases(&mut preimages);
-
-    let digests = preimages
-        .iter()
-        .map(|preimage| {
-            let mut sha3 = Sha3_256::new();
-            sha3.update(preimage);
-
-            sha3.finalize().into()
-        })
-        .collect::<Vec<[u8; 32]>>();
-
-    // Write the number of preimages to the SP1Stdin
-    // This should be equal to the number of digests.
-    stdin.write(&preimages.len());
-    preimages.iter().for_each(|preimage| stdin.write_slice(preimage.as_slice()));
 
-    move |mut public| {
-        for digest in digests {
-            let committed = public.read::<[u8; 32]>();
-            assert_eq!(digest, committed);
+    #[sp1_test("sha3", syscalls = [SHA_COMPRESS, SHA_EXTEND], gpu, prove)]
+    fn test_sha3_expected_digest_lte_100_times(
+        stdin: &mut sp1_sdk::SP1Stdin,
+    ) -> impl FnOnce(SP1PublicValues) {
+        use sha3::Digest;
+        use sha3::Sha3_256;
+
+        use sp1_test::DEFAULT_CORPUS_COUNT;
+        use sp1_test::DEFAULT_CORPUS_MAX_LEN;
+
+        let mut preimages: Vec<Vec<u8>> = sp1_test::random_preimages_with_bounded_len(
+            DEFAULT_CORPUS_COUNT,
+            DEFAULT_CORPUS_MAX_LEN,
+        );
+
+        sp1_test::add_hash_fn_edge_cases(&mut preimages);
+
+        let digests = preimages
+            .iter()
+            .map(|preimage| {
+                let mut sha3 = Sha3_256::new();
+                sha3.update(preimage);
+
+                sha3.finalize().into()
+            })
+            .collect::<Vec<[u8; 32]>>();
+
+        // Write the number of preimages to the SP1Stdin
+        // This should be equal to the number of digests.
+        stdin.write(&preimages.len());
+        preimages.iter().for_each(|preimage| stdin.write_slice(preimage.as_slice()));
+
+        move |mut public| {
+            for digest in digests {
+                let committed = public.read::<[u8; 32]>();
+                assert_eq!(digest, committed);
+            }
         }
     }
 }
