Skip to content

Commit cb98f49

Browse files
DreamWuGitDreamWuGit
committed
comment out p256 crate test
1 parent 9092084 commit cb98f49

File tree

2 files changed

+125
-156
lines changed

2 files changed

+125
-156
lines changed

‎Cargo.lock

+2-2
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

‎zkevm-circuits/src/sig_circuit/test.rs

+123-154
Original file line numberDiff line numberDiff line change
@@ -240,149 +240,19 @@ fn p256_sign_verify() {
240240
use super::utils::LOG_TOTAL_NUM_ROWS;
241241
use crate::sig_circuit::utils::MAX_NUM_SIG;
242242
use halo2_proofs::halo2curves::bn256::Fr;
243-
use p256::ecdsa::signature::hazmat::{PrehashSigner, PrehashVerifier};
244-
use p256::ecdsa::signature::DigestSigner;
245-
use p256::ecdsa::{
246-
signature::Signer, signature::Verifier, Signature, SigningKey, VerifyingKey,
247-
};
248-
use p256::{
249-
elliptic_curve::generic_array::GenericArray, elliptic_curve::Curve, AffinePoint, NistP256,
250-
};
251243
use rand::SeedableRng;
252244
use rand_xorshift::XorShiftRng;
253245
use sha3::{Digest, Keccak256};
254-
//use hex_literal::hex;
255-
use ff::FromUniformBytes;
256-
use ff::PrimeField;
257-
use halo2_proofs::arithmetic::CurveAffine;
258-
use halo2_proofs::halo2curves::group::GroupEncoding;
259-
use halo2_proofs::halo2curves::serde::SerdeObject;
260-
use num::{BigUint, Num};
261-
use p256::elliptic_curve::point::AffineCoordinates;
262-
use p256::pkcs8::EncodePublicKey;
263-
use p256::PublicKey;
264-
265246
let mut rng = XorShiftRng::seed_from_u64(10000);
266247

267-
// p256 crate generate signature
268-
// {
269-
// let mut signatures = Vec::new();
270-
// let msg = gen_msg(&mut rng);
271-
272-
// let msg_hash_bytes: [u8; 32] = Keccak256::digest(&msg)
273-
// .as_slice()
274-
// .to_vec()
275-
// .try_into()
276-
// .expect("hash length isn't 32 bytes");
277-
// let msg_hash = secp256r1::Fq::from_bytes(&msg_hash_bytes).unwrap();
278-
// let (sk, pk) = gen_key_pair_r1(&mut rng);
279-
// println!("sk_fq raw bytes {:?}", sk.to_raw_bytes());
280-
// println!("sk_fq to_bytes {:?}", sk.to_bytes()); // = to_repr
281-
282-
// println!("pk_fp.x {:?}", pk.x.to_bytes());
283-
284-
// let (r, s, v) = sign_r1_with_rng(&mut rng, sk, msg_hash);
285-
// // signatures.push(SignData {
286-
// // signature: (r, s, v),
287-
// // pk,
288-
// // msg: msg.into(),
289-
// // msg_hash,
290-
// // });
291-
292-
// let signing_key = SigningKey::from_slice(&sk.to_raw_bytes()).expect("get private from sk");
293-
// println!("signing_key = {:?}", signing_key.to_bytes());
294-
// let verifying_key = signing_key.verifying_key();
295-
// // let vk= verifying_key.to_encoded_point(false);
296-
// println!("verifying_key = {:?}", verifying_key);
297-
298-
// let signature: Signature = signing_key
299-
// .sign_prehash(&msg_hash_bytes)
300-
// .expect("sign failed");
301-
// let sig_bytes = signature.to_bytes();
302-
// let mut sig_r_bytes: [u8; 32] = sig_bytes[..32].try_into().expect("failed ");
303-
// let mut sig_s_bytes: [u8; 32] = sig_bytes[32..64].try_into().expect("failed ");
304-
// // let r = secp256r1::Fq::from_bytes_le(&sig_r_bytes);
305-
// // let s = secp256r1::Fq::from_bytes_le(&sig_s_bytes);
306-
// sig_r_bytes.reverse();
307-
// sig_s_bytes.reverse();
308-
// // let r = secp256r1::Fq::from_bytes(&sig_r_bytes).unwrap();
309-
// // let s = secp256r1::Fq::from_bytes(&sig_s_bytes).unwrap();
310-
// // put into sig queue for sig circuit verification
311-
// // hack: custom pk
312-
// fn fe_from_str(string: impl AsRef<str>) -> secp256r1::Fp {
313-
// let string = string.as_ref();
314-
// let oct = if let Some(hex) = string.strip_prefix("0x") {
315-
// BigUint::from_str_radix(hex, 16).unwrap().to_string()
316-
// } else {
317-
// string.to_string()
318-
// };
319-
320-
// secp256r1::Fp::from_str_vartime(&oct).unwrap()
321-
// }
322-
// // let x = fe_from_str("0x972eb906f4c9315a6bd0e3cf80de7faf5c7d924bf9db641e952065952bbda42c");
323-
// // let y = fe_from_str("0x548448473cfb708b0e0835a75fdb690a01e2023ea7f3f17c0fb5dea77086996a");
324-
325-
// let public_key: PublicKey = verifying_key.into();
326-
// let pubkey_affine = public_key.as_affine();
327-
// let affine_x = pubkey_affine.x();
328-
329-
// let mut field_x: [u8; 32] = pubkey_affine.x().into();
330-
// field_x.reverse();
331-
// let x_fp = secp256r1::Fp::from_bytes(&field_x).unwrap();
332-
// println!("x_fp : {:?}", x_fp.to_bytes());
333-
334-
// // calculate x^3 + ax + b (mod p)
335-
// let x3 = x_fp.square() * x_fp;
336-
// let ax = secp256r1::Secp256r1Affine::a() * x_fp;
337-
// let y2 = x3 + ax + secp256r1::Secp256r1Affine::b();
338-
// let y = y2.sqrt().unwrap();
339-
340-
// //let pk = Secp256r1Affine::from_xy(x_fp, y).unwrap();
341-
342-
// signatures.push(SignData {
343-
// signature: (r, s, 0),
344-
// pk,
345-
// msg: msg.into(),
346-
// msg_hash,
347-
// });
348-
349-
// println!("recover y: {:?}", y);
350-
// println!("new pk : {:?}", pk);
351-
// let mut r_bytes_1 = r.to_bytes();
352-
// let mut s_bytes_1 = s.to_bytes();
353-
// r_bytes_1.reverse();
354-
// s_bytes_1.reverse();
355-
356-
// let signature2 = Signature::from_slice([r_bytes_1, s_bytes_1].concat().as_slice())
357-
// .expect("no error");
358-
// println!(
359-
// "signature {:?} ",
360-
// signature.to_bytes(),
361-
// );
362-
// println!(
363-
// "signature2 {:?}",
364-
// signature2.to_bytes(),
365-
// );
366-
367-
// let is_valid = verifying_key
368-
// .verify_prehash(&msg_hash_bytes, &signature2)
369-
// .is_ok();
370-
// println!("Signature is valid: {}", is_valid);
371-
372-
// let k = LOG_TOTAL_NUM_ROWS as u32;
373-
// run::<Fr>(k, 1, vec![], signatures);
374-
375-
// log::debug!("end of testing for msg_hash = 0");
376-
// }
377-
378248
// msg_hash == 0
379249
{
380250
log::debug!("testing for msg_hash = 0");
381251
let mut signatures = Vec::new();
382252

383253
let (sk, pk) = gen_key_pair_r1(&mut rng);
384254
let msg = gen_msg(&mut rng);
385-
let msg_hash = secp256r1::Fq::zero(); // 257 ok, 250 not ok
255+
let msg_hash = secp256r1::Fq::zero();
386256
println!("original pk {:?}", pk);
387257

388258
let (r, s, v) = sign_r1_with_rng(&mut rng, sk, msg_hash);
@@ -403,30 +273,29 @@ fn p256_sign_verify() {
403273
}
404274

405275
// msg_hash == 1
406-
// {
407-
// log::debug!("testing for msg_hash = 1");
408-
// let mut signatures = Vec::new();
409-
410-
// let (sk, pk) = gen_key_pair_r1(&mut rng);
411-
// let msg = gen_msg(&mut rng);
412-
// let msg_hash = secp256r1::Fq::one();
413-
// let (r, s, v) = sign_r1_with_rng(&mut rng, sk, msg_hash);
414-
// signatures.push(SignData {
415-
// signature: (r, s, v),
416-
// pk,
417-
// msg: msg.into(),
418-
// msg_hash,
419-
// });
420-
421-
// let k = LOG_TOTAL_NUM_ROWS as u32;
422-
// run::<Fr>(k, 1, vec![], signatures);
423-
424-
// log::debug!("end of testing for msg_hash = 1");
425-
// }
276+
{
277+
log::debug!("testing for msg_hash = 1");
278+
let mut signatures = Vec::new();
279+
280+
let (sk, pk) = gen_key_pair_r1(&mut rng);
281+
let msg = gen_msg(&mut rng);
282+
let msg_hash = secp256r1::Fq::one();
283+
let (r, s, v) = sign_r1_with_rng(&mut rng, sk, msg_hash);
284+
signatures.push(SignData {
285+
signature: (r, s, v),
286+
pk,
287+
msg: msg.into(),
288+
msg_hash,
289+
});
290+
291+
let k = LOG_TOTAL_NUM_ROWS as u32;
292+
run::<Fr>(k, 1, vec![], signatures);
293+
294+
log::debug!("end of testing for msg_hash = 1");
295+
}
426296

427297
// random msg_hash
428-
// let max_sigs = [1, 16, MAX_NUM_SIG]; // enable this line after testing
429-
let max_sigs = [1];
298+
let max_sigs = [1, 16, MAX_NUM_SIG];
430299

431300
for max_sig in max_sigs.iter() {
432301
log::debug!("testing for {} signatures", max_sig);
@@ -440,7 +309,7 @@ fn p256_sign_verify() {
440309
.try_into()
441310
.expect("hash length isn't 32 bytes");
442311
let msg_hash = secp256r1::Fq::from_bytes(&msg_hash).unwrap();
443-
//let msg_hash = secp256r1::Fq::one();
312+
444313
let (r, s, v) = sign_r1_with_rng(&mut rng, sk, msg_hash);
445314
signatures.push(SignData {
446315
signature: (r, s, v),
@@ -457,6 +326,106 @@ fn p256_sign_verify() {
457326
}
458327
}
459328

329+
// TODO: this test fail due to signature/pubkey representation(sec1 encoding/compress etc)
330+
// need to decode correct bytes and re-construct signature/pubkey for testing
331+
// test rust p256 crate apis: sign & verify
332+
// #[test]
333+
// fn p256_crate_sig_verify() {
334+
// use super::utils::LOG_TOTAL_NUM_ROWS;
335+
// use crate::sig_circuit::utils::MAX_NUM_SIG;
336+
// use halo2_proofs::halo2curves::bn256::Fr;
337+
// use p256::ecdsa::signature::hazmat::{PrehashSigner, PrehashVerifier};
338+
// use p256::ecdsa::{
339+
// signature::Signer, signature::Verifier, Signature, SigningKey, VerifyingKey,
340+
// };
341+
// use rand::SeedableRng;
342+
// use rand_xorshift::XorShiftRng;
343+
// use sha3::{Digest, Keccak256};
344+
// use ff::FromUniformBytes;
345+
// use ff::PrimeField;
346+
// use halo2_proofs::arithmetic::CurveAffine;
347+
// use halo2_proofs::halo2curves::group::GroupEncoding;
348+
// use halo2_proofs::halo2curves::serde::SerdeObject;
349+
// use p256::elliptic_curve::point::AffineCoordinates;
350+
// use p256::pkcs8::EncodePublicKey;
351+
// use p256::PublicKey;
352+
353+
// let mut rng = XorShiftRng::seed_from_u64(10000);
354+
355+
// // p256 crate generate signature
356+
// {
357+
// let mut signatures = Vec::new();
358+
// let msg = gen_msg(&mut rng);
359+
360+
// let msg_hash_bytes: [u8; 32] = Keccak256::digest(&msg)
361+
// .as_slice()
362+
// .to_vec()
363+
// .try_into()
364+
// .expect("hash length isn't 32 bytes");
365+
// let msg_hash = secp256r1::Fq::from_bytes(&msg_hash_bytes).unwrap();
366+
// let (sk, pk) = gen_key_pair_r1(&mut rng);
367+
// println!("sk_fq raw bytes {:?}", sk.to_raw_bytes());
368+
369+
// let signing_key = SigningKey::from_slice(&sk.to_raw_bytes()).expect("get private from sk");
370+
// println!("signing_key = {:?}", signing_key.to_bytes());
371+
// let verifying_key = signing_key.verifying_key();
372+
// // let vk= verifying_key.to_encoded_point(false);
373+
// println!("verifying_key = {:?}", verifying_key);
374+
375+
// let signature: Signature = signing_key
376+
// .sign_prehash(&msg_hash_bytes)
377+
// .expect("sign failed");
378+
// let sig_bytes = signature.to_bytes();
379+
// let mut sig_r_bytes: [u8; 32] = sig_bytes[..32].try_into().expect("failed ");
380+
// let mut sig_s_bytes: [u8; 32] = sig_bytes[32..64].try_into().expect("failed ");
381+
// let r = secp256r1::Fq::from_raw_bytes(&sig_r_bytes).unwrap();
382+
// let s = secp256r1::Fq::from_raw_bytes(&sig_s_bytes).unwrap();
383+
// // hack: custom pk
384+
385+
// let public_key: PublicKey = verifying_key.into();
386+
// let pubkey_affine = public_key.as_affine();
387+
// let affine_x = pubkey_affine.x();
388+
389+
// let mut field_x: [u8; 32] = pubkey_affine.x().into();
390+
// let x_fp = secp256r1::Fp::from_raw_bytes_unchecked(&field_x);
391+
// // println!("x_fp : {:?}", x_fp.to_bytes());
392+
// // can not get y from pubkey_affine direclty.
393+
// // calculate x^3 + ax + b (mod p)
394+
// let x3 = x_fp.square() * x_fp;
395+
// let ax = secp256r1::Secp256r1Affine::a() * x_fp;
396+
// let y2 = x3 + ax + secp256r1::Secp256r1Affine::b();
397+
// // check if need negative form
398+
// let y = y2.sqrt().unwrap();
399+
400+
// let pk = Secp256r1Affine::from_xy(x_fp, y).unwrap();
401+
402+
// signatures.push(SignData {
403+
// signature: (r, s, 0),
404+
// pk,
405+
// msg: msg.into(),
406+
// msg_hash,
407+
// });
408+
409+
// let mut r_bytes_1 = r.to_bytes();
410+
// let mut s_bytes_1 = s.to_bytes();
411+
// r_bytes_1.reverse();
412+
// s_bytes_1.reverse();
413+
414+
// let signature2 = Signature::from_slice([r_bytes_1, s_bytes_1].concat().as_slice())
415+
// .expect("no error");
416+
417+
// let is_valid = verifying_key
418+
// .verify_prehash(&msg_hash_bytes, &signature2)
419+
// .is_ok();
420+
// println!("Signature is valid: {}", is_valid);
421+
422+
// let k = LOG_TOTAL_NUM_ROWS as u32;
423+
// run::<Fr>(k, 1, vec![], signatures);
424+
425+
// log::debug!("end of testing for msg_hash = 0");
426+
// }
427+
// }
428+
460429
// test for both secp256k1 and secp256r1 signatures
461430
#[test]
462431
fn sign_verify() {

0 commit comments

Comments
 (0)