blind.rs build up, deving signer.rs

Author: klizz111

bbs/src/bbs_bn254/user.rs bbs/src/bbs_bn254/blind.rsbbs/src/bbs_bn254/user.rs renamed to bbs/src/bbs_bn254/blind.rs

@@ -1,3 +1,6 @@
+//! User functions impl for some user-side operations, including:
+//! blind, unblind and proof of knowledge of committed values.
+
 use ark_bn254::{G1Affine as G1, G1Projective as G1Projective, Fr as Scalar};
 use ark_ec::CurveGroup;
 use ark_ff::PrimeField;
@@ -7,20 +10,19 @@ use sha2::{Digest, Sha256};
 
 use crate::bbs_bn254::structs::{BlindedCommitment, CommitmentProof, Parameters};
 
-/// User functions impl for BBS+ signatures over BN254.
-/// Includes blind, unblind, proofgen
-
 /// Create a blinded commitment for a list of messages.
 /// Returns `Err` if message length exceeds available parameters.
-pub fn blind(params: &Parameters, messages: &[Scalar]) -> Result<BlindedCommitment, &'static str> {
+/// data with index at and behind `blind_index` will be blinded, should be between 1 and messages.len() - 1
+pub fn blind(params: &Parameters, messages: &[Scalar], blind_index: usize) -> Result<BlindedCommitment, &'static str> {
 	let mut rng = ark_std::test_rng();
-	blind_with_rng(params, messages, &mut rng)
+	blind_with_rng(params, messages, blind_index, &mut rng)
 }
 
 /// Create a blinded commitment using a caller-supplied RNG.
 pub fn blind_with_rng<R: RngCore>(
 	params: &Parameters,
 	messages: &[Scalar],
+	blind_index: usize,
 	rng: &mut R,
 ) -> Result<BlindedCommitment, &'static str> {
 	if messages.len() > params.L {
@@ -29,11 +31,17 @@ pub fn blind_with_rng<R: RngCore>(
 	if params.H.len() < messages.len() + 1 {
 		return Err("parameters do not include enough message base points");
 	}
+	if blind_index == 0 || blind_index >= messages.len() {
+		return Err("invalid blind index");
+	}
 
+	// calc r*H_1
 	let blinding_factor = Scalar::rand(rng);
 	let mut commitment = params.H[0] * blinding_factor;
-	for (i, m) in messages.iter().enumerate() {
-		commitment += params.H[i + 1] * m;
+
+	// calc m_j*H_{j+1}
+	for j in (blind_index - 1)..messages.len() {
+		commitment += params.H[j + 1] * messages[j];		
 	}
 
 	Ok(BlindedCommitment {
@@ -140,7 +148,7 @@ mod tests {
 		let messages = vec![Scalar::from(1u64), Scalar::from(2u64), Scalar::from(3u64)];
 
 		let mut rng = ark_std::test_rng();
-		let commitment = blind_with_rng(&params, &messages, &mut rng).unwrap();
+		let commitment = blind_with_rng(&params, &messages, 1, &mut rng).unwrap();
 		let proof = commitment_pok_prove_with_rng(&params, &commitment, &messages, &mut rng).unwrap();
 
 		let ok = commitment_pok_verify(&params, &commitment, &proof).unwrap();

bbs/src/bbs_bn254/keygen.rs

@@ -1,5 +1,5 @@
-/// This is the key generation module for the BBS+ signature scheme over the BN254 curve.
-/// Provides functions to generate secret keys, public keys, and key pairs for signing and verification.
+//! This is the key generation module for the BBS+ signature scheme over the BN254 curve.
+//! Provides functions to generate secret keys, public keys, and key pairs for signing and verification.
 
 use ark_bn254::{G1Affine as G1, G2Affine as G2, Fr as Scalar};
 use ark_ec::{AffineRepr, CurveGroup};

bbs/src/bbs_bn254/mod.rs

@@ -1,10 +1,11 @@
 pub mod structs;
 pub mod keygen;
-pub mod user;
+pub mod blind;
+pub mod signer;
 
 pub use keygen::{keygen, keygen_with_rng};
 pub use structs::{Parameters, PrivateKey, PublicKey};
-pub use user::{
+pub use blind::{
 	blind,
 	blind_with_rng,
 	commitment_pok_prove,

bbs/src/bbs_bn254/signer.rs

@@ -0,0 +1,43 @@
+//! Impl signing related functions.
+
+use ark_bn254::{G1Affine as G1, G2Affine as G2, Fr as Scalar};
+use ark_ec::CurveGroup;
+use ark_ff::PrimeField;
+use ark_std::{UniformRand, rand::RngCore, test_rng};
+
+use crate::bbs_bn254::{Parameters, PrivateKey, structs::Signature};
+
+pub fn sign_no_blind(
+    params: &Parameters,
+    sk: &PrivateKey,
+    messages: &[Scalar]
+) -> Result<Signature, &'static str> {
+    let mut rng = test_rng();
+    sign_no_blind_with_rng(params, sk, messages, rng)
+}
+
+pub fn sign_no_blind_with_rng<R: RngCore>(
+    params: &Parameters,
+    sk: &PrivateKey,
+    messages: &[Scalar],
+    rng: &mut R
+) -> Result<Signature, &'static str> {
+    // Sample random scalars e and s
+    let e = Scalar::rand(rng);
+    let s = Scalar::rand(rng);
+
+    // Constrruct Commitment C = G_1 + s*H_0 + m_1*H_1 + ... + m_L*H_L
+    let mut c = params.g1 + params.H[0] * s;
+    for (j, m_j) in messages.iter().enumerate() {
+        if j >= params.L {
+            return Err("message length exceeds parameters");
+        }
+        c += params.H[j + 1] * m_j;
+    }
+
+    // calc (x + e) ^ (-1)
+    let mut tmp = sk.x + e;
+    tmp = tmp.inverse().ok_or("failed to compute inverse")?;
+    
+    Ok(())
+}

bbs/src/bbs_bn254/structs.rs

@@ -1,3 +1,5 @@
+//! Define the core data structures here.
+
 #![allow(non_snake_case, dead_code)]
 
 use ark_bn254::{G1Affine as G1, G2Affine as G2, Fr as Scalar};

bbs/src/lib.rs

@@ -1 +1,3 @@
+//! BBS signature scheme implementation in Rust.
+//! Using bn254 curve.
 pub mod bbs_bn254;