private void RunNSenders(
int n, int f,
DeliveryServiceMode mode = DeliveryServiceMode.TAKE_RANDOM,
double repeatProbability = .0
)
{
SetUpAllHonestNSenders(n, f);
_deliveryService.RepeatProbability = repeatProbability;
_deliveryService.Mode = mode;
var rnd = new Random();
var mutePlayers = new List <int>();
while (_deliveryService.MutedPlayers.Count < f)
{
var tmp = rnd.Next(0, n);
_deliveryService.MutePlayer(tmp);
mutePlayers.Add(tmp);
}
for (var i = 0; i < n; ++i)
{
_broadcasters[i].InternalRequest(new ProtocolRequest <ReliableBroadcastId, EncryptedShare?>
(_resultInterceptors[i].Id, new ReliableBroadcastId(i, 0), _testShare));
for (var j = 0; j < n; ++j)
{
if (j == i)
{
continue;
}
_broadcasters[i].InternalRequest(new ProtocolRequest <ReliableBroadcastId, EncryptedShare?>
(_resultInterceptors[i].Id, new ReliableBroadcastId(j, 0), null));
}
}
for (var i = 0; i < n; ++i)
{
if (!mutePlayers.Contains(i))
{
_broadcasts[i].WaitFinish();
}
}
for (var i = 0; i < n; ++i)
{
if (!mutePlayers.Contains(i))
{
Assert.AreEqual(_testShare, _resultInterceptors[i].Result);
}
}
for (var i = 0; i < n; ++i)
{
if (!mutePlayers.Contains(i))
{
Assert.IsTrue(_broadcasts[i].Terminated, $"protocol {i} did not terminate");
}
}
}
private void TestAllCommonSubset(int n, int f, DeliveryServiceMode mode = DeliveryServiceMode.TAKE_FIRST)
{
SetUpAllHonest(n, f);
_deliveryService.Mode = mode;
var inputs = new List <EncryptedShare>();
var rnd = new byte[32];
_rnd.NextBytes(rnd);
for (var i = 0; i < n; ++i)
{
var testShare = new EncryptedShare(G1.Generator, rnd, G2.Generator, i);
inputs.Add(testShare);
_broadcasters[i].InternalRequest(new ProtocolRequest <CommonSubsetId, EncryptedShare>(
_resultInterceptors[i].Id, (_acs[i].Id as CommonSubsetId) !, testShare
));
}
for (var i = 0; i < n; ++i)
{
if (_deliveryService.MutedPlayers.Contains(i))
{
continue;
}
_acs[i].WaitResult();
}
_deliveryService.WaitFinish();
for (var i = 0; i < n; ++i)
{
_broadcasters[i].Terminate();
foreach (var id in _broadcasters[i].Registry.Keys)
{
Assert.NotNull(id);
var protocol = _broadcasters[i].GetProtocolById(id);
if (protocol == null)
{
continue;
}
protocol.Terminate();
protocol.WaitFinish();
}
}
var outputs = new List <ISet <EncryptedShare> >();
for (var i = 0; i < n; ++i)
{
Assert.IsTrue(_acs[i].Terminated, $"protocol {i} did not terminated");
Assert.AreEqual(_resultInterceptors[i].ResultSet, 1,
$"protocol {i} has emitted result not once but {_resultInterceptors[i].ResultSet}");
Assert.AreEqual(n, _resultInterceptors[i].Result.Count);
outputs.Add(_resultInterceptors[i].Result);
}
CheckOutput(n, f, inputs.ToArray(), outputs.ToArray());
}
public void RunBinaryAgreementRandom(
int n, int f, DeliveryServiceMode mode,
int muteCnt = 0, double repeatProbability = .0
)
{
SetUpAllHonest(n, f);
_deliveryService.RepeatProbability = repeatProbability;
_deliveryService.Mode = mode;
while (_deliveryService.MutedPlayers.Count < muteCnt)
{
_deliveryService.MutePlayer(_rnd.Next(0, n));
}
var used = new BoolSet();
for (var i = 0; i < n; ++i)
{
var cur = _rnd.Next() % 2 == 1;
used = used.Add(cur);
_broadcasters[i].InternalRequest(new ProtocolRequest <BinaryAgreementId, bool>(
_resultInterceptors[i].Id, (_broadcasts[i].Id as BinaryAgreementId) !, cur
));
}
for (var i = 0; i < n; ++i)
{
if (_deliveryService.MutedPlayers.Contains(i))
{
continue;
}
_broadcasts[i].WaitResult();
}
_deliveryService.WaitFinish();
for (var i = 0; i < n; ++i)
{
if (_deliveryService.MutedPlayers.Contains(i))
{
continue;
}
Assert.AreEqual(
_resultInterceptors[i].ResultSet, 1,
$"protocol has {i} emitted result not once but {_resultInterceptors[i].ResultSet}"
);
}
bool?res = null;
for (var i = 0; i < n; ++i)
{
if (_deliveryService.MutedPlayers.Contains(i))
{
continue;
}
var ans = _resultInterceptors[i].Result;
res ??= ans;
Assert.AreEqual(res, _resultInterceptors[i].Result);
}
Assert.IsNotNull(res);
Assert.True(used.Contains(res !.Value));
for (var i = 0; i < n; ++i)
{
_broadcasts[i].Terminate();
_broadcasts[i].WaitFinish();
}
}
private static ThresholdKeyring[] SimulateKeygen(int n, int f, DeliveryServiceMode mode)
{
var ecdsaKeys = Enumerable.Range(0, n)
.Select(_ => Crypto.GeneratePrivateKey())
.Select(x => x.ToPrivateKey())
.Select(x => new EcdsaKeyPair(x))
.ToArray();
var keyGens = Enumerable.Range(0, n)
.Select(i => new TrustlessKeygen(ecdsaKeys[i], ecdsaKeys.Select(x => x.PublicKey), f, 0))
.ToArray();
var messageLedger = new RandomSamplingQueue <QueueItem>();
messageLedger.Enqueue(new QueueItem(-1, null));
var curKeys = keyGens.Select(_ => (ThresholdKeyring?)null).ToArray();
while (messageLedger.Count > 0)
{
QueueItem?msg;
var success = mode switch
{
DeliveryServiceMode.TAKE_FIRST => messageLedger.TryDequeue(out msg),
DeliveryServiceMode.TAKE_LAST => messageLedger.TryTakeLast(out msg),
DeliveryServiceMode.TAKE_RANDOM => messageLedger.TrySample(out msg),
_ => throw new NotImplementedException($"Unknown mode {mode}")
};
Assert.IsTrue(success);
switch (msg?.payload)
{
case null:
for (var i = 0; i < n; ++i)
{
messageLedger.Enqueue(new QueueItem(i, keyGens[i].StartKeygen()));
}
break;
case CommitMessage commitMessage:
for (var i = 0; i < n; ++i)
{
messageLedger.Enqueue(new QueueItem(i, keyGens[i].HandleCommit(msg.sender, commitMessage)));
}
break;
case ValueMessage valueMessage:
for (var i = 0; i < n; ++i)
{
keyGens[i].HandleSendValue(msg.sender, valueMessage);
}
break;
default:
Assert.Fail($"Message of type {msg.GetType()} occurred");
break;
}
for (var i = 0; i < n; ++i)
{
var curKey = keyGens[i].TryGetKeys();
if (curKey is null)
{
Assert.AreEqual(null, curKeys[i]);
continue;
}
if (!curKeys[i].HasValue)
{
curKeys[i] = curKey;
continue;
}
Assert.IsTrue(curKey.Value.TpkePrivateKey.ToBytes()
.SequenceEqual(curKeys[i] !.Value.TpkePrivateKey.ToBytes()));
Assert.AreEqual(curKey.Value.PublicPartHash(), curKeys[i] !.Value.PublicPartHash());
}
for (var i = 0; i < n; ++i)
{
keyGens[i] = TestSerializationRoundTrip(keyGens[i], ecdsaKeys[i]);
}
}
for (var i = 0; i < n; ++i)
{
Assert.IsTrue(keyGens[i].Finished());
Assert.AreNotEqual(curKeys[i], null);
}
var keys = keyGens
.Select(x => x.TryGetKeys() ?? throw new Exception())
.ToArray();
for (var i = 0; i < n; ++i)
{
Assert.AreEqual(keys[0].TpkePublicKey, keys[i].TpkePublicKey);
Assert.AreEqual(keys[0].ThresholdSignaturePublicKeySet, keys[i].ThresholdSignaturePublicKeySet);
}
return(keys);
}
