public void CSBadSerializeGroupElementArrayTest()
{
GroupElement[] input = StaticHelperClass.GenerateRandomBases(10, paramIndex);
StaticHelperClass.TryBodyDelegate negativeLength =
new StaticHelperClass.TryBodyDelegate(
() => {
string[] serialized = CryptoSerializer.SerializeGroupElementArray(input, 3, -1, "blah");
});
StaticHelperClass.AssertThrowsException(negativeLength, typeof(Exception), "negative output length");
// zero output length
string[] output = CryptoSerializer.SerializeGroupElementArray(input, 3, 0, "blah");
Assert.AreEqual(0, output.Length, "output.Length.");
// output length too long
StaticHelperClass.TryBodyDelegate outputLengthTooLarge =
new StaticHelperClass.TryBodyDelegate(
() =>
{
string[] serialized = CryptoSerializer.SerializeGroupElementArray(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.SerializeGroupElementArray(input, -1, 4, "blah");
});
StaticHelperClass.AssertThrowsException(startIndexNegative, typeof(Exception), "Start index is negative.");
}
public void InequalityParamsSerializationTest()
{
for (int i = 0; i < StaticHelperClass.ParameterArray.Length; ++i)
{
CryptoParameters crypto = StaticHelperClass.ParameterArray[i];
FieldZqElement x = crypto.FieldZq.GetElement(1000);
FieldZqElement y = crypto.FieldZq.GetElement(2000);
PedersenCommitment X = new PedersenCommitment(x, crypto);
PedersenCommitment Y = new PedersenCommitment(y, crypto);
VerifierInequalityProofParameters verifier = new VerifierInequalityProofParameters(X.Value, Y.Value, crypto);
string json = CryptoSerializer.Serialize <VerifierInequalityProofParameters>(verifier);
VerifierInequalityProofParameters deserialized = CryptoSerializer.Deserialize <VerifierInequalityProofParameters>(json);
StaticHelperClass.AssertProofParametersAreEqual(verifier, deserialized, "Verifier X Y");
verifier = new VerifierInequalityProofParameters(X.Value, y, crypto);
json = CryptoSerializer.Serialize <VerifierInequalityProofParameters>(verifier);
deserialized = CryptoSerializer.Deserialize <VerifierInequalityProofParameters>(json);
StaticHelperClass.AssertProofParametersAreEqual(verifier, deserialized, "Verifier X value");
ProverInequalityProofParameters prover = new ProverInequalityProofParameters(X, Y, crypto);
json = CryptoSerializer.Serialize <ProverInequalityProofParameters>(prover);
ProverInequalityProofParameters dProver = CryptoSerializer.Deserialize <ProverInequalityProofParameters>(json);
StaticHelperClass.AssertProofParametersAreEqual(dProver, prover, "Prover X Y");
prover = new ProverInequalityProofParameters(X, y, crypto);
json = CryptoSerializer.Serialize <ProverInequalityProofParameters>(prover);
dProver = CryptoSerializer.Deserialize <ProverInequalityProofParameters>(json);
StaticHelperClass.AssertProofParametersAreEqual(dProver, prover, "Prover X value");
}
}
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 DLGetHashCodeTest()
{
FieldZqElement[] exponents = StaticHelperClass.GenerateRandomExponents(8, 1);
DLRepOfGroupElement dl = new DLRepOfGroupElement(exponents, _parameters[1]);
Assert.AreEqual(dl.BaseAtIndex(0).GetHashCode(), dl.GetHashCode());
}
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 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 EQTwoTokenEqualityTest()
{
// Both tokens will not hash attributes
// but example also works if hashAttributes=true
bool hashAttributes = true;
// Setting up IssuerParameters for token1
byte[] uidP1 = new byte[] { 1, 1, 2, 3, 5, 7 };
byte[] tokenInformation1 = new byte[] { 1, 2, 3, 4, 5, 6, 7 };
byte[][] attributes1 = new byte[][]
{
_encoding.GetBytes("Attribute 1"),
_encoding.GetBytes("Attribute 2"),
_encoding.GetBytes("Target Attribute"), // this is the attribute we'll compare
_encoding.GetBytes("Attribute 4")
};
// Setting up IssuerParameters for token2
byte[] tokenInformation2 = new byte[] { 12, 13, 14, 15, 0, 10 };
byte[] uidP2 = new byte[] { 3, 1, 4, 1, 5 };
byte[][] attributes2 = new byte[][]
{
_encoding.GetBytes("Target Attribute"), // this is the attribute we'll compare
_encoding.GetBytes("Attribute 6"),
_encoding.GetBytes("Attribute 7"),
_encoding.GetBytes("Attribute 8")
};
// generate tokens
ProverPresentationProtocolParameters prover1, prover2;
VerifierPresentationProtocolParameters verifier1, verifier2;
StaticHelperClass.GetUProveParameters(hashAttributes, out prover1, out verifier1, tokenInformation1, attributes1, null, uidP1);
StaticHelperClass.GetUProveParameters(hashAttributes, out prover2, out verifier2, tokenInformation2, attributes2, null, uidP2);
// Create equality proof
EqualityProof eqProof = new EqualityProof(
prover1, // token1
3, // target attribute in token1
prover2, // token2
1); // target attribute in token2
// ....
// Send data to verifier, including eqProof
// ....
// Verify tokens
// ...
// Verify equality proof
bool success = eqProof.Verify(
verifier1,
3,
verifier2,
1);
Assert.IsTrue(success, "Could not verify proof.");
}
public void SMBadConstructorTest()
{
ProverSetMembershipParameters badProver = new ProverSetMembershipParameters(_cryptoParameters);
StaticHelperClass.AssertThrowsException(
new StaticHelperClass.TryBodyDelegate(() => { SetMembershipProof proof = new SetMembershipProof(badProver); }),
typeof(Exception),
"Constructor SetMembershipProof called with bad prover parameters.");
}
public void EQTokenAndDLTest()
{
// In this example, the token hashes the attribute
// but example also works if hashAttributes=false
bool hashAttributes = true;
// Setting up attributes for token
byte[][] attributes = new byte[][]
{
_encoding.GetBytes("Attribute 1"),
_encoding.GetBytes("Attribute 2"),
_encoding.GetBytes("Teaching Assistant"), // this is the attribute we'll compare
_encoding.GetBytes("Attribute 4")
};
// generate token
ProverPresentationProtocolParameters prover;
VerifierPresentationProtocolParameters verifier;
StaticHelperClass.GetUProveParameters(hashAttributes, out prover, out verifier, null, attributes);
OpenUProveToken token = new OpenUProveToken(prover);
Assert.IsTrue(token.Validate(null), "validate token.");
// generate pedersen commitment to Teaching Assistant
PedersenCommitment ped = new PedersenCommitment(prover.IP, 3, _encoding.GetBytes("Teaching Assistant"));
// Verify they are equal
Assert.AreEqual(token.AttributeXI(3), ped.CommittedValue, "Token and PedersenCommitment different.");
// Create a proof that the 3rd attribute in token is equal to the committed value in ped.
ProverEqualityParameters eqProver = new ProverEqualityParameters(
token, // token
3, // 3rd attribute is the 3rd exponent
ped, // pedersen commitment
0, // committed value is the 0th exponent
new CryptoParameters(prover.IP));
EqualityProof proof = new EqualityProof(eqProver);
// Verify proof
ClosedUProveToken closedToken = new ClosedUProveToken(verifier);
Assert.IsTrue(closedToken.AreBasesEqual(token), "token bases.");
IStatement closedPed = ped.GetStatement();
Assert.IsTrue(closedPed.AreBasesEqual(ped), "token bases.");
VerifierEqualityParameters eqVerifier = new VerifierEqualityParameters(
closedToken, // verifier token information
3, // 3rd attribute is the 3nd exponent
closedPed, // verifier information about ped
0, // committed value is the 0th exponent
new CryptoParameters(prover.IP));
Assert.IsTrue(proof.Verify(eqVerifier));
}
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 CSCheckDeserializationInputTest()
{
PrivateType serializer = new PrivateType(typeof(CryptoSerializer));
object [] parameters = new object[] { new string[] { "b", "a" }, 0, 0, "lalla", null };
StaticHelperClass.AssertThrowsException(
() => { serializer.InvokeStatic("CheckDeserializationInput", parameters); },
typeof(SerializationException),
"Group is null");
}
public static void AssertProofParametersAreEqual(ProofParameters A, ProofParameters B, string msg)
{
Assert.AreEqual(A.ProverParameters, B.ProverParameters, msg + " Prover parameters");
Assert.AreEqual(A.GetType(), B.GetType(), msg + " different classes");
Assert.AreEqual(A.Group.GroupName, B.Group.GroupName, msg + " Groups");
Assert.AreEqual(A.Group.Q, B.Group.Q, msg + " Q");
StaticHelperClass.AssertArraysAreEqual(A.Generators, B.Generators, msg + " Generators");
StaticHelperClass.AssertArraysAreEqual <GroupElement>(A.PublicValues, B.PublicValues, msg + " Public values");
StaticHelperClass.AssertArraysAreEqual <DLRepOfGroupElement>(A.Witnesses, B.Witnesses, msg + " Witnesses");
}
public void CSGroupElementArrayTest2()
{
GroupElement[] input = StaticHelperClass.GenerateRandomBases(10, paramIndex);
string[] serialized = CryptoSerializer.SerializeGroupElementArray(input, 3, 4, "blah");
Assert.AreEqual(4, serialized.Length, "serialized array length");
GroupElement[] output = CryptoSerializer.DeserializeGroupElementArray(serialized, 3, 10, "output", crypto.Group);
GroupElement [] expectedOutput = new GroupElement[10]
{
null,
null,
null,
input[3],
input[4],
input[5],
input[6],
null,
null,
null
};
StaticHelperClass.AssertArraysAreEqual(expectedOutput, output, "output");
GroupElement[] output2 = CryptoSerializer.DeserializeGroupElementArray(serialized, 0, 10, "output2", crypto.Group);
GroupElement[] expectedOutput2 = new GroupElement[10]
{
input[3],
input[4],
input[5],
input[6],
null,
null,
null,
null,
null,
null
};
StaticHelperClass.AssertArraysAreEqual(expectedOutput2, output2, "output2");
GroupElement[] output3 = CryptoSerializer.DeserializeGroupElementArray(serialized, 6, 10, "output3", crypto.Group);
GroupElement[] expectedOutput3 = new GroupElement[10]
{
null,
null,
null,
null,
null,
null,
input[3],
input[4],
input[5],
input[6]
};
StaticHelperClass.AssertArraysAreEqual(expectedOutput3, output3, "output3");
}
public void SMUProveIntegrationTestWithSMRandom()
{
// In this example, the token hashes the attribute
// but example also works if hashAttributes=false
bool hashAttributes = true;
// Setting up attributes for token
byte[][] tokenAttributes = new byte[][]
{
_encoding.GetBytes("Attribute 1"),
_encoding.GetBytes("Attribute 2"),
_encoding.GetBytes("Teaching Assistant"), // this is the attribute we'll compare
_encoding.GetBytes("Attribute 4")
};
// We will prove that the target token attribute is in this set
byte[][] setValues = new byte[][]
{
_encoding.GetBytes("Teaching Assistant"),
_encoding.GetBytes("Student"),
_encoding.GetBytes("Professor"), // this is the attribute we'll compare
_encoding.GetBytes("Dean")
};
// generate token
ProverPresentationProtocolParameters prover;
VerifierPresentationProtocolParameters verifier;
StaticHelperClass.GetUProveParameters(hashAttributes, out prover, out verifier, null, tokenAttributes);
// Get random data from revocation proof
CryptoParameters crypto = new CryptoParameters(prover.IP);
SetMembershipProofGenerationRandomData randomData = SetMembershipProofGenerationRandomData.Generate(crypto.FieldZq, setValues.Length - 1);
// Create set membership proof
SetMembershipProof setProof = new SetMembershipProof(
prover, // token
3, // target attribute in token
setValues, // claim: target attribute is in this set
randomData);
// ...
// Send token and set membership proof to verifier
// ...
bool success = setProof.Verify(
verifier, // verifier token description
3, // target attribute index
setValues); // check target attribute is in this set
Assert.IsTrue(success, "Could not verify proof.");
}
public void Get_G_H_Tests()
{
for (int i = 0; i < _parameters.Length; ++i)
{
GroupElement[] bases = StaticHelperClass.GenerateRandomBases(2, i);
GroupElement value = _parameters[i].Generators[0];
ClosedPedersenCommitment ped = new ClosedPedersenCommitment(bases, value, _parameters[i].Group);
Assert.AreEqual(bases[0], ped.G, "Failed to get G.");
Assert.AreEqual(bases[1], ped.H, "Failed to get H.");
Assert.IsTrue(ped.Validate());
}
}
public void BDVerifierSerializationTest()
{
VerifierBitDecompositionParameters verifier = new VerifierBitDecompositionParameters(
_parameters[0].G, _parameters[0].Generators, _parameters[0]);
string jsonString = CryptoSerializer.Serialize <VerifierBitDecompositionParameters>(verifier);
VerifierBitDecompositionParameters deserializedVerifier = CryptoSerializer.Deserialize <VerifierBitDecompositionParameters>(jsonString);
Assert.AreEqual(verifier.Group.GroupName, deserializedVerifier.Group.GroupName);
StaticHelperClass.AssertArraysAreEqual(verifier.PublicValues, deserializedVerifier.PublicValues, "PublicValues");
StaticHelperClass.AssertArraysAreEqual <DLRepOfGroupElement>(verifier.Witnesses, deserializedVerifier.Witnesses, "Witnesses");
}
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 InequalityUProveIntegrationTestUKV()
{
// Both tokens will hash attributes
// but example also works if hashAttributes=false
bool hashAttributes = true;
// Setting up IssuerParameters for token1
byte[] uidP1 = new byte[] { 1, 1, 2, 3, 5, 8 };
byte[] tokenInformation1 = new byte[] { 1, 2, 3, 4, 5, 6, 7 };
byte[][] attributes1 = new byte[][]
{
_encoding.GetBytes("Attribute 1"),
_encoding.GetBytes("Attribute 2"),
_encoding.GetBytes("Teaching Assistant"), // this is the attribute we'll compare
_encoding.GetBytes("Attribute 4")
};
// Setting up IssuerParameters for token2
byte[] tokenInformation2 = new byte[] { 12, 13, 14, 15, 0, 10 };
byte[] uidP2 = new byte[] { 3, 1, 4, 1, 5 };
byte[][] attributes2 = new byte[][]
{
_encoding.GetBytes("Student"), // this is the attribute we'll compare
_encoding.GetBytes("Attribute 2"),
_encoding.GetBytes("Attribute 3"),
_encoding.GetBytes("Attribute 4")
};
// generate tokens
ProverPresentationProtocolParameters prover1, prover2;
VerifierPresentationProtocolParameters verifier1, verifier2;
StaticHelperClass.GetUProveParameters(hashAttributes, out prover1, out verifier1, tokenInformation1, attributes1, null, uidP1);
StaticHelperClass.GetUProveParameters(hashAttributes, out prover2, out verifier2, tokenInformation2, attributes2, null, uidP2);
// Create Inequality Proof
InequalityProof ieqProof = new InequalityProof(
prover1,
3,
prover2,
1);
// .... Send inequality proof to Verifier ....
// Verify proof
bool success = ieqProof.Verify(
verifier1,
3,
verifier2,
1);
Assert.IsTrue(success, "Could not verify proof.");
}
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 SMVerifierParamSerializationTest()
{
// prover test
VerifierSetMembershipParameters verifier = new VerifierSetMembershipParameters(_cryptoParameters.G, ValidDaysOfTheWeek, _cryptoParameters);
string jsonString = CryptoSerializer.Serialize <VerifierSetMembershipParameters>(verifier);
VerifierSetMembershipParameters deserializedVerifier = CryptoSerializer.Deserialize <ProverSetMembershipParameters>(jsonString);
Assert.AreEqual(verifier.Group.GroupName, deserializedVerifier.Group.GroupName);
StaticHelperClass.AssertArraysAreEqual(verifier.MemberSet, deserializedVerifier.MemberSet, "MemberSet");
StaticHelperClass.AssertArraysAreEqual(verifier.PublicValues, deserializedVerifier.PublicValues, "PublicValues");
StaticHelperClass.AssertArraysAreEqual <DLRepOfGroupElement>(verifier.Witnesses, deserializedVerifier.Witnesses, "Witnesses");
}
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 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 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 TokenConstructorTest()
{
// generate prover parameters using recommended parameters.
ProverPresentationProtocolParameters proverParams;
VerifierPresentationProtocolParameters verifierParams;
StaticHelperClass.GetUProveParameters(false, out proverParams, out verifierParams);
// create token
OpenUProveToken token = new OpenUProveToken(proverParams);
// get expected public key
Assert.AreEqual(proverParams.KeyAndToken.Token.H, token.PublicKey, "check public key");
Assert.IsTrue(token.Validate(null), "validate token.");
}
public static void Init(TestContext context)
{
// create parameter sets
_parameters = new CryptoParameters[6];
_parameters[0] = new CryptoParameters(ECParameterSets.ParamSet_EC_P256_V1, null);
_parameters[1] = new CryptoParameters(ECParameterSets.ParamSet_EC_P384_V1, null);
_parameters[2] = new CryptoParameters(ECParameterSets.ParamSet_EC_P521_V1, null);
_parameters[3] = new CryptoParameters(SubgroupParameterSets.ParamSetL1024N160V1, null);
_parameters[4] = new CryptoParameters(SubgroupParameterSets.ParamSetL2048N256V1, null);
_parameters[5] = new CryptoParameters(SubgroupParameterSets.ParamSetL3072N256V1, null);
// _parameters[6] = new CryptoParameters(ECParameterSets.ParamSet_EC_BN254_V1, null);
// generate prover parameters using recommended parameters.
StaticHelperClass.GetUProveParameters(true, out _proverParams, out _verifierParams);
}
public void CryptoUProveConstructorTest()
{
ProverPresentationProtocolParameters prover;
VerifierPresentationProtocolParameters verifier;
StaticHelperClass.GetUProveParameters(false, out prover, out verifier);
CryptoParameters crypto = new CryptoParameters(prover.IP);
Assert.AreEqual(prover.IP.Gq, crypto.Group);
Assert.AreEqual(prover.IP.UidH, crypto.HashFunctionName);
Assert.AreEqual(prover.IP.Gq.G, crypto.G);
Assert.AreEqual(prover.IP.G[1], crypto.H);
Assert.AreEqual(prover.IP.Zq.One, crypto.FieldZq.One);
Assert.IsTrue(crypto.Verify(), "Verify should pass.");
}
public void BDBadProverParameterTest()
{
ProverBitDecompositionParameters prover = new ProverBitDecompositionParameters(
new PedersenCommitment(_parameters[2].FieldZq.GetElement(10), _parameters[2]),
4,
_parameters[2]);
prover.Witnesses[3] = new PedersenCommitment(_parameters[2].FieldZq.GetElement(2), _parameters[2]);
StaticHelperClass.AssertThrowsException
(
() => { BitDecompositionProof proof = new BitDecompositionProof(prover); },
typeof(Exception),
"Bad prover parameters."
);
}