public void EQEndToEndTest1()
{
// create two pedersen commitments to 1
DLRepOfGroupElement[] dlarray = new DLRepOfGroupElement[2]
{
new PedersenCommitment(_parameters.FieldZq.One, _parameters),
new PedersenCommitment(_parameters.FieldZq.One, _parameters)
};
PrettyName alpha = new PrettyName("alpha", 0);
DoubleIndex d1 = new DoubleIndex(0, 0); // dlarray[0].BaseAtIndex(0)
DoubleIndex d2 = new DoubleIndex(1, 0); // dlarray[1].BaseAtIndex(0)
EqualityMap map = new EqualityMap();
map.Add(alpha, d1);
map.Add(alpha, d2);
int index;
Assert.IsTrue(map.TryRetrieveIntIndex(d1, out index));
Assert.AreEqual(0, index);
Assert.IsTrue(map.TryRetrieveIntIndex(d2, out index));
Assert.AreEqual(0, index);
ProverEqualityParameters peParameters = new ProverEqualityParameters(
dlarray,
map,
_parameters);
EqualityProof proof = new EqualityProof(peParameters);
Assert.IsTrue(proof.Verify(peParameters));
}
public void EqualsTest()
{
int replen1 = 12;
int replen2 = 11;
for (int paramIndex = 0; paramIndex < _parameters.Length; ++paramIndex)
{
FieldZqElement[] exponents1 = _parameters[paramIndex].FieldZq.GetRandomElements(replen1, true);
FieldZqElement[] exponents2 = _parameters[paramIndex].FieldZq.GetRandomElements(replen2, true);
DLRepOfGroupElement dl1 = new DLRepOfGroupElement(exponents1, _parameters[paramIndex]);
DLRepOfGroupElement dl2 = new DLRepOfGroupElement(exponents1, _parameters[paramIndex]);
DLRepOfGroupElement dl3 = new DLRepOfGroupElement(exponents2, _parameters[paramIndex]);
Assert.IsTrue(dl1.Equals(dl1), "dl1 should equal itself");
Assert.IsTrue(dl1.Equals(dl2), "dl1 should equal dl2");
Assert.IsTrue(dl2.Equals(dl1), "dl2 should equal dl1");
Assert.IsFalse(dl2.Equals(dl3), "dl2 should not equal dl3");
Assert.IsFalse(dl3.Equals(dl2), "dl3 should not equal dl2");
Assert.IsFalse(dl3.Equals(exponents1[0]), "wrong class input!");
DLRepOfGroupElement nulldl = new DLRepOfGroupElement();
Assert.IsFalse(dl1.Equals(nulldl), "not equal to nulldl");
Assert.IsFalse(nulldl.Equals(dl1), "nulldl not equal to dl1");
Assert.IsTrue(nulldl.Equals(nulldl), "nulldl equal to itself");
GroupElement[] bases = new GroupElement[replen1];
for (int i = 0; i < bases.Length; ++i)
{
bases[i] = _parameters[paramIndex].Group.Identity;
}
DLRepOfGroupElement dl4 = new DLRepOfGroupElement(bases, exponents1, _parameters[paramIndex].Group);
Assert.IsFalse(dl1.Equals(dl4), "dl1 and dl4 different due to bases");
Assert.IsFalse(dl4.Equals(dl1), "dl4 and dl1 different due to bases");
}
}
public void PPSerializationTest()
{
int paramIndex = 4;
ProofParameters original = new ProofParameters(StaticHelperClass.ParameterArray[paramIndex]);
DLRepOfGroupElement [] witnesses = new DLRepOfGroupElement[10];
GroupElement[] bases = new GroupElement[5] {
original.Generators[0],
original.Generators[1],
original.Generators[2],
original.Generators[3],
original.Generators[4]
};
for (int i = 0; i < 10; ++i)
{
FieldZqElement[] exponents = StaticHelperClass.GenerateRandomExponents(5, paramIndex);
witnesses[i] = new DLRepOfGroupElement(bases, exponents, original.Group);
}
original.setProverParameters(witnesses);
string serializedParams = CryptoSerializer.Serialize <ProofParameters>(original);
ProofParameters deserialized = CryptoSerializer.Deserialize <ProofParameters>(serializedParams);
Assert.AreEqual(original.ProverParameters, deserialized.ProverParameters, "ProverParameters field improperly deserialized");
StaticHelperClass.AssertArraysAreEqual(original.Generators, deserialized.Generators, "Generators.");
StaticHelperClass.AssertArraysAreEqual(original.PublicValues, deserialized.PublicValues, "Public Values.");
StaticHelperClass.AssertArraysAreEqual(original.Witnesses, deserialized.Witnesses, "Witnesses");
Assert.AreEqual(original.Group.G, deserialized.Group.G, "Group.group.g");
}
public void DLGetHashCodeTest()
{
FieldZqElement[] exponents = StaticHelperClass.GenerateRandomExponents(8, 1);
DLRepOfGroupElement dl = new DLRepOfGroupElement(exponents, _parameters[1]);
Assert.AreEqual(dl.BaseAtIndex(0).GetHashCode(), dl.GetHashCode());
}
public void NullConstructorTest()
{
DLRepOfGroupElement dl = new DLRepOfGroupElement();
Assert.AreEqual(0, dl.RepresentationLength, "dl.representation length should be 0");
Assert.IsNull(dl.Value, "Value is null");
}
public void CSDLRepArrayTestWithGroup()
{
DLRepOfGroupElement[] input = StaticHelperClass.GenerateRandomDLRepOfGroupElementArray(10, 7, this.paramIndex);
FieldZqElement[][] inputExponents = new FieldZqElement[10][];
for (int dlIndex = 0; dlIndex < 10; ++dlIndex)
{
inputExponents[dlIndex] = new FieldZqElement[7];
for (int exponentIndex = 0; exponentIndex < 7; ++exponentIndex)
{
inputExponents[dlIndex][exponentIndex] = input[dlIndex].ExponentAtIndex(exponentIndex);
}
}
string[] serializedTT = CryptoSerializer.Serialize(input, true, true);
DLRepOfGroupElement[] outputTT = CryptoSerializer.Deserialize <DLRepOfGroupElement>(serializedTT, null, null);
StaticHelperClass.AssertArraysAreEqual(input, outputTT, "outputTT");
string[] serializedNT = CryptoSerializer.Serialize(input, true, false);
GroupElement[] newBases = StaticHelperClass.GenerateRandomBases(input[0].RepresentationLength, this.paramIndex);
DLRepOfGroupElement[] outputNT = CryptoSerializer.Deserialize <DLRepOfGroupElement>(serializedNT, null, newBases);
Assert.AreEqual(input.Length, outputNT.Length, "outputNT.Length");
for (int i = 0; i < outputNT.Length; ++i)
{
DLRepOfGroupElement expected = new DLRepOfGroupElement(newBases, inputExponents[i], this.crypto.Group);
expected.Value = input[i].Value;
Assert.AreEqual(expected, outputNT[i], "outputNT " + i);
}
FieldZqElement[] commitments = StaticHelperClass.GenerateRandomExponents(10, this.paramIndex);
FieldZqElement[] openings = StaticHelperClass.GenerateRandomExponents(10, this.paramIndex);
input = PedersenCommitment.GetCommitments(this.crypto, commitments, openings);
}
public static DLRepOfGroupElement[] GenerateRandomDLRepOfGroupElementArray(int arrayLength, int representationLength, int paramIndex)
{
DLRepOfGroupElement[] output = new DLRepOfGroupElement[arrayLength];
for (int i = 0; i < arrayLength; ++i)
{
output[i] = GenerateRandomDLRepOfGroupElement(representationLength, paramIndex);
}
return(output);
}
public void DLRepEqualsWrongExponentTest()
{
GroupElement[] bases = StaticHelperClass.GenerateRandomBases(8, 0);
FieldZqElement[] exponents = StaticHelperClass.GenerateRandomExponents(8, 0);
DLRepOfGroupElement dl = new DLRepOfGroupElement(bases, exponents, _parameters[0].Group);
exponents[7] = exponents[2];
DLRepOfGroupElement badDL = new DLRepOfGroupElement(bases, exponents, _parameters[0].Group);
Assert.IsFalse(dl.Equals(badDL), "should fail due to bad exponent.");
Assert.IsFalse(badDL.Equals(dl), "should fail due to bad exponent.");
}
public void TryStrictMultiplyWithExponentsTest()
{
bool success;
DLRepOfGroupElement [] dlArray;
FieldZqElement [] exponents;
DLRepOfGroupElement product;
for (int paramIndex = 0; paramIndex < _parameters.Length; ++paramIndex)
{
dlArray = new DLRepOfGroupElement[128];
GroupElement expectedProduct = _parameters[paramIndex].Group.Identity;
for (int i = 0; i < dlArray.Length; ++i)
{
exponents = StaticHelperClass.GenerateRandomExponents(5, paramIndex);
dlArray[i] = new DLRepOfGroupElement(exponents, _parameters[paramIndex]);
expectedProduct *= dlArray[i].Value;
}
DLRepOfGroupElement actualProduct;
success = DLRepOfGroupElement.TryStrictMultiply(dlArray, out actualProduct);
Assert.IsTrue(success, "TryStrictMultiply should have succeeded.");
Assert.IsNotNull(actualProduct, "actualProduct should be set to a value.");
Assert.IsTrue(actualProduct.AreBasesEqual(dlArray[0]), "Bases should be the same.");
Assert.AreEqual(expectedProduct, actualProduct.Value, "Value computed incorrectly.");
}
// fail on null/ empty input
DLRepOfGroupElement dl;
success = DLRepOfGroupElement.TryStrictMultiply(null, out dl);
Assert.IsFalse(success);
DLRepOfGroupElement[] emptyArray = new DLRepOfGroupElement[0];
success = DLRepOfGroupElement.TryStrictMultiply(emptyArray, out dl);
Assert.IsFalse(success);
// fail because bases are different
dlArray = new DLRepOfGroupElement[5];
GroupElement [] bases = StaticHelperClass.GenerateRandomBases(8, 5);
for (int dlIndex = 0; dlIndex < dlArray.Length - 1; ++dlIndex)
{
exponents = StaticHelperClass.GenerateRandomExponents(8, 5);
dlArray[dlIndex] = new DLRepOfGroupElement(bases, exponents, _parameters[5].Group);
}
GroupElement [] badBases = StaticHelperClass.GenerateRandomBases(8, 5);
exponents = StaticHelperClass.GenerateRandomExponents(8, 5);
dlArray[dlArray.Length - 1] = new DLRepOfGroupElement(badBases, exponents, _parameters[5].Group);
success = DLRepOfGroupElement.TryStrictMultiply(dlArray, out product);
Assert.IsFalse(success, "should fail since one of the elements in dlArray has different bases.");
}
public void EQBadVerifierParametersTest()
{
int length = 20;
int fullLength = length * 2;
DLRepOfGroupElement[] openEquations = StaticHelperClass.GenerateRandomDLRepOfGroupElementArray(length, 5, _paramIndex);
DLRepOfGroupElement[] allOpenEquations = new DLRepOfGroupElement[fullLength];
for (int i = 0; i < openEquations.Length; ++i)
{
allOpenEquations[i] = openEquations[i];
allOpenEquations[i + length] = openEquations[i];
}
// create equality map
EqualityMap map = new EqualityMap();
for (int i = 0; i < length; ++i)
{
map.Add(
new PrettyName("chi", i),
new DoubleIndex(i, 0)
);
map.Add(
new PrettyName("chi", i),
new DoubleIndex(length + i, 0)
);
map.Add(
new PrettyName("delta", i),
new DoubleIndex(i, 19)
);
map.Add(
new PrettyName("delta", i),
new DoubleIndex(length + i, 19)
);
map.Add(
new PrettyName("beta", i),
new DoubleIndex(i, 5)
);
map.Add(
new PrettyName("beta", i),
new DoubleIndex(length + i, 5)
);
}
}
public void BaseAndExponentAtIndexTest()
{
int replen = 25;
for (int paramIndex = 0; paramIndex < _parameters.Length; ++paramIndex)
{
GroupElement [] bases = StaticHelperClass.GenerateRandomBases(replen, paramIndex);
FieldZqElement [] exponents = StaticHelperClass.GenerateRandomExponents(replen, paramIndex);
DLRepOfGroupElement dl = new DLRepOfGroupElement(bases, exponents, _parameters[paramIndex].Group);
Assert.AreEqual(replen, dl.RepresentationLength, "incorrect representation length");
for (int i = 0; i < replen; ++i)
{
Assert.AreEqual(bases[i], dl.BaseAtIndex(i), "wrong base");
Assert.AreEqual(exponents[i], dl.ExponentAtIndex(i), "wrong exponent");
}
}
}
public void OpenClosedPairTest()
{
GroupElement[] bases = StaticHelperClass.GenerateRandomBases(4, 0);
GroupElement[] goodBases = StaticHelperClass.GenerateRandomBases(4, 0);
FieldZqElement[] exponents = StaticHelperClass.GenerateRandomExponents(4, 0);
DLRepOfGroupElement dl = new DLRepOfGroupElement(goodBases, exponents, _parameters[0].Group);
IStatement expectedClosed = dl.GetStatement();
ClosedDLRepOfGroupElement badClosed = new ClosedDLRepOfGroupElement(bases, dl.Value, dl.Group);
Assert.IsTrue(DLRepOfGroupElement.IsValidOpenClosedPair(dl, expectedClosed), "should be valid.");
Assert.IsFalse(DLRepOfGroupElement.IsValidOpenClosedPair(dl, badClosed), "bad pair due to wrong bases.");
badClosed = new ClosedDLRepOfGroupElement(goodBases, bases[0], _parameters[0].Group);
Assert.IsFalse(DLRepOfGroupElement.IsValidOpenClosedPair(dl, badClosed), "bad pair due to wrong value.");
Assert.IsFalse(DLRepOfGroupElement.IsValidOpenClosedPair(null, null), "should fail on null input.");
}
public void CSDLRepTest()
{
DLRepOfGroupElement[] input = StaticHelperClass.GenerateRandomDLRepOfGroupElementArray(10, 7, this.paramIndex);
for (int i = 0; i < input.Length; ++i)
{
Group group = input[i].Group;
GroupElement [] bases = new GroupElement[input[i].RepresentationLength];
FieldZqElement [] exponents = new FieldZqElement[input[i].RepresentationLength];
for (int j = 0; j < input[i].RepresentationLength; ++j)
{
bases[j] = input[i].BaseAtIndex(j);
exponents[j] = input[i].ExponentAtIndex(j);
}
DLRepOfGroupElement expected = new DLRepOfGroupElement(bases, exponents, group);
expected.Value = input[i].Value;
input[i].IsGroupSerializable = false;
input[i].AreBasesSerializable = false;
string serializedNN = CryptoSerializer.Serialize <DLRepOfGroupElement>(input[i]);
DLRepOfGroupElement outputNN = CryptoSerializer.Deserialize <DLRepOfGroupElement>(serializedNN, group, bases);
Assert.AreEqual(input[i], outputNN, "outputNN");
input[i].IsGroupSerializable = false;
input[i].AreBasesSerializable = true;
string serializedNB = CryptoSerializer.Serialize <DLRepOfGroupElement>(input[i]);
DLRepOfGroupElement outputNB = CryptoSerializer.Deserialize <DLRepOfGroupElement>(serializedNB, group);
Assert.AreEqual(input[i], outputNB, "outputNB");
input[i].IsGroupSerializable = true;
input[i].AreBasesSerializable = false;
string serializedAN = CryptoSerializer.Serialize <DLRepOfGroupElement>(input[i]);
DLRepOfGroupElement outputAN = CryptoSerializer.Deserialize <DLRepOfGroupElement>(serializedAN, null, bases);
Assert.AreEqual(expected, outputAN, "outputAN");
input[i].IsGroupSerializable = true;
input[i].AreBasesSerializable = true;
string serializedAB = CryptoSerializer.Serialize <DLRepOfGroupElement>(input[i]);
DLRepOfGroupElement outputAB = CryptoSerializer.Deserialize <DLRepOfGroupElement>(serializedAB, null, null);
Assert.AreEqual(input[i], outputAB, "outputAB");
}
}
public void DLtoPedConstructorTest()
{
for (int paramIndex = 0; paramIndex < _parameters.Length; ++paramIndex)
{
GroupElement[] bases = StaticHelperClass.GenerateRandomBases(2, paramIndex);
FieldZqElement[] exponents = StaticHelperClass.GenerateRandomExponents(2, paramIndex);
DLRepOfGroupElement dl = new DLRepOfGroupElement(bases, exponents, _parameters[paramIndex].Group);
PedersenCommitment ped = new PedersenCommitment(dl);
Assert.IsTrue(ped.Validate(), "ped should be a valid pedersen commitment.");
Assert.AreEqual(bases[0], ped.G, "Wrong G value.");
Assert.AreEqual(bases[1], ped.H, "Wrong H value.");
Assert.AreEqual(exponents[0], ped.CommittedValue, "wrong committed value.");
Assert.AreEqual(exponents[1], ped.Opening, "wrong opening.");
GroupElement expectedValue = _parameters[paramIndex].Group.MultiExponentiate(bases, exponents);
Assert.AreEqual(expectedValue, ped.Value, "wrong value.");
}
}
public void DLRepToPedBadConstructorTest()
{
int paramIndex = 5;
GroupElement[] bases = null;
FieldZqElement[] exponents = null;
Group group = _parameters[paramIndex].Group;
PedersenCommitment ped;
// wrong length bases & exponent arrays
bool threwException = false;
bases = StaticHelperClass.GenerateRandomBases(1, paramIndex);
exponents = StaticHelperClass.GenerateRandomExponents(1, paramIndex);
DLRepOfGroupElement dl = new DLRepOfGroupElement(bases, exponents, group);
try
{
ped = new PedersenCommitment(dl);
}
catch (Exception)
{
threwException = true;
}
Assert.IsTrue(threwException, "should throw exception when dl representation length is 1.");
// wrong length bases & exponent arrays
threwException = false;
bases = StaticHelperClass.GenerateRandomBases(3, paramIndex);
exponents = StaticHelperClass.GenerateRandomExponents(3, paramIndex);
dl = new DLRepOfGroupElement(bases, exponents, group);
try
{
ped = new PedersenCommitment(dl);
}
catch (Exception)
{
threwException = true;
}
Assert.IsTrue(threwException, "should throw exception when bases and exponents are arrays of length 3.");
}
public void ComputeValueTest()
{
for (int paramIndex = 0; paramIndex < _parameters.Length; ++paramIndex)
{
int replen = 10;
FieldZqElement[] exponents = StaticHelperClass.GenerateRandomExponents(replen, paramIndex);
GroupElement[] bases = StaticHelperClass.GenerateRandomBases(replen, paramIndex);
DLRepOfGroupElement actualDL = new DLRepOfGroupElement(bases, exponents, _parameters[paramIndex].Group);
GroupElement expectedValue = _parameters[paramIndex].Group.MultiExponentiate(bases, exponents);
Assert.AreEqual(expectedValue, actualDL.Value, "different values");
Assert.AreEqual(exponents.Length, actualDL.RepresentationLength, "different number of bases");
for (int baseIndex = 0; baseIndex < actualDL.RepresentationLength; ++baseIndex)
{
Assert.AreEqual(bases[baseIndex], actualDL.BaseAtIndex(baseIndex), "different base");
Assert.AreEqual(exponents[baseIndex], actualDL.ExponentAtIndex(baseIndex), "different exponent");
}
}
}
public void ComputeValueWithParametersTest()
{
for (int paramIndex = 0; paramIndex < _parameters.Length; ++paramIndex)
{
int replen = 14;
GroupElement[] bases = GetGenerators(_parameters[paramIndex], replen);
FieldZqElement[] exponents = StaticHelperClass.GenerateRandomExponents(replen, paramIndex);
DLRepOfGroupElement actualDL = new DLRepOfGroupElement(exponents, _parameters[paramIndex]);
DLRepOfGroupElement expectedDL = new DLRepOfGroupElement(bases, exponents, _parameters[paramIndex].Group);
//compare expectedDL and actualDL
Assert.IsNotNull(actualDL, "actualDl null");
Assert.IsNotNull(expectedDL, "expectedDL null");
Assert.AreEqual(expectedDL.Value, actualDL.Value, "different values");
Assert.AreEqual(expectedDL.RepresentationLength, actualDL.RepresentationLength, "different number of bases");
Assert.AreEqual(expectedDL, actualDL, "ComputeValue created different objects");
}
}
public void BaseConstructorTest()
{
for (int paramIndex = 0; paramIndex < _parameters.Length; ++paramIndex)
{
int replen = 10;
FieldZqElement[] exponents = StaticHelperClass.GenerateRandomExponents(replen, paramIndex);
GroupElement[] bases = StaticHelperClass.GenerateRandomBases(replen, paramIndex);
DLRepOfGroupElement dl = new DLRepOfGroupElement(bases, exponents, _parameters[paramIndex].Group);
// check bases and exponents got copied correctly, and value was computed correctly
GroupElement expectedValue = _parameters[paramIndex].Group.Identity;
for (int baseIndex = 0; baseIndex < bases.Length; ++baseIndex)
{
Assert.AreEqual(bases[baseIndex], dl.BaseAtIndex(baseIndex), "Wrong base");
Assert.AreEqual(exponents[baseIndex], dl.ExponentAtIndex(baseIndex), "wrong exponent");
expectedValue = expectedValue * bases[baseIndex].Exponentiate(exponents[baseIndex]);
}
Assert.AreEqual(expectedValue, dl.Value, "Incorrect Value");
}
}
public void EQSerializationTest()
{
int length = 20;
int fullLength = length * 2;
DLRepOfGroupElement [] openEquations = StaticHelperClass.GenerateRandomDLRepOfGroupElementArray(length, 5, _paramIndex);
DLRepOfGroupElement [] allOpenEquations = new DLRepOfGroupElement[fullLength];
for (int i = 0; i < openEquations.Length; ++i)
{
allOpenEquations[i] = openEquations[i];
allOpenEquations[i + length] = openEquations[i];
}
// create equality map
EqualityMap map = new EqualityMap();
for (int i = 0; i < length; ++i)
{
map.Add(
new PrettyName("chi", i),
new DoubleIndex(i, 0)
);
map.Add(
new PrettyName("chi", i),
new DoubleIndex(length + i, 0)
);
map.Add(
new PrettyName("delta", i),
new DoubleIndex(i, 4)
);
map.Add(
new PrettyName("delta", i),
new DoubleIndex(length + i, 4)
);
map.Add(
new PrettyName("beta", i),
new DoubleIndex(i, 2)
);
map.Add(
new PrettyName("beta", i),
new DoubleIndex(length + i, 2)
);
}
// create proverParameters
ProverEqualityParameters prover = new ProverEqualityParameters(allOpenEquations, map, _crypto);
string jsonProver = CryptoSerializer.Serialize <ProverEqualityParameters>(prover);
ProverEqualityParameters deserializedProver = CryptoSerializer.Deserialize <ProverEqualityParameters>(jsonProver);
StaticHelperClass.AssertArraysAreEqual(prover.Statements, deserializedProver.Statements, "Prover closedDLEquations");
StaticHelperClass.AssertArraysAreEqual(prover.Witnesses, deserializedProver.Witnesses, "Prover Witnesses");
StaticHelperClass.AssertArraysAreEqual(prover.HashDigest, deserializedProver.HashDigest, "equality map hash.");
StaticHelperClass.AssertArraysAreEqual(prover.Generators, deserializedProver.Generators, "prover Generators");
for (int i = 0; i < prover.Statements.Length; ++i)
{
Assert.IsTrue(prover.Statements[i].AreBasesEqual(deserializedProver.Statements[i]), "unequal bases for equation " + i);
}
Assert.IsTrue(deserializedProver.Verify(), "deserializedProver.Verify()");
// create proof
EqualityProof proof = new EqualityProof(prover);
Assert.IsTrue(proof.Verify(prover), "Proof.Verify(prover)");
Assert.IsTrue(proof.Verify(deserializedProver), "proof.Verify(deserializedProver)");
string jsonProof = CryptoSerializer.Serialize <EqualityProof>(proof);
// TODO: switch to using ip-based de-serialization; need to harmonize with U-Prove SDK code
IssuerParameters ip = new IssuerParameters();
ip.Gq = prover.Group;
EqualityProof deserializedProof = ip.Deserialize <EqualityProof>(jsonProof); // CryptoSerializer.Deserialize<EqualityProof>(jsonProof);
Assert.IsTrue(deserializedProof.Verify(prover), "deserializedProof.Verify(prover)");
Assert.IsTrue(deserializedProof.Verify(deserializedProver), "deserializedProof.Verify(deserializedProver)");
// create verifier
IStatement[] closedEquations = new ClosedDLRepOfGroupElement[allOpenEquations.Length];
for (int i = 0; i < allOpenEquations.Length; ++i)
{
closedEquations[i] = allOpenEquations[i].GetStatement();
}
VerifierEqualityParameters verifier = new VerifierEqualityParameters(closedEquations, map, _crypto);
Assert.IsTrue(proof.Verify(verifier), "Proof.Verify(verifier)");
Assert.IsTrue(deserializedProof.Verify(verifier), "proof.Verify(verifier)");
string jsonVerifier = CryptoSerializer.Serialize <VerifierEqualityParameters>(verifier);
VerifierEqualityParameters deserializedVerifier = CryptoSerializer.Deserialize <VerifierEqualityParameters>(jsonVerifier);
Assert.IsTrue(deserializedVerifier.Verify(), "deserializedVerifier.Verify()");
Assert.IsTrue(deserializedProof.Verify(deserializedVerifier), "deserializedProof.Verify(deserializedVerifier)");
// create proof from deserialized prover
EqualityProof newProof = new EqualityProof(deserializedProver);
Assert.IsTrue(newProof.Verify(deserializedProver), "newProof.verify(deserializedProver)");
Assert.IsTrue(newProof.Verify(verifier), "newProof.Verify(verifier)");
}
public void ComputeValueBadInputTest()
{
GroupElement[] bases = StaticHelperClass.GenerateRandomBases(8, 1);
FieldZqElement [] exponents = StaticHelperClass.GenerateRandomExponents(9, 1);
bool threwException = false;
try
{
DLRepOfGroupElement dl = new DLRepOfGroupElement(bases, exponents, _parameters[1].Group);
}
catch (Exception)
{
threwException = true;
}
Assert.IsTrue(threwException, "should throw exception when given 8 bases and 9 exponents.");
exponents = StaticHelperClass.GenerateRandomExponents(8, 1);
threwException = false;
try
{
DLRepOfGroupElement dl = new DLRepOfGroupElement(null, exponents, _parameters[1].Group);
}
catch (Exception)
{
threwException = true;
}
Assert.IsTrue(threwException, "should throw exception on null bases");
threwException = false;
try
{
DLRepOfGroupElement dl = new DLRepOfGroupElement(bases, null, _parameters[1].Group);
}
catch (Exception)
{
threwException = true;
}
Assert.IsTrue(threwException, "should throw exception on null exponents");
threwException = false;
try
{
DLRepOfGroupElement dl = new DLRepOfGroupElement(bases, exponents, null);
}
catch (Exception)
{
threwException = true;
}
Assert.IsTrue(threwException, "should throw exception on null group");
threwException = false;
try
{
DLRepOfGroupElement dl = new DLRepOfGroupElement(bases, exponents, _parameters[4].Group);
}
catch (Exception)
{
threwException = true;
}
Assert.IsTrue(threwException, "should throw exception on wrong Group");
threwException = false;
bases = new GroupElement[0];
exponents = new FieldZqElement[0];
try
{
DLRepOfGroupElement dl = new DLRepOfGroupElement(bases, exponents, _parameters[4].Group);
}
catch (Exception)
{
threwException = true;
}
Assert.IsTrue(threwException, "should throw exception on zero length bases and exponents arrays");
}
