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 CSBadDeserializeFieldZqElementArrayTest()
{
FieldZqElement[] input = StaticHelperClass.GenerateRandomExponents(10, paramIndex);
string[] serialized = CryptoSerializer.SerializeFieldZqElementArray(input, 3, 4, "blah");
Assert.AreEqual(4, serialized.Length, "serialized array length");
StaticHelperClass.TryBodyDelegate negativeStartIndex =
new StaticHelperClass.TryBodyDelegate(
() =>
{
FieldZqElement[] output = CryptoSerializer.DeserializeFieldZqElementArray(serialized, -1, 10, "blah", crypto.Group);
});
StaticHelperClass.AssertThrowsException(negativeStartIndex, typeof(Exception), "negative start index");
StaticHelperClass.TryBodyDelegate startIndexTooLarge =
new StaticHelperClass.TryBodyDelegate(
() =>
{
FieldZqElement[] output = CryptoSerializer.DeserializeFieldZqElementArray(serialized, 8, 10, "blah", crypto.Group);
});
StaticHelperClass.AssertThrowsException(startIndexTooLarge, typeof(Exception), "start index too large");
StaticHelperClass.TryBodyDelegate startIndexWaytooLarge =
new StaticHelperClass.TryBodyDelegate(
() =>
{
FieldZqElement[] output = CryptoSerializer.DeserializeFieldZqElementArray(serialized, 11, 10, "blah", crypto.Group);
});
StaticHelperClass.AssertThrowsException(startIndexWaytooLarge, typeof(Exception), "start index greater than output length ");
}
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 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 CSFieldZqElementArrayTest()
{
FieldZqElement[] input = StaticHelperClass.GenerateRandomExponents(10, paramIndex);
string[] output = CryptoSerializer.SerializeFieldZqElementArray(input, "blah");
Assert.AreEqual(input.Length, output.Length, "serialized array length different.");
FieldZqElement[] deserialized = CryptoSerializer.DeserializeFieldZqElementArray(output, "blah", crypto.Group);
StaticHelperClass.AssertArraysAreEqual(input, deserialized, "deserialized");
}
public void CSFieldZqElementArrayTest2()
{
FieldZqElement[] input = StaticHelperClass.GenerateRandomExponents(10, paramIndex);
string[] serialized = CryptoSerializer.SerializeFieldZqElementArray(input, 3, 4, "blah");
Assert.AreEqual(4, serialized.Length, "serialized array length");
FieldZqElement[] output = CryptoSerializer.DeserializeFieldZqElementArray(serialized, 3, 10, "output", crypto.Group);
FieldZqElement[] expectedOutput = new FieldZqElement[10]
{
null,
null,
null,
input[3],
input[4],
input[5],
input[6],
null,
null,
null
};
StaticHelperClass.AssertArraysAreEqual(expectedOutput, output, "output");
FieldZqElement[] output2 = CryptoSerializer.DeserializeFieldZqElementArray(serialized, 0, 10, "output2", crypto.Group);
FieldZqElement[] expectedOutput2 = new FieldZqElement[10]
{
input[3],
input[4],
input[5],
input[6],
null,
null,
null,
null,
null,
null
};
StaticHelperClass.AssertArraysAreEqual(expectedOutput2, output2, "output2");
FieldZqElement[] output3 = CryptoSerializer.DeserializeFieldZqElementArray(serialized, 6, 10, "output3", crypto.Group);
FieldZqElement[] expectedOutput3 = new FieldZqElement[10]
{
null,
null,
null,
null,
null,
null,
input[3],
input[4],
input[5],
input[6]
};
StaticHelperClass.AssertArraysAreEqual(expectedOutput3, output3, "output3");
}
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 PedCommitmentBadConstructorTest()
{
int paramIndex = 6;
GroupElement[] bases = null;
FieldZqElement[] exponents = null;
Group group = _parameters[paramIndex].Group;
PedersenCommitment ped;
// null input
bool threwException = false;
try
{
ped = new PedersenCommitment(bases, exponents, group);
}
catch (Exception)
{
threwException = true;
}
Assert.IsTrue(threwException, "should throw exception on null input.");
// wrong length bases & exponent arrays
threwException = false;
bases = StaticHelperClass.GenerateRandomBases(1, paramIndex);
exponents = StaticHelperClass.GenerateRandomExponents(1, paramIndex);
try
{
ped = new PedersenCommitment(bases, exponents, group);
}
catch (Exception)
{
threwException = true;
}
Assert.IsTrue(threwException, "should throw exception when bases and exponents are arrays of length 1.");
// wrong length bases & exponent arrays
threwException = false;
bases = StaticHelperClass.GenerateRandomBases(3, paramIndex);
exponents = StaticHelperClass.GenerateRandomExponents(3, paramIndex);
try
{
ped = new PedersenCommitment(bases, exponents, group);
}
catch (Exception)
{
threwException = true;
}
Assert.IsTrue(threwException, "should throw exception when bases and exponents are arrays of length 3.");
}
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 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 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 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 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 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 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 CSBadSerializeFieldZqElementArrayTest()
{
FieldZqElement[] input = StaticHelperClass.GenerateRandomExponents(10, paramIndex);
StaticHelperClass.TryBodyDelegate negativeLength =
new StaticHelperClass.TryBodyDelegate(
() =>
{
string[] serialized = CryptoSerializer.SerializeFieldZqElementArray(input, 3, -1, "blah");
});
StaticHelperClass.AssertThrowsException(negativeLength, typeof(Exception), "negative output length");
// zero output length
string[] output = CryptoSerializer.SerializeFieldZqElementArray(input, 3, 0, "blah");
Assert.AreEqual(0, output.Length, "output.Length.");
// output length too long
StaticHelperClass.TryBodyDelegate outputLengthTooLarge =
new StaticHelperClass.TryBodyDelegate(
() =>
{
string[] serialized = CryptoSerializer.SerializeFieldZqElementArray(input, 3, 9, "blah");
});
StaticHelperClass.AssertThrowsException(outputLengthTooLarge, typeof(Exception), "Output length too large");
// copy index negative
StaticHelperClass.TryBodyDelegate startIndexNegative =
new StaticHelperClass.TryBodyDelegate(
() =>
{
string[] serialized = CryptoSerializer.SerializeFieldZqElementArray(input, -1, 4, "blah");
});
StaticHelperClass.AssertThrowsException(startIndexNegative, typeof(Exception), "Start index is negative.");
string[] jsonStrings = new string[32];
StaticHelperClass.AssertThrowsException(
() => { CryptoSerializer.DeserializeFieldZqElementArray(jsonStrings, 0, 0, "field", null); },
typeof(SerializationException),
"Group is null.");
}
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");
}
public static DLRepOfGroupElement GenerateRandomDLRepOfGroupElement(int representationLength, int paramIndex)
{
GroupElement[] bases = StaticHelperClass.GenerateRandomBases(representationLength, paramIndex);
FieldZqElement[] exponents = StaticHelperClass.GenerateRandomExponents(representationLength, paramIndex);
return(new DLRepOfGroupElement(bases, exponents, ParameterArray[paramIndex].Group));
}
