public DeviceConsistencyMessage(DeviceConsistencyCommitment commitment, IdentityKeyPair identityKeyPair)
{
try
{
byte[] signatureBytes = Curve.CalculateVrfSignature(identityKeyPair.GetPrivateKey(), commitment.ToByteArray());
byte[] vrfOutputBytes = Curve.VerifyVrfSignature(identityKeyPair.GetPublicKey().GetPublicKey(), commitment.ToByteArray(), signatureBytes);
_generation = commitment.GetGeneration();
_signature = new DeviceConsistencySignature(signatureBytes, vrfOutputBytes);
_serialized = SignalProtos.DeviceConsistencyCodeMessage.CreateBuilder()
.SetGeneration((uint)commitment.GetGeneration())
.SetSignature(ByteString.CopyFrom(_signature.GetSignature()))
.Build()
.ToByteArray();
}
catch (InvalidKeyException e)
{
Debug.Assert(false);
throw e;
}
catch (VrfSignatureVerificationFailedException e)
{
Debug.Assert(false);
throw e;
}
}
public DeviceConsistencyMessage(DeviceConsistencyCommitment commitment, IdentityKeyPair identityKeyPair)
{
try
{
byte[] signatureBytes = Curve.calculateVrfSignature(identityKeyPair.getPrivateKey(), commitment.toByteArray());
byte[] vrfOutputBytes = Curve.verifyVrfSignature(identityKeyPair.getPublicKey().getPublicKey(), commitment.toByteArray(), signatureBytes);
this.generation = commitment.getGeneration();
this.signature = new DeviceConsistencySignature(signatureBytes, vrfOutputBytes);
this.serialized = new DeviceConsistencyCodeMessage
{
Generation = (uint)commitment.getGeneration(),
Signature = ByteString.CopyFrom(signature.getSignature())
}.ToByteArray();
}
catch (InvalidKeyException e)
{
Debug.Assert(false);
throw e;
}
catch (VrfSignatureVerificationFailedException e)
{
Debug.Assert(false);
throw e;
}
}
private string generateCode(DeviceConsistencyCommitment commitment, params DeviceConsistencyMessage[] messages)
{
List <DeviceConsistencySignature> signatures = new List <DeviceConsistencySignature>();
foreach (DeviceConsistencyMessage message in messages)
{
signatures.Add(message.getSignature());
}
return(DeviceConsistencyCodeGenerator.generateFor(commitment, signatures));
}
public void testDeviceConsistency()
{
IdentityKeyPair deviceOne = KeyHelper.generateIdentityKeyPair();
IdentityKeyPair deviceTwo = KeyHelper.generateIdentityKeyPair();
IdentityKeyPair deviceThree = KeyHelper.generateIdentityKeyPair();
List <IdentityKey> keyList = new List <IdentityKey>(new[]
{
deviceOne.getPublicKey(),
deviceTwo.getPublicKey(),
deviceThree.getPublicKey()
});
Random random = new Random();
HelperMethods.Shuffle(keyList, random);
DeviceConsistencyCommitment deviceOneCommitment = new DeviceConsistencyCommitment(1, keyList);
HelperMethods.Shuffle(keyList, random);
DeviceConsistencyCommitment deviceTwoCommitment = new DeviceConsistencyCommitment(1, keyList);
HelperMethods.Shuffle(keyList, random);
DeviceConsistencyCommitment deviceThreeCommitment = new DeviceConsistencyCommitment(1, keyList);
CollectionAssert.AreEqual(deviceOneCommitment.toByteArray(), deviceTwoCommitment.toByteArray());
CollectionAssert.AreEqual(deviceTwoCommitment.toByteArray(), deviceThreeCommitment.toByteArray());
DeviceConsistencyMessage deviceOneMessage = new DeviceConsistencyMessage(deviceOneCommitment, deviceOne);
DeviceConsistencyMessage deviceTwoMessage = new DeviceConsistencyMessage(deviceOneCommitment, deviceTwo);
DeviceConsistencyMessage deviceThreeMessage = new DeviceConsistencyMessage(deviceOneCommitment, deviceThree);
DeviceConsistencyMessage receivedDeviceOneMessage = new DeviceConsistencyMessage(deviceOneCommitment, deviceOneMessage.getSerialized(), deviceOne.getPublicKey());
DeviceConsistencyMessage receivedDeviceTwoMessage = new DeviceConsistencyMessage(deviceOneCommitment, deviceTwoMessage.getSerialized(), deviceTwo.getPublicKey());
DeviceConsistencyMessage receivedDeviceThreeMessage = new DeviceConsistencyMessage(deviceOneCommitment, deviceThreeMessage.getSerialized(), deviceThree.getPublicKey());
CollectionAssert.AreEqual(deviceOneMessage.getSignature().getVrfOutput(), receivedDeviceOneMessage.getSignature().getVrfOutput());
CollectionAssert.AreEqual(deviceTwoMessage.getSignature().getVrfOutput(), receivedDeviceTwoMessage.getSignature().getVrfOutput());
CollectionAssert.AreEqual(deviceThreeMessage.getSignature().getVrfOutput(), receivedDeviceThreeMessage.getSignature().getVrfOutput());
string codeOne = generateCode(deviceOneCommitment, deviceOneMessage, receivedDeviceTwoMessage, receivedDeviceThreeMessage);
string codeTwo = generateCode(deviceTwoCommitment, deviceTwoMessage, receivedDeviceThreeMessage, receivedDeviceOneMessage);
string codeThree = generateCode(deviceThreeCommitment, deviceThreeMessage, receivedDeviceTwoMessage, receivedDeviceOneMessage);
Assert.AreEqual(codeOne, codeTwo);
Assert.AreEqual(codeTwo, codeThree);
}
public DeviceConsistencyMessage(DeviceConsistencyCommitment commitment, byte[] serialized, IdentityKey identityKey)
{
try
{
SignalProtos.DeviceConsistencyCodeMessage message = SignalProtos.DeviceConsistencyCodeMessage.ParseFrom(serialized);
byte[] vrfOutputBytes = Curve.VerifyVrfSignature(identityKey.GetPublicKey(), commitment.ToByteArray(), message.Signature.ToByteArray());
_generation = (int)message.Generation;
_signature = new DeviceConsistencySignature(message.Signature.ToByteArray(), vrfOutputBytes);
_serialized = serialized;
}
catch (InvalidProtocolBufferException e)
{
throw new InvalidMessageException(e);
}
catch (InvalidKeyException e)
{
throw new InvalidMessageException(e);
}
catch (VrfSignatureVerificationFailedException e)
{
throw new InvalidMessageException(e);
}
}