public bool Verify(VerifierPresentationProtocolParameters verifier1, int attributeIndexForVerifier1, VerifierPresentationProtocolParameters verifier2, int attributeIndexForVerifier2)
        {
            if (!verifier1.IP.Gq.Equals(verifier2.IP.Gq))
            {
                throw new ArgumentException("both verifiers must share the same group");
            }

            // Create ClosedUProveTokens
            ClosedUProveToken token1 = new ClosedUProveToken(verifier1);
            ClosedUProveToken token2 = new ClosedUProveToken(verifier2);

            // Verify proof
            VerifierEqualityParameters eqVerifier = new VerifierEqualityParameters(
                token1,
                attributeIndexForVerifier1,
                token2,
                attributeIndexForVerifier2,
                new CryptoParameters(verifier1.IP));

            return(this.Verify(eqVerifier));
        }
예제 #2
0
        /// <summary>
        /// Verifies this proof that the committed values are valid Pedersen Commitments to token attributes.
        /// </summary>
        /// <param name="verifier">Array of verifier token parameters.</param>
        /// <param name="attributeIndices">Target attribute in each token.</param>
        /// <param name="committedValues">Array of Pedersen Commitment values.</param>
        /// <returns></returns>
        public bool Verify(VerifierPresentationProtocolParameters [] verifier, int [] attributeIndices)
        {
            if ((verifier == null) || (verifier.Length == 0))
            {
                throw new ArgumentException("First argument should be an array of at least one element.");
            }
            if (!UProveIntegrationProof.AreTokensCompatible(verifier))
            {
                throw new ArgumentException("All tokens must use same group.");
            }

            if ((attributeIndices == null) || (attributeIndices.Length != verifier.Length))
            {
                throw new ArgumentNullException("Second argument must be an array of the same length as first argument.");
            }

            if ((this.PedersenCommitmentValues == null) || (this.PedersenCommitmentValues.Length != verifier.Length))
            {
                throw new ArgumentNullException("Third argument must be an array of the same length as first argument.");
            }

            EqualityMap map = new EqualityMap();

            IStatement[]        statements = new IStatement[verifier.Length * 2];
            ClosedUProveToken[] tokens     = new ClosedUProveToken[verifier.Length];
            for (int i = 0; i < tokens.Length; ++i)
            {
                // create uprove token and add target attribute to map
                statements[2 * i] = new ClosedUProveToken(verifier[i]);
                map.Add(new PrettyName("token", 2 * i), new DoubleIndex(i, attributeIndices[i]));

                // add pedersen commitment to witness list, and add to map
                statements[2 * i + 1] = new ClosedPedersenCommitment(verifier[i].IP, this.PedersenCommitmentValues[i]);
                map.Add(new PrettyName("token", 2 * i + 1), new DoubleIndex(i, 0));
            }

            VerifierEqualityParameters eqVerifier = new VerifierEqualityParameters(statements, map, new CryptoParameters(verifier[0].IP));

            return(this.TokenCommitmentEqualityProof.Verify(eqVerifier));
        }