public static IEnumerator LogBasesStream(MentalState m, Expression e, ProofType pt = Proof, float timeout = -1)
{
var result = new ProofBases();
var done = new Container <bool>(false);
var startTime = Time.time;
var proofRoutine = m.StreamProofs(result, e, done, pt);
m.StartCoroutine(proofRoutine);
var waitingString = "waiting for '" + e + "' to be proved...";
var foundResult = "found partial result. go to LogBasesStream() to see it.";
var isProvedByString = "'" + e + "'" + " is proved by: ";
while (!done.Item)
{
if (startTime + timeout >= Time.time)
{
m.StopCoroutine(proofRoutine);
break;
}
// Log(waitingString);
if (!result.IsEmpty())
{
// Log(foundResult);
// Log(isProvedByString + result);
}
yield return(null);
}
Log(isProvedByString + result);
yield break;
}
public Proof(
ProofType type,
ProofType proofId,
BankAccount bankAccount)
{
Id = GetUniqueIdentifier();
Type = type;
ProofId = proofId;
BankAccount = bankAccount;
}
/// <summary>
/// Constructor. Use this constructor when the verifier does not known integerB.
/// </summary>
/// <param name="crypto">Crypto parameters</param>
/// <param name="closedIntegerA">Value of pedersen commitment to integer A</param>
/// <param name="rangeProofType">relation between integerA and integerB</param>
/// <param name="closedIntegerB">Value of pedersen commitment to integer B</param>
/// <param name="minRange">Minimum value of integerA and integerB</param>
/// <param name="maxRange">Maximum value of integerA and integerB</param>
public VerifierRangeProofParameters(CryptoParameters crypto, GroupElement closedIntegerA, ProofType rangeProofType, GroupElement closedIntegerB, int minRange, int maxRange)
: base(crypto)
{
this.setVerifierParameters(new GroupElement[] { closedIntegerA, closedIntegerB });
this.RangeProofType = rangeProofType;
this.IntegerBIsKnown = false;
this.MinValue = minRange;
this.MaxValue = maxRange;
}
private async Task <AuthResponse> handleAuthRequest(AuthRequest authRequest, ProofType type)
{
AuthResponse response = new AuthResponse();
if (authRequest.user != null)
{
var user = (await userRepository.Lookup(authRequest.user)).FirstOrDefault();
if (user == null)
{
throw new NoSuchUserException();
}
if (authRequest.profile != null)
{
var userLookup = new UserLookup();
userLookup.id = user.Id;
authRequest.profile.user = userLookup;
}
}
var profile = (await profileRepository.Lookup(authRequest.profile)).FirstOrDefault();
if (profile == null)
{
switch (type)
{
case ProofType.ProofType_NickEmail:
throw new NickInvalidException();
case ProofType.ProofType_Unique:
throw new UniqueNickInvalidException();
default:
throw new AuthInvalidCredentialsException();
}
}
UserLookup lookup = new UserLookup();
lookup.id = profile.Userid;
profile.User = profile.User ?? (await userRepository.Lookup(lookup)).FirstOrDefault();
String client_proof = GetPasswordProof(profile, authRequest, type, true);
if (!client_proof.Equals(authRequest.client_response))
{
throw new AuthInvalidCredentialsException();
}
response.server_response = GetPasswordProof(profile, authRequest, type, false);
response.profile = profile;
response.user = profile.User;
response.session = await generateSessionKey(profile);
response.success = true;
return(response);
}
public IActionResult Update(string id, ProofType item)
{
var items = _service.Get(id);
if (items == null)
{
return(NotFound());
}
_service.Update(id, item);
return(NoContent());
}
/// <summary>
/// Constructor. Use this constructor when the Verifier knows the value of integerB.
/// </summary>
/// <param name="crypto">Crypto parameters</param>
/// <param name="closedIntegerA">Committed value being compared.</param>
/// <param name="integerB">Verifier known constant being compared</param>
/// <param name="maxRange">Maximum value of committed value in closedCommitment. Used to determine length of bit decomposition.</param>
/// <param name="minRange">Minimum value of committed value in closedCommitment. Used to determine length of bit decomposition.</param>
/// <param name="proofType">Relatation between committed value in closedCommitment and integer ( less than, greater than, etc).</param>
public VerifierRangeProofParameters(CryptoParameters crypto, GroupElement closedIntegerA, ProofType rangeProofType, int integerB, int minRange, int maxRange)
: base(crypto)
{
GroupElement closedIntegerB = this.G.Exponentiate(this.FieldZq.GetElement(integerB));
this.setVerifierParameters(new GroupElement[] { closedIntegerA, closedIntegerB });
this.RangeProofType = rangeProofType;
this.IntegerBIsKnown = true;
this.IntegerB = integerB;
this.MinValue = minRange;
this.MaxValue = maxRange;
}
/// <summary>
/// Constructor. Use this constructor when the verifier DOES NOT know the value
/// of IntegerB.
/// </summary>
/// <param name="crypto">Crypto parameters.</param>
/// <param name="openIntegerA">Pedersen Commitment to integerA.</param>
/// <param name="rangeProofType">Type of range proof.</param>
/// <param name="openIntegerB">Pedersen Commitment to integerB.</param>
/// <param name="minRange">Minimum value for integerA and integerB.</param>
/// <param name="maxRange">Maximum value for integerA and integerB.</param>
public ProverRangeProofParameters(
CryptoParameters crypto,
PedersenCommitment openIntegerA,
ProofType rangeProofType,
PedersenCommitment openIntegerB,
int minRange,
int maxRange) : base(crypto)
{
this.setProverParameters(new PedersenCommitment[] { openIntegerA, openIntegerB });
this.IntegerBIsKnown = false;
this.RangeProofType = rangeProofType;
this.MinValue = minRange;
this.MaxValue = maxRange;
}
/// <summary>
/// Constructor. Use this constructor when the verifier knows the value
/// of IntegerB.
/// </summary>
/// <param name="crypto">Crypto parameters.</param>
/// <param name="openIntegerA">Pedersen Commitment to integerA.</param>
/// <param name="rangeProofType">Type of range proof.</param>
/// <param name="integerB">integerB.</param>
/// <param name="minRange">Minimum value for integerA and integerB.</param>
/// <param name="maxRange">Maximum value for integerA and integerB.</param>
public ProverRangeProofParameters(
CryptoParameters crypto,
PedersenCommitment openIntegerA,
ProofType rangeProofType,
int integerB,
int minRange,
int maxRange) : base(crypto)
{
PedersenCommitment openIntegerB = new PedersenCommitment(this.G, this.H, this.FieldZq.GetElement((uint)integerB), this.FieldZq.Zero, this.Group);
this.setProverParameters(new PedersenCommitment[] { openIntegerA, openIntegerB });
this.IntegerBIsKnown = true;
this.IntegerB = integerB;
this.RangeProofType = rangeProofType;
this.MinValue = minRange;
this.MaxValue = maxRange;
}
public ActionResult <ProofType> Create(ProofType items)
{
_service.Create(items);
return(CreatedAtRoute("GetProofType", new { id = items.Id.ToString() }, items));
}
public void Remove(ProofType itemIn)
{
_collection.DeleteOne(item => item.Id == item.Id);
}
public void Update(string id, ProofType itemIn)
{
_collection.ReplaceOne(item => item.Id == id, itemIn);
}
public ProofType Create(ProofType itemIn)
{
_collection.InsertOne(itemIn);
return(itemIn);
}
private String GetPasswordProof(Profile profile, AuthRequest request, ProofType type, bool client_to_server)
{
List <String> challenges = new List <String>();
StringBuilder sb = new StringBuilder();
string password = null;
if (profile != null && profile.User != null)
{
password = profile.User.Password;
}
switch (type)
{
case ProofType.ProofType_NickEmail:
if (profile.User.Partnercode != CoreWeb.Models.User.PARTNERID_GAMESPY)
{
sb.Append(profile.User.Partnercode.ToString());
sb.Append("@");
sb.Append(profile.Nick);
sb.Append("@");
sb.Append(profile.User.Email);
}
else
{
sb.Append(profile.Nick);
sb.Append("@");
sb.Append(profile.User.Email);
}
break;
case ProofType.ProofType_Unique:
if (profile.User.Partnercode != CoreWeb.Models.User.PARTNERID_GAMESPY)
{
sb.Append(profile.User.Partnercode.ToString());
sb.Append("@");
sb.Append(profile.Uniquenick);
}
else
{
sb.Append(profile.Uniquenick);
}
break;
case ProofType.ProofType_PreAuth:
password = request.client_response;
sb.Append(request.auth_token);
break;
case ProofType.ProofType_LoginTicket:
password = request.login_ticket;
sb.Append(request.login_ticket);
break;
}
if (client_to_server)
{
challenges.Add(request.client_challenge);
challenges.Add(request.server_challenge);
}
else
{
challenges.Add(request.server_challenge);
challenges.Add(request.client_challenge);
}
return(GetProofString(sb.ToString(), challenges, password));
}
