/// <summary>
/// Calculates the dob attribute - converting is special
/// </summary>
/// <param name="dobValue">string value of the dob attribute</param>
/// <returns>encrypted dob value</returns>
private byte[] PrepareDate(string dobValue, out int minYear, out int maxYear)
{
DateTime minBirthdate = DateTime.Today.AddYears(-120);
DateTime maxBirthdate = new DateTime(DateTime.Now.Year, 12, 31).AddYears(50);
minYear = minBirthdate.Year;
maxYear = maxBirthdate.Year;
DateTime proverDoB = DateTime.ParseExact(dobValue, "dd.MM.yyyy", System.Globalization.CultureInfo.InvariantCulture);
int encodedProverBirthday = RangeProofParameterFactory.EncodeYearAndDay(proverDoB, minBirthdate.Year);
byte[] proverBirthdayAttribute = RangeProofParameterFactory.EncodeIntAsUProveAttribute(encodedProverBirthday);
return(proverBirthdayAttribute);
}
/// <summary>
/// Generates one range proof with the given parameters
/// </summary>
/// <param name="commitmentIndex">commitmentIndex of the attribute, used for the range proof</param>
/// <param name="rangeProofType">used range proof type</param>
/// <param name="dateToVerify"></param>
/// <param name="minYear">min reference year</param>
/// <param name="maxYear">max reference year</param>
/// <param name="verifiersRangeProofId">id from the verifiers published range proof properties</param>
/// <returns>returns a json string which contains the range proof</returns>
private string GenerateRangeProof(int commitmentIndex, RangeProofType rangeProofType, DateTime dateToVerify,
int minYear, int maxYear, int verifiersRangeProofId)
{
uprove_json.Proofs.RangeProof rangeProof = parser.ParseJsonToObject <uprove_json.Proofs.RangeProof>(
ip.Serialize <UProveCrypto.PolyProof.RangeProof>(new UProveCrypto.PolyProof.RangeProof(
RangeProofParameterFactory.GetDateTimeProverParameters(
new CryptoParameters(ip),
new PedersenCommitment(pppp, ip.Deserialize <PresentationProof>(parser.ParseObjectToJson(proof)),
cpv, commitmentIndex),
rangeProofType.ProofType,
dateToVerify,
minYear,
maxYear))));
rangeProof.minBirthYear = minYear;
rangeProof.maxBirthYear = maxYear;
rangeProof.rangeProofType = rangeProofType.Value;
rangeProof.verifiersRangeProofId = verifiersRangeProofId;
rangeProof.targetDate = dateToVerify.ToString();
rangeProof.commitmentIndex = commitmentIndex;
return(parser.ParseObjectToJson(rangeProof));
}
///// <summary>
///// Init must be called first
///// Checks if the given setmembership proofs were correct - compare with the given setmembership proof settings from the verifier
///// <returns>true --> all membership proof were successfull; exception -> something went wrong</returns>
///// </summary>
//public bool VerifySetMembershipProofs(string setMembershipProofJson, VerifierMembers memberList)
//{
// try
// {
// LogService.Log(LogService.LogType.Info, "IssuingVerifier - VerifySetMembershipProofs called");
// proofVerification.IsMemberOf = memberList.Members;
// VerifyProof();
// if (!isInitialized || !proofAccepted || !tokenAccepted)
// throw new Exception("SetMembershipProof could not be proved; isInitialized:" + isInitialized
// + ", Proof verifierd:" + proofAccepted + ", Token verified:" + tokenAccepted);
// LogService.Log(LogService.LogType.Info, "IssuingVerifier - SetMembershipProof given: " + setMembershipProofJson);
// bool canContinue = false;
// Proof proof = parser.ParseJsonToObject<Proof>(proofJson);
// // check if the disclosed attribute is from the expected type (name) and disclosed -1 = committedAttribute
// for (int i = 0; i < proof.D.Count; i++)
// {
// // check if the name of the attribute is like the given member attribute name
// if (memberList.MemberAttribute ==
// parser.ParseJsonToObject<BasicClaim>(encoding.GetString(Convert.FromBase64String(proof.D[i]))).name)
// {
// if (proofRequirements.committedAttributes.Contains(proofRequirements.disclosedAttributes[i] - 1))
// {
// canContinue = true;
// LogService.Log(LogService.LogType.Info, "IssuingVerifier - Given SetMembership attribute name matches defined attribute name");
// break;
// }
// }
// }
// if (!canContinue)
// throw new Exception("Given SetMembership attribute name does not matches the expected attribute name '" + memberList.MemberAttribute + "'. ");
// byte[][] setValues = parser.ParseJsonToObject<uprove_json.Proofs.SetMembershipProof>(setMembershipProofJson).setValues;
// int commitmentIndex = parser.ParseJsonToObject<uprove_json.Proofs.SetMembershipProof>(setMembershipProofJson).commitmentIndex;
// UProveCrypto.PolyProof.SetMembershipProof setProof = IP.Deserialize<UProveCrypto.PolyProof.SetMembershipProof>(setMembershipProofJson);
// if (!UProveCrypto.PolyProof.SetMembershipProof.Verify(vppp, pProof, setProof, commitmentIndex, setValues))
// throw new Exception("SetMembership Proof failed.");
// else
// // check if it is a member of the allowed universities
// return CheckIfMemberOfAllowedMembers(setValues);
// }
// catch (Exception e)
// {
// LogService.Log(LogService.LogType.FatalError, "IssuingVerifier - VerifySetMembershipProof failed.", e);
// throw new CommunicationException("IssuingVerifier - VerifySetMembershipProof failed.", e);
// }
//}
#endregion VerifySetMembershipProofs
#region VerifyRangeProofs
/// <summary>
/// Init must called first
/// Checks if the given range proofs were correct - compare with the given range proof settings from the verifier
/// </summary>
/// <param name="rangeProofJsons">list of range proofs to check and verify</param>
/// <param name="verifierRanges">list of range proofs settings - given by the verifier
/// e.g. rangeProofJsons[x] must include settings from verifierRanges[x]</param>
/// <returns>true -> all range proofs were successfull, exception -> something went wrong</returns>
public bool VerifyRangeProofs(List <string> rangeProofJsons, List <VerifierRanges> verifierRanges)
{
try
{
LogService.Log(LogService.LogType.Info, "IssuingVerifier - VerifyRangeProofs called");
if (!isInitialized || !proofAccepted || !tokenAccepted)
{
throw new Exception("VerifyRangeProofs could not be proved; isInitialized:" + isInitialized
+ ", Proof verifierd:" + proofAccepted + ", Token verified:" + tokenAccepted);
}
int[] rangeProofAttributeMatch = new int[2];
List <int> committedAttributes = proofRequirements.committedAttributes.Select(id => id).ToList <int>();
List <int> disclosedAttributes = proofRequirements.disclosedAttributes.Select(id => id).ToList <int>();
// check if the disclosed attribute is from the expected type (name) and disclosed -1 = committedAttribute
Proof proof = parser.ParseJsonToObject <Proof>(proofJson);
if (rangeProofAttributeMatch[0] != rangeProofAttributeMatch[1])
{
throw new Exception("Given range proof attribute name does not matches the expected attribute name '"
+ "todo display range proof attributes" + "'. ");
}
uprove_json.Proofs.RangeProof rp;
VerifierRanges vr;
List <VerifierRanges> testedVRs = new List <VerifierRanges>();
foreach (string oneRangeProofJson in rangeProofJsons)
{
LogService.Log(LogService.LogType.Info, "IssuingVerifier - RangeProof given: " + oneRangeProofJson);
rp = parser.ParseJsonToObject <uprove_json.Proofs.RangeProof>(oneRangeProofJson);
vr = verifierRanges.Where(x => x.verifiersRangeProofId == rp.verifiersRangeProofId).FirstOrDefault <VerifierRanges>();
// check if there was a verifier ranges object found
if (vr == null)
{
throw new Exception("No such proof given");
}
// set this proof as tested -> check later if sibling got tested too
testedVRs.Add(vr);
// attribute == commitment attribute
if (parser.ParseJsonToObject <BasicClaim>(encoding.GetString(Convert.FromBase64String(proof.D[rp.commitmentIndex]))).name
!= vr.rangeProofAttribute)
{
throw new Exception("Attribute commitment is not matching attribute from verifiers range proof properties");
}
// rangeProofType == rangeProofType
if (rp.rangeProofType != vr.rangeProofType)
{
throw new Exception("Proof type is not matching proof tpye from verifiers range proof properties");
}
// check if target date is correct set and then check if the proof is correct
if (!(DateTime.Compare(Convert.ToDateTime(rp.targetDate), DateTime.Now.AddYears(-vr.number)) <= 0))
{
throw new Exception("TargetDate is in the wrong format (to small or large).");
}
// check range proof
UProveCrypto.PolyProof.RangeProof vRangeProof = IP.Deserialize <UProveCrypto.PolyProof.RangeProof>(oneRangeProofJson);
// and verify the range proof
if (!vRangeProof.Verify(
RangeProofParameterFactory.GetDateTimeVerifierParameters(
new CryptoParameters(IP),
new ClosedPedersenCommitment(IP, pProof, rp.commitmentIndex).Value,
//(VerifierRangeProofParameters.ProofType)
RangeProofType.GetType(rp.rangeProofType).ProofType,
Convert.ToDateTime(rp.targetDate),
rp.minBirthYear,
rp.maxBirthYear)))
{
throw new Exception("RangeProof failed");
}
LogService.Log(LogService.LogType.Info, "IssuingVerifier - RangeProof passed tests");
}
// check siblings
CheckSiblings(testedVRs);
return(true);
}
catch (Exception e)
{
LogService.Log(LogService.LogType.FatalError, "IssuingVerifier - Verifing range proof failed.", e);
throw new CommunicationException("IssuingVerifier - Verifing range proof failed.", e);
}
}
