public async Task <byte[][]> ReceiveAsync(BitArray selectionIndices, int numberOfInvocations, int numberOfMessageBytes)
{
if (selectionIndices.Length != numberOfInvocations)
{
throw new ArgumentException("Amount of selection indices must match the specified number of invocations.", nameof(selectionIndices));
}
if (_receiverState.SeededRandomOracles == null)
{
await ExecuteReceiverBaseOTAsync();
}
// note(lumip): we need a random bit matrix t as per the construction
// of Ishai et al. and we use the trick of Asharov et al. and populate it with the random
// expansion of the base OT seeds, i.e., t_k = H(seed_0). Since these are calculated later,
// we only set up the matrix structure here.
BitMatrix tTransposed = new BitMatrix((uint)SecurityParameter, (uint)numberOfInvocations);
// "perform" _securityParams many 1-out-of-2 OTs with numberOfInvocations bits message length
// by extending the _securityParams many 1-out-of-2 OTs with _securityParams bits message length
// (using the seeded random oracles)
// the purpose of these OTs is to offer to the _sender_ either a column of t or the column xor'ed with
// the selection bits of the receiver
// todo(lumip): should try-catch in case random oracle runs out
// and ideally performs new base OTs and repeat
int numberOfRandomBytes = BitArray.RequiredBytes(numberOfInvocations);
byte[][][] sendBuffer = new byte[SecurityParameter][][];
Parallel.For(0, SecurityParameter, k =>
{
BitArray tColumn = BitArray.FromBytes(
_receiverState.SeededRandomOracles[k][0].Take(numberOfRandomBytes).ToArray(),
numberOfInvocations
);
tTransposed.SetRow((uint)k, tColumn);
BitArray mask = BitArray.FromBytes(
_receiverState.SeededRandomOracles[k][1].Take(numberOfRandomBytes).ToArray(),
numberOfInvocations
);
BitArray maskedSecondOption = tColumn ^ mask ^ selectionIndices;
sendBuffer[k] = new byte[1][] { maskedSecondOption.ToBytes() };
});
await CommunicationTools.WriteOptionsAsync(Channel, sendBuffer, 1, SecurityParameter, numberOfRandomBytes);
return(await ReceiveMaskedOptionsAsync(selectionIndices, tTransposed, numberOfInvocations, numberOfMessageBytes));
}
public async Task <Pair <byte[]>[]> SendAsync(byte[][] correlationStrings, int numberOfInvocations, int numberOfMessageBytes)
{
if (correlationStrings.Length != numberOfInvocations)
{
throw new ArgumentException("Amount of provided correlation strings must match the specified number of invocations.", nameof(correlationStrings));
}
foreach (byte[] message in correlationStrings)
{
if (message.Length != numberOfMessageBytes)
{
throw new ArgumentException("The length of of at least one correlation string does not match the specified message length.", nameof(correlationStrings));
}
}
BitMatrix q = await ReceiveQMatrix(numberOfInvocations);
Debug.Assert(q.Rows == numberOfInvocations);
Debug.Assert(q.Cols == SecurityParameter);
Pair <byte[]>[] options = new Pair <byte[]> [numberOfInvocations];
byte[][][] maskedOptions = new byte[numberOfInvocations][][];
Parallel.For(0, numberOfInvocations, i =>
{
Debug.Assert(correlationStrings[i].Length == numberOfMessageBytes);
RandomOracle randomOracle = RandomOracleProvider.Create();
options[i] = new Pair <byte[]>();
BitArray qRow = q.GetRow((uint)i);
byte[] query = qRow.ToBytes();
options[i][0] = randomOracle.Invoke(query).Take(numberOfMessageBytes).ToArray();
options[i][1] = ByteBuffer.Xor(correlationStrings[i], options[i][0]);
query = (qRow ^ SenderChoices).ToBytes();
maskedOptions[i] = new[] { randomOracle.Mask(options[i][1], query) };
Debug.Assert(maskedOptions[i][0].Length == numberOfMessageBytes);
});
await CommunicationTools.WriteOptionsAsync(Channel, maskedOptions, 1, numberOfInvocations, numberOfMessageBytes);
return(options);
}
public async Task SendAsync(Pair <byte[]>[] options, int numberOfInvocations, int numberOfMessageBytes)
{
if (options.Length != numberOfInvocations)
{
throw new ArgumentException("Amount of provided option pairs must match the specified number of invocations.", nameof(options));
}
for (int j = 0; j < options.Length; ++j)
{
foreach (byte[] message in options[j])
{
if (message.Length != numberOfMessageBytes)
{
throw new ArgumentException("The length of of at least one option does not match the specified message length.", nameof(options));
}
}
}
BitMatrix q = await ReceiveQMatrix(numberOfInvocations);
Debug.Assert(q.Rows == numberOfInvocations);
Debug.Assert(q.Cols == SecurityParameter);
byte[][][] maskedOptions = new byte[numberOfInvocations][][];
Parallel.For(0, numberOfInvocations, i =>
{
maskedOptions[i] = new byte[2][];
BitArray qRow = q.GetRow((uint)i);
for (int j = 0; j < 2; ++j)
{
Debug.Assert(options[i][j].Length == numberOfMessageBytes);
if (j == 1)
{
qRow.Xor(SenderChoices);
}
byte[] query = qRow.ToBytes();
maskedOptions[i][j] = RandomOracleProvider.Create().Mask(options[i][j], query);
}
});
await CommunicationTools.WriteOptionsAsync(Channel, maskedOptions, 2, numberOfInvocations, numberOfMessageBytes);
}