public void TestRequiredBytes()
{
Assert.AreEqual(0, BitQuadrupleArray.RequiredBytes(0));
Assert.AreEqual(1, BitQuadrupleArray.RequiredBytes(1));
Assert.AreEqual(1, BitQuadrupleArray.RequiredBytes(2));
Assert.AreEqual(2, BitQuadrupleArray.RequiredBytes(3));
}
public Task <PreprocessedSenderBatch> PreprocessSenderAsync(IMessageChannel channel, int numberOfInvocations)
{
byte[] randomOptionsBuffer = _randomNumberGenerator.GetBytes(BitQuadrupleArray.RequiredBytes(numberOfInvocations));
BitQuadrupleArray randomOptions = BitQuadrupleArray.FromBytes(randomOptionsBuffer, numberOfInvocations);
return(_obliviousTransfer.SendAsync(channel, randomOptions, numberOfInvocations)
.ContinueWith(task => new PreprocessedSenderBatch(randomOptions)));
}
private Quadruple <byte[]>[] ToOptionMessages(BitQuadrupleArray options)
{
Quadruple <byte[]>[] optionMessages = new Quadruple <byte[]> [options.Length];
for (int i = 0; i < optionMessages.Length; ++i)
{
optionMessages[i] = new Quadruple <byte[]>(
new[] { (byte)options[i][0] },
new[] { (byte)options[i][1] },
new[] { (byte)options[i][2] },
new[] { (byte)options[i][3] }
);
}
return(optionMessages);
}
public void TestByteConversion()
{
BitQuadrupleArray array = new BitQuadrupleArray(new[] {
new BitQuadruple(Bit.Zero, Bit.One, Bit.One, Bit.Zero),
new BitQuadruple(Bit.One, Bit.One, Bit.Zero, Bit.One),
new BitQuadruple(Bit.Zero, Bit.One, Bit.Zero, Bit.One)
});
array[1] = new BitQuadruple(Bit.One, Bit.Zero, Bit.One, Bit.One);
byte[] buffer = array.ToBytes();
Assert.AreEqual(3, array.Length);
Assert.AreEqual(2, buffer.Length);
Assert.AreEqual((byte)Convert.ToInt32("11010110", 2), buffer[0]);
Assert.AreEqual((byte)Convert.ToInt32("00001010", 2), buffer[1]);
}
public async Task <BitArray> ReceiveAsync(IMessageChannel channel, QuadrupleIndexArray selectionIndices, int numberOfInvocations)
{
if (selectionIndices.Length != numberOfInvocations)
{
throw new ArgumentException("Provided selection indices must match the specified number of invocations.", nameof(selectionIndices));
}
if (_receiverBatch == null || _nextReceiverInstanceId + numberOfInvocations > _receiverBatch.NumberOfInstances)
{
throw new InvalidOperationException("Not enough preprocessed receiver data available.");
}
QuadrupleIndexArray deltaSelectionIndices = new QuadrupleIndexArray(numberOfInvocations);
for (int i = 0; i < numberOfInvocations; ++i)
{
int deltaSelectionIndex = (_receiverBatch.GetSelectionIndex(_nextReceiverInstanceId + i) - selectionIndices[i] + 4) % 4;
deltaSelectionIndices[i] = deltaSelectionIndex;
}
await channel.WriteMessageAsync(deltaSelectionIndices.ToBytes());
byte[] packedMaskedOptionQuadruples = await channel.ReadMessageAsync();
if (packedMaskedOptionQuadruples.Length != BitQuadrupleArray.RequiredBytes(numberOfInvocations))
{
throw new DesynchronizationException("Received incorrect number of masked option quadruples.");
}
BitQuadrupleArray maskedOptionQuadruples = BitQuadrupleArray.FromBytes(packedMaskedOptionQuadruples, numberOfInvocations);
BitArray selectedBits = new BitArray(numberOfInvocations);
for (int i = 0; i < numberOfInvocations; ++i)
{
BitQuadruple maskedOptions = maskedOptionQuadruples[i];
selectedBits[i] = maskedOptions[selectionIndices[i]] ^ _receiverBatch.GetSelectedOption(_nextReceiverInstanceId + i);
}
_nextReceiverInstanceId += numberOfInvocations;
return(selectedBits);
}
private async Task <BitArray> ComputeSenderSharesAsync(IMessageChannel channel, BitArray leftShares, BitArray rightShares, int numberOfInvocations)
{
BitArray randomShares = _randomNumberGenerator.GetBits(numberOfInvocations);
BitQuadrupleArray options = new BitQuadrupleArray(numberOfInvocations);
for (int i = 0; i < numberOfInvocations; ++i)
{
options[i] = new BitQuadruple(
randomShares[i], // 00
randomShares[i] ^ leftShares[i], // 01
randomShares[i] ^ rightShares[i], // 10
randomShares[i] ^ leftShares[i] ^ rightShares[i] // 11
);
}
await _obliviousTransfer.SendAsync(channel, options, numberOfInvocations);
return(randomShares);
}
public async Task SendAsync(IMessageChannel channel, BitQuadrupleArray options, int numberOfInvocations)
{
if (options.Length != numberOfInvocations)
{
throw new ArgumentException("Provided options must match the specified number of invocations.", nameof(options));
}
if (_senderBatch == null || _nextSenderInstanceId + numberOfInvocations > _senderBatch.NumberOfInstances)
{
throw new InvalidOperationException("Not enough preprocessed sender data available.");
}
byte[] packedDeltaSelectionIndices = await channel.ReadMessageAsync();
if (packedDeltaSelectionIndices.Length != QuadrupleIndexArray.RequiredBytes(numberOfInvocations))
{
throw new DesynchronizationException("Received incorrect number of delta selection indices.");
}
QuadrupleIndexArray deltaSelectionIndices = QuadrupleIndexArray.FromBytes(packedDeltaSelectionIndices, numberOfInvocations);
BitQuadrupleArray maskedOptionQuadruples = new BitQuadrupleArray(numberOfInvocations);
for (int i = 0; i < numberOfInvocations; ++i)
{
int deltaSelectionIndex = deltaSelectionIndices[i];
BitQuadruple preprocessedOptions = _senderBatch.GetOptions(_nextSenderInstanceId + i);
BitQuadruple unmaskedOptions = options[i];
BitQuadruple maskedOptions = new BitQuadruple(
unmaskedOptions[0] ^ preprocessedOptions[(0 + deltaSelectionIndex) % 4],
unmaskedOptions[1] ^ preprocessedOptions[(1 + deltaSelectionIndex) % 4],
unmaskedOptions[2] ^ preprocessedOptions[(2 + deltaSelectionIndex) % 4],
unmaskedOptions[3] ^ preprocessedOptions[(3 + deltaSelectionIndex) % 4]
);
maskedOptionQuadruples[i] = maskedOptions;
}
await channel.WriteMessageAsync(maskedOptionQuadruples.ToBytes());
_nextSenderInstanceId += numberOfInvocations;
}
public Task SendAsync(IMessageChannel channel, BitQuadrupleArray options, int numberOfInvocations)
{
return(SendAsync(channel, ToOptionMessages(options), numberOfInvocations, 1));
}
public PreprocessedSenderBatch(BitQuadrupleArray options)
{
_options = options;
}