private static DbPersistentData ReadDatabase( Stream stream, Headers headers, byte[] masterKey) { var decrypted = FileFormat.Decrypt( stream, headers, masterKey); if (decrypted == null) { return(null); } using (decrypted) using (var buffer = new MemoryStream()) { BufferEx.CopyStream(decrypted, buffer); return(new DbPersistentData { MasterKey = masterKey, Xml = buffer.ToArray(), Protection = CryptoSerializer .Serialize(headers), }); } }
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 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 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 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 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 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 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 CryptoSerializationTest() { foreach (CryptoParameters crypto in StaticHelperClass.ParameterArray) { // serialize the parameters string serialized = CryptoSerializer.Serialize <CryptoParameters>(crypto); // deserialize the parameters CryptoParameters deserialized = CryptoSerializer.Deserialize <CryptoParameters>(serialized); Assert.IsTrue(deserialized.Verify(), "crypto parameters invalid."); Assert.AreEqual(crypto.Group.GroupName, deserialized.Group.GroupName, "Wrong group name."); Assert.AreEqual(crypto.Group.Q, deserialized.Group.Q, "wrong modulus."); Assert.AreEqual(crypto.Generators.Length, deserialized.Generators.Length, "wrong number of generators."); Assert.AreEqual(crypto.G, deserialized.G, "wrong generator G."); Assert.AreEqual(crypto.H, deserialized.H, "wrong generator H."); Assert.AreEqual(crypto.HashFunctionName, deserialized.HashFunctionName, "wrong hash function."); } }
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 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)"); }