public void DLAreBasesEqualBadInputTest()
{
GroupElement[] bases1 = StaticHelperClass.GenerateRandomBases(10, 0);
ClosedDLRepOfGroupElement udl = new ClosedDLRepOfGroupElement(bases1, bases1[0], _parameters[0].Group);
GroupElement[] bases2 = new GroupElement[9];
for (int i = 0; i < bases2.Length; ++i)
{
bases2[i] = bases1[i];
}
ClosedDLRepOfGroupElement udlbad = new ClosedDLRepOfGroupElement(bases2, bases1[0], _parameters[0].Group);
Assert.IsFalse(udl.AreBasesEqual(udlbad), "different bases due to different rep length");
Assert.IsFalse(udlbad.AreBasesEqual(udl), "different bases due to different rep length");
udlbad = null;
Assert.IsFalse(udl.AreBasesEqual(udlbad), "different bases since udlbad is null");
// testing on array input
ClosedDLRepOfGroupElement[] udlArray = null;
Assert.IsFalse(ClosedDLRepOfGroupElement.AreBasesEqual(udlArray), "fails on null input.");
udlArray = new ClosedDLRepOfGroupElement[0];
Assert.IsFalse(ClosedDLRepOfGroupElement.AreBasesEqual(udlArray), "fails on empty array input.");
udlArray = new ClosedDLRepOfGroupElement[1] {
udl
};
Assert.IsTrue(ClosedDLRepOfGroupElement.AreBasesEqual(udlArray), "array of one element should pass");
}
public void AreBasesEqualTest()
{
for (int i = 0; i < _parameters.Length; ++i)
{
GroupElement[] bases0 = GetGenerators(_parameters[i], 6);
GroupElement[] bases1 = GetGenerators(_parameters[i], 6);
bases1[5] = bases1[5] * bases1[3];
ClosedDLRepOfGroupElement dl = new ClosedDLRepOfGroupElement(bases0, _parameters[i].G, _parameters[i].Group);
ClosedDLRepOfGroupElement dlWithSameBases = new ClosedDLRepOfGroupElement(bases0, _parameters[i].H, _parameters[i].Group);
ClosedDLRepOfGroupElement dlWithDiffBases = new ClosedDLRepOfGroupElement(bases1, _parameters[i].G, _parameters[i].Group);
Assert.IsTrue(dl.AreBasesEqual(dlWithSameBases), "bases are the same.");
Assert.IsTrue(dlWithSameBases.AreBasesEqual(dl), "bases are same");
Assert.IsFalse(dl.AreBasesEqual(dlWithDiffBases), "bases are different.");
ClosedDLRepOfGroupElement[] sameBaseArray = new ClosedDLRepOfGroupElement[4] {
dlWithSameBases, dl, dlWithSameBases, dl
};
ClosedDLRepOfGroupElement[] diffBaseArray = new ClosedDLRepOfGroupElement[4] {
dl, dl, dl, dlWithDiffBases
};
Assert.IsTrue(ClosedDLRepOfGroupElement.AreBasesEqual(sameBaseArray), "Bases are identical");
Assert.IsFalse(ClosedDLRepOfGroupElement.AreBasesEqual(diffBaseArray), "Bases are different");
}
}
public void ClosedDLHashCodeTest()
{
GroupElement[] bases = StaticHelperClass.GenerateRandomBases(11, 0);
GroupElement value = bases[1];
ClosedDLRepOfGroupElement udl = new ClosedDLRepOfGroupElement(bases, value, _parameters[0].Group);
Assert.AreEqual(bases[0].GetHashCode(), udl.GetHashCode(), "should retrieve hashcode from bases[0]");
bases = new GroupElement[0];
udl = new ClosedDLRepOfGroupElement(bases, value, _parameters[0].Group);
Assert.AreEqual(0, udl.GetHashCode(), "hash code for 0 replength closed dl rep should be 0");
}
public void ClosedDLRepToClosedPedTest()
{
GroupElement[] bases = StaticHelperClass.GenerateRandomBases(2, 3);
GroupElement value = StaticHelperClass.GenerateRandomValue(3);
ClosedDLRepOfGroupElement udl = new ClosedDLRepOfGroupElement(bases, value, _parameters[3].Group);
ClosedPedersenCommitment closedPed = new ClosedPedersenCommitment(udl);
Assert.AreEqual(2, closedPed.RepresentationLength, "representation length should be 2");
Assert.AreEqual(bases[0], closedPed.G, "G value should be bases[0]");
Assert.AreEqual(bases[1], closedPed.H, "H value incorrect.");
Assert.AreEqual(value, closedPed.Value, "value incorrect.");
Assert.IsTrue(closedPed.Validate(), "should be valid closed pederson commitment.");
}
public void ClosedPedConstructorTests()
{
GroupElement[] badbases = StaticHelperClass.GenerateRandomBases(3, 0);
GroupElement value = badbases[2];
ClosedDLRepOfGroupElement baddl = new ClosedDLRepOfGroupElement(badbases, value, _parameters[0].Group);
bool threwException = false;
try
{
ClosedPedersenCommitment ped = new ClosedPedersenCommitment(badbases, value, _parameters[0].Group);
}
catch (Exception)
{
threwException = true;
}
Assert.IsTrue(threwException, "ClosedPedersenCommitment constructor should throw Exception when length of bases is not 2");
threwException = false;
try
{
ClosedPedersenCommitment ped = new ClosedPedersenCommitment(baddl);
}
catch (Exception)
{
threwException = true;
}
badbases = StaticHelperClass.GenerateRandomBases(1, 0);
baddl = new ClosedDLRepOfGroupElement(badbases, value, _parameters[0].Group);
threwException = false;
try
{
ClosedPedersenCommitment ped = new ClosedPedersenCommitment(badbases, value, _parameters[0].Group);
}
catch (Exception)
{
threwException = true;
}
Assert.IsTrue(threwException, "ClosedPedersenCommitment constructor should throw Exception when length of bases is 1.");
threwException = false;
try
{
ClosedPedersenCommitment ped = new ClosedPedersenCommitment(baddl);
}
catch (Exception)
{
threwException = true;
}
Assert.IsTrue(threwException, "ClosedPedersenCommitment constructor should throw Exception when length of bases is 1.");
}
public void ExponentiateTest()
{
for (int paramIndex = 0; paramIndex < _parameters.Length; ++paramIndex)
{
GroupElement[] bases = StaticHelperClass.GenerateRandomBases(8, paramIndex);
FieldZqElement[] exponent = StaticHelperClass.GenerateRandomExponents(1, paramIndex);
GroupElement value = _parameters[paramIndex].Generators[0];
ClosedDLRepOfGroupElement udl = new ClosedDLRepOfGroupElement(bases, value, _parameters[paramIndex].Group);
ClosedDLRepOfGroupElement actualUDL = udl.Exponentiate(exponent[0]);
Assert.IsTrue(actualUDL.AreBasesEqual(udl), "bases should be the same.");
Assert.AreEqual(udl.Value.Exponentiate(exponent[0]), actualUDL.Value, "Value computed incorrectly.");
}
}
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 CSClosedDLRepArrayTest()
{
int arrayLength = 10;
DLRepOfGroupElement[] openInput = StaticHelperClass.GenerateRandomDLRepOfGroupElementArray(10, 7, this.paramIndex);
ClosedDLRepOfGroupElement [] input = new ClosedDLRepOfGroupElement[arrayLength];
for (int i = 0; i < input.Length; ++i)
{
GroupElement[] bases = StaticHelperClass.GenerateRandomBases(10, this.paramIndex);
GroupElement value = bases[0];
input[i] = new ClosedDLRepOfGroupElement(bases, value, crypto.Group);
}
string[] serialized = CryptoSerializer.Serialize(input, false);
ClosedDLRepOfGroupElement[] output = CryptoSerializer.Deserialize <ClosedDLRepOfGroupElement>(serialized, crypto.Group);
StaticHelperClass.AssertArraysAreEqual(input, output, "no group");
string[] serialized2 = CryptoSerializer.Serialize(input, true);
ClosedDLRepOfGroupElement[] output2 = CryptoSerializer.Deserialize <ClosedDLRepOfGroupElement>(serialized, crypto.Group);
StaticHelperClass.AssertArraysAreEqual(input, output2, "group");
}
public void TryStrictMultiplySucceedTest()
{
for (int paramIndex = 0; paramIndex < _parameters.Length; ++paramIndex)
{
GroupElement[] bases = StaticHelperClass.GenerateRandomBases(8, paramIndex);
GroupElement[] values = StaticHelperClass.GenerateRandomBases(10, paramIndex);
ClosedDLRepOfGroupElement[] udlArray = new ClosedDLRepOfGroupElement[values.Length];
GroupElement expectedProduct = _parameters[paramIndex].Group.Identity;
for (int udlIndex = 0; udlIndex < udlArray.Length; ++udlIndex)
{
udlArray[udlIndex] = new ClosedDLRepOfGroupElement(bases, values[udlIndex], _parameters[paramIndex].Group);
expectedProduct *= values[udlIndex];
}
ClosedDLRepOfGroupElement product;
bool success = ClosedDLRepOfGroupElement.TryStrictMultiply(udlArray, out product);
Assert.IsTrue(success, "TryStrictMultiply should have succeeded.");
Assert.IsNotNull(product, "product should be set to not null");
Assert.IsTrue(product.AreBasesEqual(udlArray[0]), "product should have same bases as other members of udlArray");
Assert.AreEqual(expectedProduct, product.Value, "Product of values computed incorrectly");
}
}
public void ClosedDLTryStrictMultiplyFailTest()
{
int paramIndex = 0;
GroupElement[] bases = StaticHelperClass.GenerateRandomBases(8, paramIndex);
GroupElement[] values = StaticHelperClass.GenerateRandomBases(10, paramIndex);
ClosedDLRepOfGroupElement[] udlArray = new ClosedDLRepOfGroupElement[values.Length];
GroupElement expectedProduct = _parameters[paramIndex].Group.Identity;
for (int udlIndex = 0; udlIndex < udlArray.Length; ++udlIndex)
{
udlArray[udlIndex] = new ClosedDLRepOfGroupElement(bases, values[udlIndex], _parameters[paramIndex].Group);
expectedProduct *= values[udlIndex];
}
// fail with different bases
GroupElement[] wrongBases = StaticHelperClass.GenerateRandomBases(8, paramIndex);
udlArray[udlArray.Length - 1] = new ClosedDLRepOfGroupElement(wrongBases, values[0], _parameters[paramIndex].Group);
ClosedDLRepOfGroupElement product = udlArray[0];
bool success = ClosedDLRepOfGroupElement.TryStrictMultiply(udlArray, out product);
Assert.IsFalse(success, "TryStrictMultiply should have failed");
Assert.IsNull(product, "product should be set to null");
success = ClosedDLRepOfGroupElement.TryStrictMultiply(null, out product);
Assert.IsFalse(success, "TryStrictMultiply should have failed");
Assert.IsNull(product, "product should be set to null");
wrongBases = StaticHelperClass.GenerateRandomBases(18, paramIndex);
udlArray[udlArray.Length - 1] = new ClosedDLRepOfGroupElement(wrongBases, values[0], _parameters[paramIndex].Group);
product = udlArray[0];
success = ClosedDLRepOfGroupElement.TryStrictMultiply(udlArray, out product);
Assert.IsFalse(success, "TryStrictMultiply should have failed");
Assert.IsNull(product, "product should be set to null");
}
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)");
}
