submit the code

Author: weikengchen

.gitignore

@@ -12,3 +12,5 @@ Cargo.lock
 
 # MSVC Windows builds of rustc generate these, which store debugging information
 *.pdb
+
+.idea

Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "ecdsa0-example"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+anyhow = "1.0"
+ecdsa0-methods = { path = "methods" }
+k256 = { version = "0.13", features = ["serde"] }
+rand_core = "0.6.4"
+risc0-zkvm = { git = "https://github.com/l2iterative/risc0/", branch="no-rust-runtime-for-host" }
+serde = "1.0"
+bytemuck = "1.14.0"
+
+[features]
+cuda = ["risc0-zkvm/cuda"]
+default = []
+metal = ["risc0-zkvm/metal"]
+prove = ["risc0-zkvm/prove"]

README.md

@@ -1,2 +1,7 @@
-# ecdsa0-example
-Example ECDSA to test distributed proof generation on Ray for RISC Zero
+# ECDSA example
+
+This is a copy-of-paste of the code in RISC0 example repo, for the pure purpose of changing the dependencies.
+
+https://github.com/risc0/risc0/blob/main/examples/ecdsa/methods/guest/src/bin/ecdsa_verify.rs
+
+We may make additional edits to test larger quantity of ECDSA signature verification.

methods/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "ecdsa0-methods"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+
+
+[build-dependencies]
+risc0-build = { git = "https://github.com/l2iterative/risc0/", branch="no-rust-runtime-for-host" }
+
+[package.metadata.risc0]
+methods = ["guest"]

methods/build.rs

@@ -0,0 +1,17 @@
+// Copyright 2024 RISC Zero, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+fn main() {
+    risc0_build::embed_methods();
+}

methods/guest/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "ecdsa-verify"
+version = "0.1.0"
+edition = "2021"
+
+[workspace]
+
+[dependencies]
+risc0-zkvm = { git = "https://github.com/l2iterative/risc0/", branch="no-rust-runtime-for-host", default_features = false, features = ["std"] }
+hex-literal = "0.4"
+k256 = { version = "=0.13.1", features = ["arithmetic", "serde", "expose-field", "std", "ecdsa"], default_features = false }
+
+[patch.crates-io]
+# Placing these patch statement in the workspace Cargo.toml will add RISC Zero SHA-256 and bigint
+# multiplication accelerator support for all downstream usages of the following crates.
+sha2 = { git = "https://github.com/risc0/RustCrypto-hashes", tag = "sha2-v0.10.6-risczero.0" }
+k256 = { git = "https://github.com/risc0/RustCrypto-elliptic-curves", tag = "k256/v0.13.1-risczero.1"  }
+crypto-bigint = { git = "https://github.com/risc0/RustCrypto-crypto-bigint", tag = "v0.5.2-risczero.0" }
+
+[profile.release]
+# Empirically observed to result in the best performance for this binary (in particular, better than
+# "fat"). It's often a good idea to experiment with different optimization levels and options.
+lto = "thin"

methods/guest/src/main.rs

@@ -0,0 +1,33 @@
+// Copyright 2024 RISC Zero, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use k256::{
+    ecdsa::{signature::Verifier, Signature, VerifyingKey},
+    EncodedPoint,
+};
+use risc0_zkvm::guest::env;
+
+fn main() {
+    // Decode the verifying key, message, and signature from the inputs.
+    let (encoded_verifying_key, message, signature): (EncodedPoint, Vec<u8>, Signature) =
+        env::read();
+    let verifying_key = VerifyingKey::from_encoded_point(&encoded_verifying_key).unwrap();
+
+    // Verify the signature, panicking if verification fails.
+    verifying_key
+            .verify(&message, &signature)
+            .expect("ECDSA signature verification failed");
+
+    env::commit(&(encoded_verifying_key, message));
+}

methods/src/lib.rs

@@ -0,0 +1,15 @@
+// Copyright 2024 RISC Zero, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+include!(concat!(env!("OUT_DIR"), "/methods.rs"));

src/main.rs

@@ -0,0 +1,70 @@
+// Copyright 2024 RISC Zero, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use ecdsa0_methods::{ECDSA_VERIFY_ELF, ECDSA_VERIFY_ID};
+use k256::{
+    ecdsa::{signature::Signer, Signature, SigningKey, VerifyingKey},
+    EncodedPoint,
+};
+use rand_core::OsRng;
+use risc0_zkvm::serde::to_vec;
+use risc0_zkvm::{default_prover, ExecutorEnv, Receipt};
+
+/// Given an secp256k1 verifier key (i.e. public key), message and signature,
+/// runs the ECDSA verifier inside the zkVM and returns a receipt, including a
+/// journal and seal attesting to the fact that the prover knows a valid
+/// signature from the committed public key over the committed message.
+fn prove_ecdsa_verification(
+    verifying_key: &VerifyingKey,
+    message: &[u8],
+    signature: &Signature,
+) -> Receipt {
+    let input = (verifying_key.to_encoded_point(true), message, signature);
+    let input_vec = to_vec(&input).unwrap();
+    let input_bytes: &[u8] = bytemuck::cast_slice(&input_vec);
+
+    println!("input_bytes: {:?}", input_bytes);
+
+    let env = ExecutorEnv::builder()
+        .write_slice(&input_bytes)
+        .build()
+        .unwrap();
+
+    // Obtain the default prover.
+    let prover = default_prover();
+
+    // Produce a receipt by proving the specified ELF binary.
+    prover.prove(env, ECDSA_VERIFY_ELF).unwrap()
+}
+
+fn main() {
+    // Generate a random secp256k1 keypair and sign the message.
+    let signing_key = SigningKey::random(&mut OsRng); // Serialize with `::to_bytes()`
+    let message = b"This is a message that will be signed, and verified within the zkVM";
+    let signature: Signature = signing_key.sign(message);
+
+    // Run signature verified in the zkVM guest and get the resulting receipt.
+    let receipt = prove_ecdsa_verification(signing_key.verifying_key(), message, &signature);
+
+    // Verify the receipt and then access the journal.
+    receipt.verify(ECDSA_VERIFY_ID).unwrap();
+    let (receipt_verifying_key, receipt_message): (EncodedPoint, Vec<u8>) =
+        receipt.journal.decode().unwrap();
+
+    println!(
+        "Verified the signature over message {:?} with key {}",
+        std::str::from_utf8(&receipt_message[..]).unwrap(),
+        receipt_verifying_key,
+    );
+}