private static async Task RunSecureComputationPartyAsync(int localPartyId, BitArray localInput)
{
Console.WriteLine($"Starting party {localPartyId}...");
using IMultiPartyNetworkSession session = await TcpMultiPartyNetworkSession.EstablishLoopbackAsync(
new Party (localPartyId),
StartPort,
NumberOfParties
);
using CryptoContext cryptoContext = CryptoContext.CreateDefault();
IObliviousTransfer obliviousTransfer = new NaorPinkasObliviousTransfer(
SecurityParameters.CreateDefault768Bit(),
cryptoContext
);
IMultiplicativeSharing multiplicativeSharing = new ObliviousTransferMultiplicativeSharing(
obliviousTransfer,
cryptoContext
);
SecretSharingSecureComputation computation = new SecretSharingSecureComputation(
session,
multiplicativeSharing,
cryptoContext
);
Stopwatch stopwatch = Stopwatch.StartNew();
SetIntersectionSecureProgram secureProgram = new SetIntersectionSecureProgram(NumberOfParties, NumberOfElements);
object[] outputPrimitives = await secureProgram.EvaluateAsync(computation, new object[] { localInput });
BitArray intersection = (BitArray)outputPrimitives[0];
BigInteger count = (BigInteger)outputPrimitives[1];
stopwatch.Stop();
Console.WriteLine();
Console.WriteLine($"Completed protocol as {session.LocalParty.Name} in {stopwatch.ElapsedMilliseconds} ms.");
Console.WriteLine($" Local input: {localInput.ToBinaryString()}");
Console.WriteLine($" Computed intersection: {intersection.ToBinaryString()}");
Console.WriteLine($" Computed number of matches: {count}");
Console.WriteLine();
Console.WriteLine("Press any key to exit.");
Console.ReadKey(true);
}
public void TestTcpMultiPartyNetworkSession()
{
Task <TcpMultiPartyNetworkSession> firstSessionTask = CreateMultiPartySessionAsync(FirstParty, 3);
Task <TcpMultiPartyNetworkSession> secondSessionTask = CreateMultiPartySessionAsync(SecondParty, 3);
Task <TcpMultiPartyNetworkSession> thirdSessionTask = CreateMultiPartySessionAsync(ThirdParty, 3);
using TcpMultiPartyNetworkSession firstSession = firstSessionTask.Result;
using TcpMultiPartyNetworkSession secondSession = secondSessionTask.Result;
using TcpMultiPartyNetworkSession thirdSession = thirdSessionTask.Result;
Assert.AreEqual(FirstParty, firstSession.LocalParty);
Assert.AreEqual(SecondParty, secondSession.LocalParty);
Assert.AreEqual(ThirdParty, thirdSession.LocalParty);
EnumerableAssert.AreEquivalent(new[] { SecondParty, ThirdParty }, GetRemoteParties(firstSession));
EnumerableAssert.AreEquivalent(new[] { FirstParty, ThirdParty }, GetRemoteParties(secondSession));
EnumerableAssert.AreEquivalent(new[] { FirstParty, SecondParty }, GetRemoteParties(thirdSession));
}
public void TestTcpMultiPartyNetworkSession()
{
Task <TcpMultiPartyNetworkSession> firstSessionTask = TcpMultiPartyNetworkSession.EstablishAsync(FirstParty, IPAddress.Loopback, Port, 3);
Task <TcpMultiPartyNetworkSession> secondSessionTask = TcpMultiPartyNetworkSession.EstablishAsync(SecondParty, IPAddress.Loopback, Port, 3);
Task <TcpMultiPartyNetworkSession> thirdSessionTask = TcpMultiPartyNetworkSession.EstablishAsync(ThirdParty, IPAddress.Loopback, Port, 3);
TcpMultiPartyNetworkSession firstSession = firstSessionTask.Result;
TcpMultiPartyNetworkSession secondSession = secondSessionTask.Result;
TcpMultiPartyNetworkSession thirdSession = thirdSessionTask.Result;
Assert.AreEqual(FirstParty, firstSession.LocalParty);
Assert.AreEqual(SecondParty, secondSession.LocalParty);
Assert.AreEqual(ThirdParty, thirdSession.LocalParty);
CollectionAssert.AreEquivalent(new[] { SecondParty, ThirdParty }, firstSession.RemotePartySessions.Select(session => session.RemoteParty).ToArray());
CollectionAssert.AreEquivalent(new[] { FirstParty, ThirdParty }, secondSession.RemotePartySessions.Select(session => session.RemoteParty).ToArray());
CollectionAssert.AreEquivalent(new[] { FirstParty, SecondParty }, thirdSession.RemotePartySessions.Select(session => session.RemoteParty).ToArray());
firstSessionTask.Dispose();
secondSessionTask.Dispose();
thirdSession.Dispose();
}
public static void RunMultiPartyNetwork(int numberOfParties, Action <IMultiPartyNetworkSession> perPartyAction)
{
IEnumerable <Task <TcpMultiPartyNetworkSession> > sessionTasks = Enumerable
.Range(0, numberOfParties)
.Select(partyId => TcpMultiPartyNetworkSession.EstablishLoopbackAsync(new Party(partyId), Port, numberOfParties));
RunNetwork(sessionTasks, perPartyAction);
}
private static Task <TcpMultiPartyNetworkSession> CreateMultiPartySessionAsync(Party party, int numberOfParties)
{
return(TcpMultiPartyNetworkSession.EstablishLoopbackAsync(party, Port, numberOfParties));
}
public static IMultiPartyNetworkSession EstablishMultiParty(int localPartyId, int numberOfParties)
{
return(TcpMultiPartyNetworkSession.EstablishAsync(new Party(localPartyId), IPAddress.Loopback, Port, numberOfParties).Result);
}
private static IMultiPartyNetworkSession CreateLocalSession(int localPartyId, int startPort, int numberOfParties)
{
return(TcpMultiPartyNetworkSession.EstablishAsync(new Party(localPartyId), IPAddress.Loopback, StartPort, NumberOfParties).Result);
}
