Struct indy_crypto::cl::prover::ProofBuilder

pub struct ProofBuilder { /* fields omitted */ }

Methods

impl ProofBuilder

pub fn add_common_attribute(     &mut self,     attr_name: &str ) -> Result<(), IndyCryptoError>

Creates m_tildes for attributes that will be the same across all subproofs

pub fn add_sub_proof_request(     &mut self,     sub_proof_request: &SubProofRequest,     credential_schema: &CredentialSchema,     non_credential_schema: &NonCredentialSchema,     credential_signature: &CredentialSignature,     credential_values: &CredentialValues,     credential_pub_key: &CredentialPublicKey,     rev_reg: Option<&RevocationRegistry>,     witness: Option<&Witness> ) -> Result<(), IndyCryptoError>

Adds sub proof request to proof builder which will be used fo building of proof. Part of proof request related to a particular schema-key. The order of sub-proofs is important: both Prover and Verifier should use the same order.

Arguments

• proof_builder - Proof builder.
• sub_proof_request -Requested attributes and predicates.
• credential_schema - Credential schema.
• credential_signature - Credential signature.
• credential_values - Credential values.
• credential_pub_key - Credential public key.
• rev_reg_pub - (Optional) Revocation registry public.

#Example

use indy_crypto::cl::new_nonce;
use indy_crypto::cl::issuer::Issuer;
use indy_crypto::cl::prover::Prover;
use indy_crypto::cl::verifier::Verifier;

let mut credential_schema_builder = Issuer::new_credential_schema_builder().unwrap();
credential_schema_builder.add_attr("sex").unwrap();
let credential_schema = credential_schema_builder.finalize().unwrap();

let mut non_credential_schema_builder = Issuer::new_non_credential_schema_builder().unwrap();
non_credential_schema_builder.add_attr("master_secret").unwrap();
let non_credential_schema = non_credential_schema_builder.finalize().unwrap();

let (credential_pub_key, credential_priv_key, cred_key_correctness_proof) = Issuer::new_credential_def(&credential_schema, &non_credential_schema, false).unwrap();

let master_secret = Prover::new_master_secret().unwrap();
let credential_nonce = new_nonce().unwrap();

let mut credential_values_builder = Issuer::new_credential_values_builder().unwrap();
credential_values_builder.add_value_hidden("master_secret", &master_secret.value().unwrap()).unwrap();
credential_values_builder.add_dec_known("sex", "5944657099558967239210949258394887428692050081607692519917050011144233115103").unwrap();
let credential_values = credential_values_builder.finalize().unwrap();

let (blinded_credential_secrets, credential_secrets_blinding_factors, blinded_credential_secrets_correctness_proof) =
    Prover::blind_credential_secrets(&credential_pub_key, &cred_key_correctness_proof, &credential_values, &credential_nonce).unwrap();

let credential_issuance_nonce = new_nonce().unwrap();

let (mut credential_signature, signature_correctness_proof) =
    Issuer::sign_credential("CnEDk9HrMnmiHXEV1WFgbVCRteYnPqsJwrTdcZaNhFVW",
                            &blinded_credential_secrets,
                            &blinded_credential_secrets_correctness_proof,
                            &credential_nonce,
                            &credential_issuance_nonce,
                            &credential_values,
                            &credential_pub_key,
                            &credential_priv_key).unwrap();

Prover::process_credential_signature(&mut credential_signature,
                                     &credential_values,
                                     &signature_correctness_proof,
                                     &credential_secrets_blinding_factors,
                                     &credential_pub_key,
                                     &credential_issuance_nonce,
                                     None, None, None).unwrap();

let mut sub_proof_request_builder = Verifier::new_sub_proof_request_builder().unwrap();
sub_proof_request_builder.add_revealed_attr("sex").unwrap();
let sub_proof_request = sub_proof_request_builder.finalize().unwrap();

let mut proof_builder = Prover::new_proof_builder().unwrap();
proof_builder.add_common_attribute("master_secret").unwrap();
proof_builder.add_sub_proof_request(&sub_proof_request,
                                    &credential_schema,
                                    &non_credential_schema,
                                    &credential_signature,
                                    &credential_values,
                                    &credential_pub_key,
                                    None,
                                    None).unwrap();

pub fn finalize(&self, nonce: &Nonce) -> Result<Proof, IndyCryptoError>

Finalize proof.

Arguments

• proof_builder - Proof builder.
• nonce - Nonce.

#Example

use indy_crypto::cl::new_nonce;
use indy_crypto::cl::issuer::Issuer;
use indy_crypto::cl::prover::Prover;
use indy_crypto::cl::verifier::Verifier;

let mut credential_schema_builder = Issuer::new_credential_schema_builder().unwrap();
credential_schema_builder.add_attr("sex").unwrap();
let credential_schema = credential_schema_builder.finalize().unwrap();

let mut non_credential_schema_builder = Issuer::new_non_credential_schema_builder().unwrap();
non_credential_schema_builder.add_attr("master_secret").unwrap();
let non_credential_schema = non_credential_schema_builder.finalize().unwrap();

let (credential_pub_key, credential_priv_key, cred_key_correctness_proof) = Issuer::new_credential_def(&credential_schema, &non_credential_schema, false).unwrap();

let master_secret = Prover::new_master_secret().unwrap();

let mut credential_values_builder = Issuer::new_credential_values_builder().unwrap();
credential_values_builder.add_value_hidden("master_secret", &master_secret.value().unwrap());
credential_values_builder.add_dec_known("sex", "5944657099558967239210949258394887428692050081607692519917050011144233115103").unwrap();
let credential_values = credential_values_builder.finalize().unwrap();

let credential_nonce = new_nonce().unwrap();

let credential_nonce = new_nonce().unwrap();
let (blinded_credential_secrets, credential_secrets_blinding_factors, blinded_credential_secrets_correctness_proof) =
    Prover::blind_credential_secrets(&credential_pub_key, &cred_key_correctness_proof, &credential_values, &credential_nonce).unwrap();

let credential_issuance_nonce = new_nonce().unwrap();

let (mut credential_signature, signature_correctness_proof) =
    Issuer::sign_credential("CnEDk9HrMnmiHXEV1WFgbVCRteYnPqsJwrTdcZaNhFVW",
                            &blinded_credential_secrets,
                            &blinded_credential_secrets_correctness_proof,
                            &credential_nonce,
                            &credential_issuance_nonce,
                            &credential_values,
                            &credential_pub_key,
                            &credential_priv_key).unwrap();

Prover::process_credential_signature(&mut credential_signature,
                                     &credential_values,
                                     &signature_correctness_proof,
                                     &credential_secrets_blinding_factors,
                                     &credential_pub_key,
                                     &credential_issuance_nonce,
                                     None, None, None).unwrap();

let mut sub_proof_request_builder = Verifier::new_sub_proof_request_builder().unwrap();
sub_proof_request_builder.add_revealed_attr("sex").unwrap();
let sub_proof_request = sub_proof_request_builder.finalize().unwrap();

let mut proof_builder = Prover::new_proof_builder().unwrap();
proof_builder.add_common_attribute("master_secret").unwrap();
proof_builder.add_sub_proof_request(&sub_proof_request,
                                    &credential_schema,
                                    &non_credential_schema,
                                    &credential_signature,
                                    &credential_values,
                                    &credential_pub_key,
                                    None,
                                    None).unwrap();

let proof_request_nonce = new_nonce().unwrap();
let _proof = proof_builder.finalize(&proof_request_nonce).unwrap();

Trait Implementations

impl Debug for ProofBuilder

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.