/** * Queues up a value to be send to all parties (yourself included). * * @param data The value to send to all parties */ default void sendToAll(byte[] data) { for (int i = 1; i <= getNoOfParties(); i++) { send(i, data); } }
/** * Sends own opening info to others and receives others' opening info. * * @param opening own opening info */ private List<byte[]> distributeOpenings(byte[] opening) { // send (over regular network) own opening info network.sendToAll(opening); // receive opening info from others return network.receiveFromAll(); }
@Override public void sendToAll(byte[] data) { network.sendToAll(data); }
boolean receiveBroadcastValidation(Network network, byte[] digest) { //TODO: should we check that we get messages from all players? boolean validated = true; List<byte[]> digests = network.receiveFromAll(); for (byte[] d : digests) { boolean equals = Arrays.equals(d, digest); validated = validated && equals; } return validated; } }
@Override public void send(int partyId, byte[] data) { this.delegate.send(partyId, data); }
private void testMultiplePartiesReconnect(int numParties, int noOfRetries) { List<NetworkConfiguration> confs = getNetConfs(numParties); for (int i = 0; i < noOfRetries; i++) { networks = createNetworks(confs); closeNetworks(networks); } }
@Test(timeout = TWO_MINUTE_TIMEOUT_MILLIS, expected = RuntimeException.class) public void testSendAfterClose() { networks = createNetworks(3); closeNetworks(networks); networks.get(1).send(2, new byte[] {}); }
@Test(timeout = TWO_MINUTE_TIMEOUT_MILLIS, expected = RuntimeException.class) public void testReceiveAfterClose() { networks = createNetworks(3); closeNetworks(networks); networks.get(1).receive(2); }
@Override public int getNoOfParties() { return delegate.getNoOfParties(); }
@Test(expected = IllegalArgumentException.class, timeout = TWO_MINUTE_TIMEOUT_MILLIS) public void testReceiveFromNegativePartyId() { networks = createNetworks(1); networks.get(1).receive(-1); }
@Test(expected = IllegalArgumentException.class, timeout = TWO_MINUTE_TIMEOUT_MILLIS) public void testSendToNegativePartyId() { networks = createNetworks(1); networks.get(1).send(-1, new byte[] { 0x01 }); }
protected Map<Integer, CloseableNetwork> createNetworks(int numParties) { List<NetworkConfiguration> confs = getNetConfs(numParties); return createNetworks(confs); }
@Override public EvaluationStatus evaluate(int round, ResourcePoolT resourcePool, Network network) { if (round == 0) { network.sendToAll(input.clone()); return EvaluationStatus.HAS_MORE_ROUNDS; } else { result = network.receiveFromAll(); return EvaluationStatus.IS_DONE; } } }
/** * Receives digests from other parties and checks that these are consistent with own digest. */ public void receiveAndValidateDigests(byte[] ownDigest) { List<byte[]> received = network.receiveFromAll(); validateDigests(ownDigest, received); }
private byte[] sendAndReset(MessageDigest dig, Network network) { byte[] digest = dig.digest(); dig.reset(); digest[0] = (byte) 0xFF; network.sendToAll(digest); return digest; }
@Override public int getNoOfParties() { return network.getNoOfParties(); }
@Test(expected = IllegalArgumentException.class, timeout = TWO_MINUTE_TIMEOUT_MILLIS) public void testReceiveFromTooLargePartyId() { networks = createNetworks(1); networks.get(1).receive(2); }
@Test(expected = IllegalArgumentException.class, timeout = TWO_MINUTE_TIMEOUT_MILLIS) public void testSendToTooLargePartyId() { networks = createNetworks(1); networks.get(1).send(2, new byte[] { 0x01 }); }
private boolean receiveMaliciousBroadcastValidation(Network network, byte[] digest) { // TODO: should we check that we get messages from all players? boolean validated = true; List<byte[]> digests = network.receiveFromAll(); for (byte[] d : digests) { boolean equals = Arrays.equals(d, digest); validated = validated && equals; } return validated; } }