public void BDSerializationTest()
{
FieldZqElement bigNum = _parameters[0].FieldZq.GetElement(2056);
PedersenCommitment bigNumCommit = new PedersenCommitment(bigNum, _parameters[0]);
int decompositionLength = 15;
ProverBitDecompositionParameters prover = new ProverBitDecompositionParameters(
bigNumCommit,
decompositionLength,
_parameters[0]);
BitDecompositionProof proof = new BitDecompositionProof(prover);
Assert.IsTrue(proof.Verify(prover), "original proof verification.");
string jsonProof = CryptoSerializer.Serialize <BitDecompositionProof>(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;
BitDecompositionProof deserializedProof = ip.Deserialize <BitDecompositionProof>(jsonProof);// CryptoSerializer.Deserialize<BitDecompositionProof>(jsonProof);
Assert.IsTrue(deserializedProof.Verify(prover), "deserialized proof verfication");
string jsonProver = CryptoSerializer.Serialize <ProverBitDecompositionParameters>(prover);
ProverBitDecompositionParameters deserializedProver = CryptoSerializer.Deserialize <ProverBitDecompositionParameters>(jsonProver);
Assert.IsTrue(deserializedProof.Verify(deserializedProver), "deserialized proof with deserialized prover.");
BitDecompositionProof proof2 = new BitDecompositionProof(deserializedProver);
Assert.IsTrue(proof2.Verify(deserializedProver), "proof2.verify(deserializedProver)");
Assert.IsTrue(proof2.Verify(prover), "Proof2.verify(prover)");
}
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 CSChangeGroupTest()
{
CryptoParameters crypto1 = StaticHelperClass.ParameterArray[4];
ProverSetMembershipParameters prover1 = new ProverSetMembershipParameters(crypto1);
FieldZqElement[] memberSet1 = crypto1.FieldZq.GetRandomElements(10, true);
prover1.setProverParameters(memberSet1[0], memberSet1);
SetMembershipProof proof1 = new SetMembershipProof(prover1);
string serialized1 = CryptoSerializer.Serialize <SetMembershipProof>(proof1);
SetMembershipProof output1 = CryptoSerializer.Deserialize <SetMembershipProof>(serialized1);
Assert.IsTrue(output1.Verify(prover1), "output1");
CryptoParameters crypto2 = StaticHelperClass.ParameterArray[3];
ProverSetMembershipParameters prover2 = new ProverSetMembershipParameters(crypto2);
FieldZqElement[] memberSet2 = crypto2.FieldZq.GetRandomElements(10, true);
prover2.setProverParameters(memberSet2[0], memberSet2);
SetMembershipProof proof2 = new SetMembershipProof(prover2);
string serialized2 = CryptoSerializer.Serialize <SetMembershipProof>(proof2);
SetMembershipProof output2 = CryptoSerializer.Deserialize <SetMembershipProof>(serialized2);
Assert.IsTrue(output2.Verify(prover2), "output2");
}
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 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 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 InequalityProofSerializationTest()
{
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);
ProverInequalityProofParameters prover = new ProverInequalityProofParameters(X, Y, crypto);
InequalityProof proof = new InequalityProof(prover);
string json = CryptoSerializer.Serialize <InequalityProof>(proof);
InequalityProof deserialized = CryptoSerializer.Deserialize <InequalityProof>(json);
Assert.IsTrue(proof.Verify(prover), "Verify proof");
Assert.AreEqual(proof.A, deserialized.A, "A");
Assert.AreEqual(proof.B, deserialized.B, "B");
prover = new ProverInequalityProofParameters(X, y, crypto);
proof = new InequalityProof(prover);
json = CryptoSerializer.Serialize <InequalityProof>(proof);
deserialized = CryptoSerializer.Deserialize <InequalityProof>(json);
Assert.IsTrue(proof.Verify(prover), "Verify proof");
Assert.AreEqual(proof.A, deserialized.A, "A");
Assert.AreEqual(proof.B, deserialized.B, "B");
}
}
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 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 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 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 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 TokenSerializationTest()
{
// generate prover parameters using recommended parameters.
ProverPresentationProtocolParameters proverParams;
VerifierPresentationProtocolParameters verifierParams;
StaticHelperClass.GetUProveParameters(false, out proverParams, out verifierParams);
// create token
OpenUProveToken token = new OpenUProveToken(proverParams);
// Serialize token
string serialized = CryptoSerializer.Serialize <OpenUProveToken>(token);
OpenUProveToken newToken = CryptoSerializer.Deserialize <OpenUProveToken>(serialized, null, token.G);
Assert.AreEqual(token, newToken, "token");
}
public void BDProverSerializationTest()
{
FieldZqElement bigNum = _parameters[0].FieldZq.GetElement(2056);
PedersenCommitment bigNumCommit = new PedersenCommitment(bigNum, _parameters[0]);
int decompositionLength = 15;
ProverBitDecompositionParameters prover = new ProverBitDecompositionParameters(
bigNumCommit,
decompositionLength,
_parameters[0]);
string jsonString = CryptoSerializer.Serialize <ProverBitDecompositionParameters>(prover);
ProverBitDecompositionParameters deserializedProver = CryptoSerializer.Deserialize <ProverBitDecompositionParameters>(jsonString);
Assert.AreEqual(prover.Group.GroupName, deserializedProver.Group.GroupName);
StaticHelperClass.AssertArraysAreEqual(prover.PublicValues, deserializedProver.PublicValues, "PublicValues");
StaticHelperClass.AssertArraysAreEqual <DLRepOfGroupElement>(prover.Witnesses, deserializedProver.Witnesses, "Witnesses");
}
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 CSGenericBadSerializationTest()
{
StaticHelperClass.AssertThrowsException(
() => { CryptoSerializer.Deserialize <SetMembershipProof>("bad jsonString"); },
typeof(SerializationException),
"deserialization");
ProverSetMembershipParameters prover = new ProverSetMembershipParameters(crypto);
FieldZqElement [] memberSet = crypto.FieldZq.GetRandomElements(10, true);
prover.setProverParameters(memberSet[0], memberSet);
SetMembershipProof proof = new SetMembershipProof(prover);
PrivateObject proofAccessor = new PrivateObject(proof);
proofAccessor.SetProperty("c", null);
StaticHelperClass.AssertThrowsException(
() => { CryptoSerializer.Serialize <SetMembershipProof>(proof); },
typeof(SerializationException),
"serialization");
}
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 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 EQMapSerializationTest()
{
int length = 20;
// 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)
);
}
string jsonString = CryptoSerializer.Serialize <EqualityMap>(map);
EqualityMap deserializedMap = CryptoSerializer.Deserialize <EqualityMap>(jsonString);
byte[] hash1 = map.Hash(DefaultHashFunction);
byte[] hash2 = deserializedMap.Hash(DefaultHashFunction);
StaticHelperClass.AssertArraysAreEqual(hash1, hash2, "hash of deserialized map.");
}
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)");
}
