Refactor KeyManager and TagRecogniser. #55

briar-tests/src/org/briarproject/ProtocolIntegrationTest.java

@@ -10,6 +10,7 @@ import org.briarproject.api.TransportId;
 import org.briarproject.api.TransportProperties;
 import org.briarproject.api.crypto.CryptoComponent;
 import org.briarproject.api.crypto.KeyPair;
+import org.briarproject.api.crypto.SecretKey;
 import org.briarproject.api.messaging.Ack;
 import org.briarproject.api.messaging.Group;
 import org.briarproject.api.messaging.GroupFactory;
@@ -44,7 +45,6 @@ import java.io.OutputStream;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
-import java.util.Random;
 
 import static org.briarproject.api.transport.TransportConstants.TAG_LENGTH;
 import static org.junit.Assert.assertArrayEquals;
@@ -61,14 +61,9 @@ public class ProtocolIntegrationTest extends BriarTestCase {
 	private final MessageVerifier messageVerifier;
 
 	private final ContactId contactId;
-	private final byte[] secret;
-	private final Author author;
+	private final SecretKey tagKey, headerKey;
 	private final Group group;
 	private final Message message, message1;
-	private final String authorName = "Alice";
-	private final String contentType = "text/plain";
-	private final long timestamp = System.currentTimeMillis();
-	private final String messageBody = "Hello world";
 	private final Collection<MessageId> messageIds;
 	private final TransportId transportId;
 	private final TransportProperties transportProperties;
@@ -85,9 +80,9 @@ public class ProtocolIntegrationTest extends BriarTestCase {
 		packetWriterFactory = i.getInstance(PacketWriterFactory.class);
 		messageVerifier = i.getInstance(MessageVerifier.class);
 		contactId = new ContactId(234);
-		// Create a shared secret
-		secret = new byte[32];
-		new Random().nextBytes(secret);
+		// Create the transport keys
+		tagKey = TestUtils.createSecretKey();
+		headerKey = TestUtils.createSecretKey();
 		// Create a group
 		GroupFactory groupFactory = i.getInstance(GroupFactory.class);
 		group = groupFactory.createGroup("Group");
@@ -95,12 +90,15 @@ public class ProtocolIntegrationTest extends BriarTestCase {
 		AuthorFactory authorFactory = i.getInstance(AuthorFactory.class);
 		CryptoComponent crypto = i.getInstance(CryptoComponent.class);
 		KeyPair authorKeyPair = crypto.generateSignatureKeyPair();
-		author = authorFactory.createAuthor(authorName,
+		Author author = authorFactory.createAuthor("Alice",
 				authorKeyPair.getPublic().getEncoded());
 		// Create two messages to the group: one anonymous, one pseudonymous
 		MessageFactory messageFactory = i.getInstance(MessageFactory.class);
+		String contentType = "text/plain";
+		long timestamp = System.currentTimeMillis();
+		String messageBody = "Hello world";
 		message = messageFactory.createAnonymousMessage(null, group,
-				contentType, timestamp, messageBody.getBytes("UTF-8"));
+				"text/plain", timestamp, messageBody.getBytes("UTF-8"));
 		message1 = messageFactory.createPseudonymousMessage(null, group,
 				author, authorKeyPair.getPrivate(), contentType, timestamp,
 				messageBody.getBytes("UTF-8"));
@@ -118,8 +116,8 @@ public class ProtocolIntegrationTest extends BriarTestCase {
 
 	private byte[] write() throws Exception {
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
-		StreamContext ctx = new StreamContext(contactId, transportId, secret,
-				0, true);
+		StreamContext ctx = new StreamContext(contactId, transportId, tagKey,
+				headerKey, 0);
 		OutputStream streamWriter =
 				streamWriterFactory.createStreamWriter(out, ctx);
 		PacketWriter packetWriter = packetWriterFactory.createPacketWriter(
@@ -134,7 +132,8 @@ public class ProtocolIntegrationTest extends BriarTestCase {
 
 		packetWriter.writeRequest(new Request(messageIds));
 
-		SubscriptionUpdate su = new SubscriptionUpdate(Arrays.asList(group), 1);
+		SubscriptionUpdate su = new SubscriptionUpdate(
+				Collections.singletonList(group), 1);
 		packetWriter.writeSubscriptionUpdate(su);
 
 		TransportUpdate tu = new TransportUpdate(transportId,
@@ -150,8 +149,8 @@ public class ProtocolIntegrationTest extends BriarTestCase {
 		byte[] tag = new byte[TAG_LENGTH];
 		assertEquals(TAG_LENGTH, in.read(tag, 0, TAG_LENGTH));
 		// FIXME: Check that the expected tag was received
-		StreamContext ctx = new StreamContext(contactId, transportId, secret,
-				0, false);
+		StreamContext ctx = new StreamContext(contactId, transportId, tagKey,
+				headerKey, 0);
 		InputStream streamReader =
 				streamReaderFactory.createStreamReader(in, ctx);
 		PacketReader packetReader = packetReaderFactory.createPacketReader(
@@ -184,7 +183,7 @@ public class ProtocolIntegrationTest extends BriarTestCase {
 		// Read the subscription update
 		assertTrue(packetReader.hasSubscriptionUpdate());
 		SubscriptionUpdate su = packetReader.readSubscriptionUpdate();
-		assertEquals(Arrays.asList(group), su.getGroups());
+		assertEquals(Collections.singletonList(group), su.getGroups());
 		assertEquals(1, su.getVersion());
 
 		// Read the transport update

briar-tests/src/org/briarproject/TestUtils.java

@@ -7,6 +7,9 @@ import java.io.File;
 import java.util.Random;
 import java.util.concurrent.atomic.AtomicInteger;
 
+import org.briarproject.api.UniqueId;
+import org.briarproject.api.crypto.SecretKey;
+
 public class TestUtils {
 
 	private static final AtomicInteger nextTestDir =
@@ -35,4 +38,10 @@ public class TestUtils {
 			c[i] = (char) ('a' + random.nextInt(26));
 		return new String(c);
 	}
+
+	public static SecretKey createSecretKey() {
+		byte[] b = new byte[SecretKey.LENGTH];
+		random.nextBytes(b);
+		return new SecretKey(b);
+	}
 }

briar-tests/src/org/briarproject/crypto/KeyAgreementTest.java

@@ -4,6 +4,7 @@ import org.briarproject.BriarTestCase;
 import org.briarproject.TestSeedProvider;
 import org.briarproject.api.crypto.CryptoComponent;
 import org.briarproject.api.crypto.KeyPair;
+import org.briarproject.api.crypto.SecretKey;
 import org.briarproject.api.system.SeedProvider;
 import org.junit.Test;
 
@@ -19,8 +20,8 @@ public class KeyAgreementTest extends BriarTestCase {
 		byte[] aPub = aPair.getPublic().getEncoded();
 		KeyPair bPair = crypto.generateAgreementKeyPair();
 		byte[] bPub = bPair.getPublic().getEncoded();
-		byte[] aSecret = crypto.deriveMasterSecret(aPub, bPair, true);
-		byte[] bSecret = crypto.deriveMasterSecret(bPub, aPair, false);
-		assertArrayEquals(aSecret, bSecret);
+		SecretKey aMaster = crypto.deriveMasterSecret(aPub, bPair, true);
+		SecretKey bMaster = crypto.deriveMasterSecret(bPub, aPair, false);
+		assertArrayEquals(aMaster.getBytes(), bMaster.getBytes());
 	}
 }

briar-tests/src/org/briarproject/crypto/KeyDerivationTest.java

@@ -2,72 +2,164 @@ package org.briarproject.crypto;
 
 import org.briarproject.BriarTestCase;
 import org.briarproject.TestSeedProvider;
+import org.briarproject.TestUtils;
+import org.briarproject.api.TransportId;
 import org.briarproject.api.crypto.CryptoComponent;
 import org.briarproject.api.crypto.SecretKey;
+import org.briarproject.api.transport.TransportKeys;
 import org.junit.Test;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
-import java.util.Random;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertFalse;
 
 public class KeyDerivationTest extends BriarTestCase {
 
+	private final TransportId transportId = new TransportId("id");
 	private final CryptoComponent crypto;
-	private final byte[] secret;
+	private final SecretKey master;
 
 	public KeyDerivationTest() {
 		crypto = new CryptoComponentImpl(new TestSeedProvider());
-		secret = new byte[32];
-		new Random().nextBytes(secret);
+		master = TestUtils.createSecretKey();
 	}
 
 	@Test
 	public void testKeysAreDistinct() {
-		List<SecretKey> keys = new ArrayList<SecretKey>();
-		keys.add(crypto.deriveFrameKey(secret, 0, true));
-		keys.add(crypto.deriveFrameKey(secret, 0, false));
-		keys.add(crypto.deriveTagKey(secret, true));
-		keys.add(crypto.deriveTagKey(secret, false));
-		for (int i = 0; i < 4; i++) {
-			byte[] keyI = keys.get(i).getBytes();
-			for (int j = 0; j < 4; j++) {
-				byte[] keyJ = keys.get(j).getBytes();
-				assertEquals(i == j, Arrays.equals(keyI, keyJ));
-			}
-		}
+		TransportKeys k = crypto.deriveTransportKeys(transportId, master,
+				123, true);
+		assertAllDifferent(k);
 	}
 
 	@Test
-	public void testSecretAffectsDerivation() {
-		Random r = new Random();
-		List<byte[]> secrets = new ArrayList<byte[]>();
-		for (int i = 0; i < 20; i++) {
-			byte[] b = new byte[32];
-			r.nextBytes(b);
-			secrets.add(crypto.deriveNextSecret(b, 0));
-		}
-		for (int i = 0; i < 20; i++) {
-			byte[] secretI = secrets.get(i);
-			for (int j = 0; j < 20; j++) {
-				byte[] secretJ = secrets.get(j);
-				assertEquals(i == j, Arrays.equals(secretI, secretJ));
-			}
-		}
+	public void testCurrentKeysMatchCurrentKeysOfContact() {
+		// Start in rotation period 123
+		TransportKeys kA = crypto.deriveTransportKeys(transportId, master,
+				123, true);
+		TransportKeys kB = crypto.deriveTransportKeys(transportId, master,
+				123, false);
+		// Alice's incoming keys should equal Bob's outgoing keys
+		assertArrayEquals(kA.getCurrentIncomingKeys().getTagKey().getBytes(),
+				kB.getCurrentOutgoingKeys().getTagKey().getBytes());
+		assertArrayEquals(kA.getCurrentIncomingKeys().getHeaderKey().getBytes(),
+				kB.getCurrentOutgoingKeys().getHeaderKey().getBytes());
+		// Alice's outgoing keys should equal Bob's incoming keys
+		assertArrayEquals(kA.getCurrentOutgoingKeys().getTagKey().getBytes(),
+				kB.getCurrentIncomingKeys().getTagKey().getBytes());
+		assertArrayEquals(kA.getCurrentOutgoingKeys().getHeaderKey().getBytes(),
+				kB.getCurrentIncomingKeys().getHeaderKey().getBytes());
+		// Rotate into the future
+		kA = crypto.rotateTransportKeys(kA, 456);
+		kB = crypto.rotateTransportKeys(kB, 456);
+		// Alice's incoming keys should equal Bob's outgoing keys
+		assertArrayEquals(kA.getCurrentIncomingKeys().getTagKey().getBytes(),
+				kB.getCurrentOutgoingKeys().getTagKey().getBytes());
+		assertArrayEquals(kA.getCurrentIncomingKeys().getHeaderKey().getBytes(),
+				kB.getCurrentOutgoingKeys().getHeaderKey().getBytes());
+		// Alice's outgoing keys should equal Bob's incoming keys
+		assertArrayEquals(kA.getCurrentOutgoingKeys().getTagKey().getBytes(),
+				kB.getCurrentIncomingKeys().getTagKey().getBytes());
+		assertArrayEquals(kA.getCurrentOutgoingKeys().getHeaderKey().getBytes(),
+				kB.getCurrentIncomingKeys().getHeaderKey().getBytes());
 	}
 
 	@Test
-	public void testStreamNumberAffectsDerivation() {
-		List<byte[]> secrets = new ArrayList<byte[]>();
-		for (int i = 0; i < 20; i++)
-			secrets.add(crypto.deriveNextSecret(secret, i));
-		for (int i = 0; i < 20; i++) {
-			byte[] secretI = secrets.get(i);
-			for (int j = 0; j < 20; j++) {
-				byte[] secretJ = secrets.get(j);
-				assertEquals(i == j, Arrays.equals(secretI, secretJ));
+	public void testPreviousKeysMatchPreviousKeysOfContact() {
+		// Start in rotation period 123
+		TransportKeys kA = crypto.deriveTransportKeys(transportId, master,
+				123, true);
+		TransportKeys kB = crypto.deriveTransportKeys(transportId, master,
+				123, false);
+		// Compare Alice's previous keys in period 456 with Bob's current keys
+		// in period 455
+		kA = crypto.rotateTransportKeys(kA, 456);
+		kB = crypto.rotateTransportKeys(kB, 455);
+		// Alice's previous incoming keys should equal Bob's outgoing keys
+		assertArrayEquals(kA.getPreviousIncomingKeys().getTagKey().getBytes(),
+				kB.getCurrentOutgoingKeys().getTagKey().getBytes());
+		assertArrayEquals(kA.getPreviousIncomingKeys().getHeaderKey().getBytes(),
+				kB.getCurrentOutgoingKeys().getHeaderKey().getBytes());
+		// Compare Alice's current keys in period 456 with Bob's previous keys
+		// in period 457
+		kB = crypto.rotateTransportKeys(kB, 457);
+		// Alice's outgoing keys should equal Bob's previous incoming keys
+		assertArrayEquals(kA.getCurrentOutgoingKeys().getTagKey().getBytes(),
+				kB.getPreviousIncomingKeys().getTagKey().getBytes());
+		assertArrayEquals(kA.getCurrentOutgoingKeys().getHeaderKey().getBytes(),
+				kB.getPreviousIncomingKeys().getHeaderKey().getBytes());
+	}
+
+	@Test
+	public void testNextKeysMatchNextKeysOfContact() {
+		// Start in rotation period 123
+		TransportKeys kA = crypto.deriveTransportKeys(transportId, master,
+				123, true);
+		TransportKeys kB = crypto.deriveTransportKeys(transportId, master,
+				123, false);
+		// Compare Alice's current keys in period 456 with Bob's next keys in
+		// period 455
+		kA = crypto.rotateTransportKeys(kA, 456);
+		kB = crypto.rotateTransportKeys(kB, 455);
+		// Alice's outgoing keys should equal Bob's next incoming keys
+		assertArrayEquals(kA.getCurrentOutgoingKeys().getTagKey().getBytes(),
+				kB.getNextIncomingKeys().getTagKey().getBytes());
+		assertArrayEquals(kA.getCurrentOutgoingKeys().getHeaderKey().getBytes(),
+				kB.getNextIncomingKeys().getHeaderKey().getBytes());
+		// Compare Alice's next keys in period 456 with Bob's current keys
+		// in period 457
+		kB = crypto.rotateTransportKeys(kB, 457);
+		// Alice's next incoming keys should equal Bob's outgoing keys
+		assertArrayEquals(kA.getNextIncomingKeys().getTagKey().getBytes(),
+				kB.getCurrentOutgoingKeys().getTagKey().getBytes());
+		assertArrayEquals(kA.getNextIncomingKeys().getHeaderKey().getBytes(),
+				kB.getCurrentOutgoingKeys().getHeaderKey().getBytes());
+	}
+
+	@Test
+	public void testMasterKeyAffectsOutput() {
+		SecretKey master1 = TestUtils.createSecretKey();
+		assertFalse(Arrays.equals(master.getBytes(), master1.getBytes()));
+		TransportKeys k = crypto.deriveTransportKeys(transportId, master,
+				123, true);
+		TransportKeys k1 = crypto.deriveTransportKeys(transportId, master1,
+				123, true);
+		assertAllDifferent(k, k1);
+	}
+
+	@Test
+	public void testTransportIdAffectsOutput() {
+		TransportId transportId1 = new TransportId("id1");
+		assertFalse(transportId.getString().equals(transportId1.getString()));
+		TransportKeys k = crypto.deriveTransportKeys(transportId, master,
+				123, true);
+		TransportKeys k1 = crypto.deriveTransportKeys(transportId1, master,
+				123, true);
+		assertAllDifferent(k, k1);
+	}
+
+	private void assertAllDifferent(TransportKeys... transportKeys) {
+		List<SecretKey> secretKeys = new ArrayList<SecretKey>();
+		for (TransportKeys k : transportKeys) {
+			secretKeys.add(k.getPreviousIncomingKeys().getTagKey());
+			secretKeys.add(k.getPreviousIncomingKeys().getHeaderKey());
+			secretKeys.add(k.getCurrentIncomingKeys().getTagKey());
+			secretKeys.add(k.getCurrentIncomingKeys().getHeaderKey());
+			secretKeys.add(k.getNextIncomingKeys().getTagKey());
+			secretKeys.add(k.getNextIncomingKeys().getHeaderKey());
+			secretKeys.add(k.getCurrentOutgoingKeys().getTagKey());
+			secretKeys.add(k.getCurrentOutgoingKeys().getHeaderKey());
+		}
+		assertAllDifferent(secretKeys);
+	}
+
+	private void assertAllDifferent(List<SecretKey> keys) {
+		for (SecretKey ki : keys) {
+			for (SecretKey kj : keys) {
+				if (ki == kj) assertArrayEquals(ki.getBytes(), kj.getBytes());
+				else assertFalse(Arrays.equals(ki.getBytes(), kj.getBytes()));
 			}
 		}
 	}

briar-tests/src/org/briarproject/db/DatabaseComponentTest.java

@@ -11,6 +11,7 @@ import org.briarproject.api.LocalAuthor;
 import org.briarproject.api.TransportConfig;
 import org.briarproject.api.TransportId;
 import org.briarproject.api.TransportProperties;
+import org.briarproject.api.crypto.SecretKey;
 import org.briarproject.api.db.DatabaseComponent;
 import org.briarproject.api.db.NoSuchContactException;
 import org.briarproject.api.db.NoSuchLocalAuthorException;
@@ -45,8 +46,9 @@ import org.briarproject.api.messaging.SubscriptionAck;
 import org.briarproject.api.messaging.SubscriptionUpdate;
 import org.briarproject.api.messaging.TransportAck;
 import org.briarproject.api.messaging.TransportUpdate;
-import org.briarproject.api.transport.Endpoint;
-import org.briarproject.api.transport.TemporarySecret;
+import org.briarproject.api.transport.IncomingKeys;
+import org.briarproject.api.transport.OutgoingKeys;
+import org.briarproject.api.transport.TransportKeys;
 import org.jmock.Expectations;
 import org.jmock.Mockery;
 import org.junit.Test;
@@ -84,8 +86,6 @@ public abstract class DatabaseComponentTest extends BriarTestCase {
 	protected final int maxLatency;
 	protected final ContactId contactId;
 	protected final Contact contact;
-	protected final Endpoint endpoint;
-	protected final TemporarySecret temporarySecret;
 
 	public DatabaseComponentTest() {
 		groupId = new GroupId(TestUtils.getRandomId());
@@ -112,9 +112,6 @@ public abstract class DatabaseComponentTest extends BriarTestCase {
 		maxLatency = Integer.MAX_VALUE;
 		contactId = new ContactId(234);
 		contact = new Contact(contactId, author, localAuthorId);
-		endpoint = new Endpoint(contactId, transportId, 123, true);
-		temporarySecret = new TemporarySecret(contactId, transportId, 123,
-				false, 234, new byte[32], 345, 456, new byte[4]);
 	}
 
 	protected abstract <T> DatabaseComponent createDatabaseComponent(
@@ -157,7 +154,7 @@ public abstract class DatabaseComponentTest extends BriarTestCase {
 			oneOf(eventBus).broadcast(with(any(ContactAddedEvent.class)));
 			// getContacts()
 			oneOf(database).getContacts(txn);
-			will(returnValue(Arrays.asList(contact)));
+			will(returnValue(Collections.singletonList(contact)));
 			// getRemoteProperties()
 			oneOf(database).getRemoteProperties(txn, transportId);
 			will(returnValue(Collections.emptyMap()));
@@ -177,7 +174,7 @@ public abstract class DatabaseComponentTest extends BriarTestCase {
 			will(returnValue(Collections.emptyList()));
 			// getGroups()
 			oneOf(database).getGroups(txn);
-			will(returnValue(Arrays.asList(groupId)));
+			will(returnValue(Collections.singletonList(group)));
 			// removeGroup()
 			oneOf(database).containsGroup(txn, groupId);
 			will(returnValue(true));
@@ -213,13 +210,13 @@ public abstract class DatabaseComponentTest extends BriarTestCase {
 		assertFalse(db.open());
 		db.addLocalAuthor(localAuthor);
 		assertEquals(contactId, db.addContact(author, localAuthorId));
-		assertEquals(Arrays.asList(contact), db.getContacts());
+		assertEquals(Collections.singletonList(contact), db.getContacts());
 		assertEquals(Collections.emptyMap(),
 				db.getRemoteProperties(transportId));
 		db.addGroup(group); // First time - listeners called
 		db.addGroup(group); // Second time - not called
 		assertEquals(Collections.emptyList(), db.getMessageHeaders(groupId));
-		assertEquals(Arrays.asList(groupId), db.getGroups());
+		assertEquals(Collections.singletonList(group), db.getGroups());
 		db.removeGroup(group);
 		db.removeContact(contactId);
 		db.removeLocalAuthor(localAuthorId);
@@ -297,9 +294,9 @@ public abstract class DatabaseComponentTest extends BriarTestCase {
 			oneOf(database).addMessage(txn, message, true);
 			oneOf(database).setReadFlag(txn, messageId, true);
 			oneOf(database).getVisibility(txn, groupId);
-			will(returnValue(Arrays.asList(contactId)));
+			will(returnValue(Collections.singletonList(contactId)));
 			oneOf(database).getContactIds(txn);
-			will(returnValue(Arrays.asList(contactId)));
+			will(returnValue(Collections.singletonList(contactId)));
 			oneOf(database).removeOfferedMessage(txn, contactId, messageId);
 			will(returnValue(false));
 			oneOf(database).addStatus(txn, contactId, messageId, false, false);
@@ -336,7 +333,7 @@ public abstract class DatabaseComponentTest extends BriarTestCase {
 				eventBus, shutdown);
 
 		try {
-			db.addEndpoint(endpoint);
+			db.addTransportKeys(contactId, createTransportKeys());
 			fail();
 		} catch (NoSuchContactException expected) {}
 
@@ -401,7 +398,7 @@ public abstract class DatabaseComponentTest extends BriarTestCase {
 		} catch (NoSuchContactException expected) {}
 
 		try {
-			Ack a = new Ack(Arrays.asList(messageId));
+			Ack a = new Ack(Collections.singletonList(messageId));
 			db.receiveAck(contactId, a);
 			fail();
 		} catch (NoSuchContactException expected) {}
@@ -412,7 +409,7 @@ public abstract class DatabaseComponentTest extends BriarTestCase {
 		} catch (NoSuchContactException expected) {}
 
 		try {
-			Offer o = new Offer(Arrays.asList(messageId));
+			Offer o = new Offer(Collections.singletonList(messageId));
 			db.receiveOffer(contactId, o);
 			fail();
 		} catch (NoSuchContactException expected) {}
@@ -594,7 +591,7 @@ public abstract class DatabaseComponentTest extends BriarTestCase {
 			// Check whether the transport is in the DB (which it's not)
 			exactly(8).of(database).startTransaction();
 			will(returnValue(txn));
-			exactly(3).of(database).containsContact(txn, contactId);
+			exactly(2).of(database).containsContact(txn, contactId);
 			will(returnValue(true));
 			exactly(8).of(database).containsTransport(txn, transportId);
 			will(returnValue(false));
@@ -606,11 +603,6 @@ public abstract class DatabaseComponentTest extends BriarTestCase {
 		db.addLocalAuthor(localAuthor);
 		assertEquals(contactId, db.addContact(author, localAuthorId));
 
-		try {
-			db.addEndpoint(endpoint);
-			fail();
-		} catch (NoSuchTransportException expected) {}
-
 		try {
 			db.getConfig(transportId);
 			fail();
@@ -621,6 +613,11 @@ public abstract class DatabaseComponentTest extends BriarTestCase {
 			fail();
 		} catch (NoSuchTransportException expected) {}
 
+		try {
+			db.getTransportKeys(transportId);
+			fail();
+		} catch (NoSuchTransportException expected) {}
+
 		try {
 			db.mergeConfig(transportId, new TransportConfig());
 			fail();
@@ -909,7 +906,8 @@ public abstract class DatabaseComponentTest extends BriarTestCase {
 			oneOf(database).containsContact(txn, contactId);
 			will(returnValue(true));
 			oneOf(database).getSubscriptionUpdate(txn, contactId, maxLatency);
-			will(returnValue(new SubscriptionUpdate(Arrays.asList(group), 1)));
+			will(returnValue(new SubscriptionUpdate(
+					Collections.singletonList(group), 1)));
 			oneOf(database).commitTransaction(txn);
 		}});
 		DatabaseComponent db = createDatabaseComponent(database, cleaner,
@@ -917,7 +915,7 @@ public abstract class DatabaseComponentTest extends BriarTestCase {
 
 		SubscriptionUpdate u = db.generateSubscriptionUpdate(contactId,
 				maxLatency);
-		assertEquals(Arrays.asList(group), u.getGroups());
+		assertEquals(Collections.singletonList(group), u.getGroups());
 		assertEquals(1, u.getVersion());
 
 		context.assertIsSatisfied();
@@ -962,8 +960,8 @@ public abstract class DatabaseComponentTest extends BriarTestCase {
 			oneOf(database).containsContact(txn, contactId);
 			will(returnValue(true));
 			oneOf(database).getTransportUpdates(txn, contactId, maxLatency);
-			will(returnValue(Arrays.asList(new TransportUpdate(transportId,
-					transportProperties, 1))));
+			will(returnValue(Collections.singletonList(new TransportUpdate(
+					transportId, transportProperties, 1))));
 			oneOf(database).commitTransaction(txn);
 		}});
 		DatabaseComponent db = createDatabaseComponent(database, cleaner,
@@ -1003,7 +1001,7 @@ public abstract class DatabaseComponentTest extends BriarTestCase {
 		DatabaseComponent db = createDatabaseComponent(database, cleaner,
 				eventBus, shutdown);
 
-		db.receiveAck(contactId, new Ack(Arrays.asList(messageId)));
+		db.receiveAck(contactId, new Ack(Collections.singletonList(messageId)));
 
 		context.assertIsSatisfied();
 	}
@@ -1027,9 +1025,9 @@ public abstract class DatabaseComponentTest extends BriarTestCase {
 			will(returnValue(true));
 			oneOf(database).addMessage(txn, message, false);
 			oneOf(database).getVisibility(txn, groupId);
-			will(returnValue(Arrays.asList(contactId)));
+			will(returnValue(Collections.singletonList(contactId)));
 			oneOf(database).getContactIds(txn);
-			will(returnValue(Arrays.asList(contactId)));
+			will(returnValue(Collections.singletonList(contactId)));
 			oneOf(database).removeOfferedMessage(txn, contactId, messageId);
 			will(returnValue(false));
 			oneOf(database).addStatus(txn, contactId, messageId, false, true);
@@ -1176,7 +1174,8 @@ public abstract class DatabaseComponentTest extends BriarTestCase {
 		DatabaseComponent db = createDatabaseComponent(database, cleaner,
 				eventBus, shutdown);
 
-		db.receiveRequest(contactId, new Request(Arrays.asList(messageId)));
+		db.receiveRequest(contactId, new Request(Collections.singletonList(
+				messageId)));
 
 		context.assertIsSatisfied();
 	}
@@ -1244,13 +1243,15 @@ public abstract class DatabaseComponentTest extends BriarTestCase {
 			will(returnValue(txn));
 			oneOf(database).containsContact(txn, contactId);
 			will(returnValue(true));
-			oneOf(database).setGroups(txn, contactId, Arrays.asList(group), 1);
+			oneOf(database).setGroups(txn, contactId,
+					Collections.singletonList(group), 1);
 			oneOf(database).commitTransaction(txn);
 		}});
 		DatabaseComponent db = createDatabaseComponent(database, cleaner,
 				eventBus, shutdown);
 
-		SubscriptionUpdate u = new SubscriptionUpdate(Arrays.asList(group), 1);
+		SubscriptionUpdate u = new SubscriptionUpdate(
+				Collections.singletonList(group), 1);
 		db.receiveSubscriptionUpdate(contactId, u);
 
 		context.assertIsSatisfied();
@@ -1398,7 +1399,7 @@ public abstract class DatabaseComponentTest extends BriarTestCase {
 		DatabaseComponent db = createDatabaseComponent(database, cleaner,
 				eventBus, shutdown);
 
-		db.setVisibility(groupId, Arrays.asList(contactId));
+		db.setVisibility(groupId, Collections.singletonList(contactId));
 
 		context.assertIsSatisfied();
 	}
@@ -1467,7 +1468,7 @@ public abstract class DatabaseComponentTest extends BriarTestCase {
 			will(returnValue(true));
 			oneOf(database).setVisibleToAll(txn, groupId, true);
 			oneOf(database).getVisibility(txn, groupId);
-			will(returnValue(Arrays.asList(contactId)));
+			will(returnValue(Collections.singletonList(contactId)));
 			oneOf(database).getContactIds(txn);
 			will(returnValue(both));
 			oneOf(database).addVisibility(txn, contactId1, groupId);
@@ -1478,14 +1479,15 @@ public abstract class DatabaseComponentTest extends BriarTestCase {
 		DatabaseComponent db = createDatabaseComponent(database, cleaner,
 				eventBus, shutdown);
 
-		db.setVisibility(groupId, Arrays.asList(contactId));
+		db.setVisibility(groupId, Collections.singletonList(contactId));
 		db.setVisibleToAll(groupId, true);
 
 		context.assertIsSatisfied();
 	}
 
 	@Test
-	public void testTemporarySecrets() throws Exception {
+	public void testTransportKeys() throws Exception {
+		final TransportKeys keys = createTransportKeys();
 		Mockery context = new Mockery();
 		@SuppressWarnings("unchecked")
 		final Database<Object> database = context.mock(Database.class);
@@ -1493,28 +1495,52 @@ public abstract class DatabaseComponentTest extends BriarTestCase {
 		final ShutdownManager shutdown = context.mock(ShutdownManager.class);
 		final EventBus eventBus = context.mock(EventBus.class);
 		context.checking(new Expectations() {{
-			// addSecrets()
+			// updateTransportKeys()
 			oneOf(database).startTransaction();
 			will(returnValue(txn));
 			oneOf(database).containsContact(txn, contactId);
 			will(returnValue(true));
 			oneOf(database).containsTransport(txn, transportId);
 			will(returnValue(true));
-			oneOf(database).addSecrets(txn, Arrays.asList(temporarySecret));
+			oneOf(database).updateTransportKeys(txn,
+					Collections.singletonMap(contactId, keys));
 			oneOf(database).commitTransaction(txn);
-			// getSecrets()
+			// getTransportKeys()
 			oneOf(database).startTransaction();
 			will(returnValue(txn));
-			oneOf(database).getSecrets(txn);
-			will(returnValue(Arrays.asList(temporarySecret)));
+			oneOf(database).containsTransport(txn, transportId);
+			will(returnValue(true));
+			oneOf(database).getTransportKeys(txn, transportId);
+			will(returnValue(Collections.singletonMap(contactId, keys)));
 			oneOf(database).commitTransaction(txn);
 		}});
 		DatabaseComponent db = createDatabaseComponent(database, cleaner,
 				eventBus, shutdown);
 
-		db.addSecrets(Arrays.asList(temporarySecret));
-		assertEquals(Arrays.asList(temporarySecret), db.getSecrets());
+		db.updateTransportKeys(Collections.singletonMap(contactId, keys));
+		assertEquals(Collections.singletonMap(contactId, keys),
+				db.getTransportKeys(transportId));
 
 		context.assertIsSatisfied();
 	}
+
+	private TransportKeys createTransportKeys() {
+		SecretKey inPrevTagKey = TestUtils.createSecretKey();
+		SecretKey inPrevHeaderKey = TestUtils.createSecretKey();
+		IncomingKeys inPrev = new IncomingKeys(inPrevTagKey, inPrevHeaderKey,
+				1, 123, new byte[4]);
+		SecretKey inCurrTagKey = TestUtils.createSecretKey();
+		SecretKey inCurrHeaderKey = TestUtils.createSecretKey();
+		IncomingKeys inCurr = new IncomingKeys(inCurrTagKey, inCurrHeaderKey,
+				2, 234, new byte[4]);
+		SecretKey inNextTagKey = TestUtils.createSecretKey();
+		SecretKey inNextHeaderKey = TestUtils.createSecretKey();
+		IncomingKeys inNext = new IncomingKeys(inNextTagKey, inNextHeaderKey,
+				3, 345, new byte[4]);
+		SecretKey outCurrTagKey = TestUtils.createSecretKey();
+		SecretKey outCurrHeaderKey = TestUtils.createSecretKey();
+		OutgoingKeys outCurr = new OutgoingKeys(outCurrTagKey, outCurrHeaderKey,
+				2, 456);
+		return new TransportKeys(transportId, inPrev, inCurr, inNext, outCurr);
+	}
 }

briar-tests/src/org/briarproject/db/H2DatabaseTest.java

@@ -11,14 +11,17 @@ import org.briarproject.api.LocalAuthor;
 import org.briarproject.api.TransportConfig;
 import org.briarproject.api.TransportId;
 import org.briarproject.api.TransportProperties;
+import org.briarproject.api.crypto.SecretKey;
 import org.briarproject.api.db.DbException;
 import org.briarproject.api.db.MessageHeader;
 import org.briarproject.api.messaging.Group;
 import org.briarproject.api.messaging.GroupId;
 import org.briarproject.api.messaging.Message;
 import org.briarproject.api.messaging.MessageId;
-import org.briarproject.api.transport.Endpoint;
-import org.briarproject.api.transport.TemporarySecret;
+import org.briarproject.api.transport.IncomingKeys;
+import org.briarproject.api.transport.OutgoingKeys;
+import org.briarproject.api.transport.TransportKeys;
+import org.briarproject.system.FileUtilsImpl;
 import org.briarproject.system.SystemClock;
 import org.junit.After;
 import org.junit.Before;
@@ -34,6 +37,7 @@ import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.Random;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -59,7 +63,6 @@ public class H2DatabaseTest extends BriarTestCase {
 	private final Random random = new Random();
 	private final GroupId groupId;
 	private final Group group;
-	private final AuthorId authorId;
 	private final Author author;
 	private final AuthorId localAuthorId;
 	private final LocalAuthor localAuthor;
@@ -75,7 +78,7 @@ public class H2DatabaseTest extends BriarTestCase {
 	public H2DatabaseTest() throws Exception {
 		groupId = new GroupId(TestUtils.getRandomId());
 		group = new Group(groupId, "Group", new byte[GROUP_SALT_LENGTH]);
-		authorId = new AuthorId(TestUtils.getRandomId());
+		AuthorId authorId = new AuthorId(TestUtils.getRandomId());
 		author = new Author(authorId, "Alice", new byte[MAX_PUBLIC_KEY_LENGTH]);
 		localAuthorId = new AuthorId(TestUtils.getRandomId());
 		localAuthor = new LocalAuthor(localAuthorId, "Bob",
@@ -171,7 +174,7 @@ public class H2DatabaseTest extends BriarTestCase {
 		assertEquals(contactId, db.addContact(txn, author, localAuthorId));
 		db.addGroup(txn, group);
 		db.addVisibility(txn, contactId, groupId);
-		db.setGroups(txn, contactId, Arrays.asList(group), 1);
+		db.setGroups(txn, contactId, Collections.singletonList(group), 1);
 		db.addMessage(txn, message, true);
 
 		// The message has no status yet, so it should not be sendable
@@ -216,7 +219,7 @@ public class H2DatabaseTest extends BriarTestCase {
 		assertTrue(ids.isEmpty());
 
 		// The contact subscribing should make the message sendable
-		db.setGroups(txn, contactId, Arrays.asList(group), 1);
+		db.setGroups(txn, contactId, Collections.singletonList(group), 1);
 		ids = db.getMessagesToSend(txn, contactId, ONE_MEGABYTE);
 		assertFalse(ids.isEmpty());
 		Iterator<MessageId> it = ids.iterator();
@@ -243,7 +246,7 @@ public class H2DatabaseTest extends BriarTestCase {
 		assertEquals(contactId, db.addContact(txn, author, localAuthorId));
 		db.addGroup(txn, group);
 		db.addVisibility(txn, contactId, groupId);
-		db.setGroups(txn, contactId, Arrays.asList(group), 1);
+		db.setGroups(txn, contactId, Collections.singletonList(group), 1);
 		db.addMessage(txn, message, true);
 		db.addStatus(txn, contactId, messageId, false, false);
 
@@ -273,7 +276,7 @@ public class H2DatabaseTest extends BriarTestCase {
 		db.addLocalAuthor(txn, localAuthor);
 		assertEquals(contactId, db.addContact(txn, author, localAuthorId));
 		db.addGroup(txn, group);
-		db.setGroups(txn, contactId, Arrays.asList(group), 1);
+		db.setGroups(txn, contactId, Collections.singletonList(group), 1);
 		db.addMessage(txn, message, true);
 		db.addStatus(txn, contactId, messageId, false, false);
 
@@ -305,7 +308,7 @@ public class H2DatabaseTest extends BriarTestCase {
 		db.addLocalAuthor(txn, localAuthor);
 		assertEquals(contactId, db.addContact(txn, author, localAuthorId));
 		db.addGroup(txn, group);
-		db.setGroups(txn, contactId, Arrays.asList(group), 1);
+		db.setGroups(txn, contactId, Collections.singletonList(group), 1);
 
 		// Add some messages to ack
 		MessageId messageId1 = new MessageId(TestUtils.getRandomId());
@@ -342,7 +345,7 @@ public class H2DatabaseTest extends BriarTestCase {
 		db.addLocalAuthor(txn, localAuthor);
 		assertEquals(contactId, db.addContact(txn, author, localAuthorId));
 		db.addGroup(txn, group);
-		db.setGroups(txn, contactId, Arrays.asList(group), 1);
+		db.setGroups(txn, contactId, Collections.singletonList(group), 1);
 
 		// Receive the same message twice
 		db.addMessage(txn, message, true);
@@ -352,10 +355,10 @@ public class H2DatabaseTest extends BriarTestCase {
 
 		// The message ID should only be returned once
 		Collection<MessageId> ids = db.getMessagesToAck(txn, contactId, 1234);
-		assertEquals(Arrays.asList(messageId), ids);
+		assertEquals(Collections.singletonList(messageId), ids);
 
 		// Remove the message ID
-		db.lowerAckFlag(txn, contactId, Arrays.asList(messageId));
+		db.lowerAckFlag(txn, contactId, Collections.singletonList(messageId));
 
 		// The message ID should have been removed
 		assertEquals(Collections.emptyList(), db.getMessagesToAck(txn,
@@ -375,7 +378,7 @@ public class H2DatabaseTest extends BriarTestCase {
 		assertEquals(contactId, db.addContact(txn, author, localAuthorId));
 		db.addGroup(txn, group);
 		db.addVisibility(txn, contactId, groupId);
-		db.setGroups(txn, contactId, Arrays.asList(group), 1);
+		db.setGroups(txn, contactId, Collections.singletonList(group), 1);
 		db.addMessage(txn, message, true);
 		db.addStatus(txn, contactId, messageId, false, false);
 
@@ -674,7 +677,7 @@ public class H2DatabaseTest extends BriarTestCase {
 		assertEquals(contactId, db.addContact(txn, author, localAuthorId));
 		db.addGroup(txn, group);
 		db.addVisibility(txn, contactId, groupId);
-		db.setGroups(txn, contactId, Arrays.asList(group), 1);
+		db.setGroups(txn, contactId, Collections.singletonList(group), 1);
 
 		// The message is not in the database
 		assertFalse(db.containsVisibleMessage(txn, contactId, messageId));
@@ -692,7 +695,7 @@ public class H2DatabaseTest extends BriarTestCase {
 		// Add a contact with a subscription
 		db.addLocalAuthor(txn, localAuthor);
 		assertEquals(contactId, db.addContact(txn, author, localAuthorId));
-		db.setGroups(txn, contactId, Arrays.asList(group), 1);
+		db.setGroups(txn, contactId, Collections.singletonList(group), 1);
 
 		// There's no local subscription for the group
 		assertFalse(db.containsVisibleMessage(txn, contactId, messageId));
@@ -711,7 +714,7 @@ public class H2DatabaseTest extends BriarTestCase {
 		db.addLocalAuthor(txn, localAuthor);
 		assertEquals(contactId, db.addContact(txn, author, localAuthorId));
 		db.addGroup(txn, group);
-		db.setGroups(txn, contactId, Arrays.asList(group), 1);
+		db.setGroups(txn, contactId, Collections.singletonList(group), 1);
 		db.addMessage(txn, message, true);
 		db.addStatus(txn, contactId, messageId, false, false);
 
@@ -737,7 +740,8 @@ public class H2DatabaseTest extends BriarTestCase {
 
 		// Make the group visible to the contact
 		db.addVisibility(txn, contactId, groupId);
-		assertEquals(Arrays.asList(contactId), db.getVisibility(txn, groupId));
+		assertEquals(Collections.singletonList(contactId),
+				db.getVisibility(txn, groupId));
 
 		// Make the group invisible again
 		db.removeVisibility(txn, contactId, groupId);
@@ -1111,183 +1115,97 @@ public class H2DatabaseTest extends BriarTestCase {
 	}
 
 	@Test
-	public void testTemporarySecrets() throws Exception {
-		// Create an endpoint and four consecutive temporary secrets
-		long epoch = 123;
-		int latency = 234;
-		boolean alice = false;
-		long outgoing1 = 345, centre1 = 456;
-		long outgoing2 = 567, centre2 = 678;
-		long outgoing3 = 789, centre3 = 890;
-		long outgoing4 = 901, centre4 = 123;
-		Endpoint ep = new Endpoint(contactId, transportId, epoch, alice);
-		Random random = new Random();
-		byte[] secret1 = new byte[32], bitmap1 = new byte[4];
-		random.nextBytes(secret1);
-		random.nextBytes(bitmap1);
-		TemporarySecret s1 = new TemporarySecret(contactId, transportId, epoch,
-				alice, 0, secret1, outgoing1, centre1, bitmap1);
-		byte[] secret2 = new byte[32], bitmap2 = new byte[4];
-		random.nextBytes(secret2);
-		random.nextBytes(bitmap2);
-		TemporarySecret s2 = new TemporarySecret(contactId, transportId, epoch,
-				alice, 1, secret2, outgoing2, centre2, bitmap2);
-		byte[] secret3 = new byte[32], bitmap3 = new byte[4];
-		random.nextBytes(secret3);
-		random.nextBytes(bitmap3);
-		TemporarySecret s3 = new TemporarySecret(contactId, transportId, epoch,
-				alice, 2, secret3, outgoing3, centre3, bitmap3);
-		byte[] secret4 = new byte[32], bitmap4 = new byte[4];
-		random.nextBytes(secret4);
-		random.nextBytes(bitmap4);
-		TemporarySecret s4 = new TemporarySecret(contactId, transportId, epoch,
-				alice, 3, secret4, outgoing4, centre4, bitmap4);
+	public void testTransportKeys() throws Exception {
+		TransportKeys keys = createTransportKeys();
 
 		Database<Connection> db = open(false);
 		Connection txn = db.startTransaction();
 
-		// Initially there should be no secrets in the database
-		assertEquals(Collections.emptyList(), db.getSecrets(txn));
+		// Initially there should be no transport keys in the database
+		assertEquals(Collections.emptyMap(),
+				db.getTransportKeys(txn, transportId));
 
-		// Add the contact, the transport, the endpoint and the first three
-		// secrets (periods 0, 1 and 2)
+		// Add the contact, the transport and the transport keys
 		db.addLocalAuthor(txn, localAuthor);
 		assertEquals(contactId, db.addContact(txn, author, localAuthorId));
-		db.addTransport(txn, transportId, latency);
-		db.addEndpoint(txn, ep);
-		db.addSecrets(txn, Arrays.asList(s1, s2, s3));
+		db.addTransport(txn, transportId, 123);
+		db.addTransportKeys(txn, contactId, keys);
 
-		// Retrieve the first three secrets
-		Collection<TemporarySecret> secrets = db.getSecrets(txn);
-		assertEquals(3, secrets.size());
-		boolean foundFirst = false, foundSecond = false, foundThird = false;
-		for (TemporarySecret s : secrets) {
-			assertEquals(contactId, s.getContactId());
-			assertEquals(transportId, s.getTransportId());
-			assertEquals(epoch, s.getEpoch());
-			assertEquals(alice, s.getAlice());
-			if (s.getPeriod() == 0) {
-				assertArrayEquals(secret1, s.getSecret());
-				assertEquals(outgoing1, s.getOutgoingStreamCounter());
-				assertEquals(centre1, s.getWindowCentre());
-				assertArrayEquals(bitmap1, s.getWindowBitmap());
-				foundFirst = true;
-			} else if (s.getPeriod() == 1) {
-				assertArrayEquals(secret2, s.getSecret());
-				assertEquals(outgoing2, s.getOutgoingStreamCounter());
-				assertEquals(centre2, s.getWindowCentre());
-				assertArrayEquals(bitmap2, s.getWindowBitmap());
-				foundSecond = true;
-			} else if (s.getPeriod() == 2) {
-				assertArrayEquals(secret3, s.getSecret());
-				assertEquals(outgoing3, s.getOutgoingStreamCounter());
-				assertEquals(centre3, s.getWindowCentre());
-				assertArrayEquals(bitmap3, s.getWindowBitmap());
-				foundThird = true;
-			} else {
-				fail();
-			}
-		}
-		assertTrue(foundFirst);
-		assertTrue(foundSecond);
-		assertTrue(foundThird);
+		// Retrieve the transport keys
+		Map<ContactId, TransportKeys> newKeys =
+				db.getTransportKeys(txn, transportId);
+		assertEquals(1, newKeys.size());
+		Entry<ContactId, TransportKeys> e =
+				newKeys.entrySet().iterator().next();
+		assertEquals(contactId, e.getKey());
+		TransportKeys k = e.getValue();
+		assertEquals(transportId, k.getTransportId());
+		assertKeysEquals(keys.getPreviousIncomingKeys(),
+				k.getPreviousIncomingKeys());
+		assertKeysEquals(keys.getCurrentIncomingKeys(),
+				k.getCurrentIncomingKeys());
+		assertKeysEquals(keys.getNextIncomingKeys(),
+				k.getNextIncomingKeys());
+		assertKeysEquals(keys.getCurrentOutgoingKeys(),
+				k.getCurrentOutgoingKeys());
 
-		// Adding the fourth secret (period 3) should delete the first
-		db.addSecrets(txn, Arrays.asList(s4));
-		secrets = db.getSecrets(txn);
-		assertEquals(3, secrets.size());
-		foundSecond = foundThird = false;
-		boolean foundFourth = false;
-		for (TemporarySecret s : secrets) {
-			assertEquals(contactId, s.getContactId());
-			assertEquals(transportId, s.getTransportId());
-			assertEquals(epoch, s.getEpoch());
-			assertEquals(alice, s.getAlice());
-			if (s.getPeriod() == 1) {
-				assertArrayEquals(secret2, s.getSecret());
-				assertEquals(outgoing2, s.getOutgoingStreamCounter());
-				assertEquals(centre2, s.getWindowCentre());
-				assertArrayEquals(bitmap2, s.getWindowBitmap());
-				foundSecond = true;
-			} else if (s.getPeriod() == 2) {
-				assertArrayEquals(secret3, s.getSecret());
-				assertEquals(outgoing3, s.getOutgoingStreamCounter());
-				assertEquals(centre3, s.getWindowCentre());
-				assertArrayEquals(bitmap3, s.getWindowBitmap());
-				foundThird = true;
-			} else if (s.getPeriod() == 3) {
-				assertArrayEquals(secret4, s.getSecret());
-				assertEquals(outgoing4, s.getOutgoingStreamCounter());
-				assertEquals(centre4, s.getWindowCentre());
-				assertArrayEquals(bitmap4, s.getWindowBitmap());
-				foundFourth = true;
-			} else {
-				fail();
-			}
-		}
-		assertTrue(foundSecond);
-		assertTrue(foundThird);
-		assertTrue(foundFourth);
-
-		// Removing the contact should remove the secrets
+		// Removing the contact should remove the transport keys
 		db.removeContact(txn, contactId);
-		assertEquals(Collections.emptyList(), db.getSecrets(txn));
+		assertEquals(Collections.emptyMap(),
+				db.getTransportKeys(txn, transportId));
 
 		db.commitTransaction(txn);
 		db.close();
 	}
 
+	private void assertKeysEquals(IncomingKeys expected, IncomingKeys actual) {
+		assertArrayEquals(expected.getTagKey().getBytes(),
+				actual.getTagKey().getBytes());
+		assertArrayEquals(expected.getHeaderKey().getBytes(),
+				actual.getHeaderKey().getBytes());
+		assertEquals(expected.getRotationPeriod(), actual.getRotationPeriod());
+		assertEquals(expected.getWindowBase(), actual.getWindowBase());
+		assertArrayEquals(expected.getWindowBitmap(), actual.getWindowBitmap());
+	}
+
+	private void assertKeysEquals(OutgoingKeys expected, OutgoingKeys actual) {
+		assertArrayEquals(expected.getTagKey().getBytes(),
+				actual.getTagKey().getBytes());
+		assertArrayEquals(expected.getHeaderKey().getBytes(),
+				actual.getHeaderKey().getBytes());
+		assertEquals(expected.getRotationPeriod(), actual.getRotationPeriod());
+		assertEquals(expected.getStreamCounter(), actual.getStreamCounter());
+	}
+
 	@Test
 	public void testIncrementStreamCounter() throws Exception {
-		// Create an endpoint and a temporary secret
-		long epoch = 123;
-		int latency = 234;
-		boolean alice = false;
-		long period = 345, outgoing = 456, centre = 567;
-		Endpoint ep = new Endpoint(contactId, transportId, epoch, alice);
-		Random random = new Random();
-		byte[] secret = new byte[32], bitmap = new byte[4];
-		random.nextBytes(secret);
-		TemporarySecret s = new TemporarySecret(contactId, transportId, epoch,
-				alice, period, secret, outgoing, centre, bitmap);
+		TransportKeys keys = createTransportKeys();
+		long rotationPeriod = keys.getCurrentOutgoingKeys().getRotationPeriod();
+		long streamCounter = keys.getCurrentOutgoingKeys().getStreamCounter();
 
 		Database<Connection> db = open(false);
 		Connection txn = db.startTransaction();
 
-		// Add the contact, transport, endpoint and temporary secret
+		// Add the contact, transport and transport keys
 		db.addLocalAuthor(txn, localAuthor);
 		assertEquals(contactId, db.addContact(txn, author, localAuthorId));
-		db.addTransport(txn, transportId, latency);
-		db.addEndpoint(txn, ep);
-		db.addSecrets(txn, Arrays.asList(s));
+		db.addTransport(txn, transportId, 123);
+		db.updateTransportKeys(txn, Collections.singletonMap(contactId, keys));
 
-		// Retrieve the secret
-		Collection<TemporarySecret> secrets = db.getSecrets(txn);
-		assertEquals(1, secrets.size());
-		s = secrets.iterator().next();
-		assertEquals(contactId, s.getContactId());
-		assertEquals(transportId, s.getTransportId());
-		assertEquals(period, s.getPeriod());
-		assertArrayEquals(secret, s.getSecret());
-		assertEquals(outgoing, s.getOutgoingStreamCounter());
-		assertEquals(centre, s.getWindowCentre());
-		assertArrayEquals(bitmap, s.getWindowBitmap());
-
-		// Increment the stream counter twice and retrieve the secret again
-		assertEquals(outgoing, db.incrementStreamCounter(txn,
-				s.getContactId(), s.getTransportId(), s.getPeriod()));
-		assertEquals(outgoing + 1, db.incrementStreamCounter(txn,
-				s.getContactId(), s.getTransportId(), s.getPeriod()));
-		secrets = db.getSecrets(txn);
-		assertEquals(1, secrets.size());
-		s = secrets.iterator().next();
-		assertEquals(contactId, s.getContactId());
-		assertEquals(transportId, s.getTransportId());
-		assertEquals(period, s.getPeriod());
-		assertArrayEquals(secret, s.getSecret());
-		assertEquals(outgoing + 2, s.getOutgoingStreamCounter());
-		assertEquals(centre, s.getWindowCentre());
-		assertArrayEquals(bitmap, s.getWindowBitmap());
+		// Increment the stream counter twice and retrieve the transport keys
+		db.incrementStreamCounter(txn, contactId, transportId, rotationPeriod);
+		db.incrementStreamCounter(txn, contactId, transportId, rotationPeriod);
+		Map<ContactId, TransportKeys> newKeys =
+				db.getTransportKeys(txn, transportId);
+		assertEquals(1, newKeys.size());
+		Entry<ContactId, TransportKeys> e =
+				newKeys.entrySet().iterator().next();
+		assertEquals(contactId, e.getKey());
+		TransportKeys k = e.getValue();
+		assertEquals(transportId, k.getTransportId());
+		OutgoingKeys outCurr = k.getCurrentOutgoingKeys();
+		assertEquals(rotationPeriod, outCurr.getRotationPeriod());
+		assertEquals(streamCounter + 2, outCurr.getStreamCounter());
 
 		db.commitTransaction(txn);
 		db.close();
@@ -1295,123 +1213,36 @@ public class H2DatabaseTest extends BriarTestCase {
 
 	@Test
 	public void testSetReorderingWindow() throws Exception {
-		// Create an endpoint and a temporary secret
-		long epoch = 123;
-		int latency = 234;
-		boolean alice = false;
-		long period = 345, outgoing = 456, centre = 567;
-		Endpoint ep = new Endpoint(contactId, transportId, epoch, alice);
-		Random random = new Random();
-		byte[] secret = new byte[32], bitmap = new byte[4];
-		random.nextBytes(secret);
-		TemporarySecret s = new TemporarySecret(contactId, transportId, epoch,
-				alice, period, secret, outgoing, centre, bitmap);
+		TransportKeys keys = createTransportKeys();
+		long rotationPeriod = keys.getCurrentIncomingKeys().getRotationPeriod();
+		long base = keys.getCurrentIncomingKeys().getWindowBase();
+		byte[] bitmap = keys.getCurrentIncomingKeys().getWindowBitmap();
 
 		Database<Connection> db = open(false);
 		Connection txn = db.startTransaction();
 
-		// Add the contact, transport, endpoint and temporary secret
+		// Add the contact, transport and transport keys
 		db.addLocalAuthor(txn, localAuthor);
 		assertEquals(contactId, db.addContact(txn, author, localAuthorId));
-		db.addTransport(txn, transportId, latency);
-		db.addEndpoint(txn, ep);
-		db.addSecrets(txn, Arrays.asList(s));
+		db.addTransport(txn, transportId, 123);
+		db.updateTransportKeys(txn, Collections.singletonMap(contactId, keys));
 
-		// Retrieve the secret
-		Collection<TemporarySecret> secrets = db.getSecrets(txn);
-		assertEquals(1, secrets.size());
-		s = secrets.iterator().next();
-		assertEquals(contactId, s.getContactId());
-		assertEquals(transportId, s.getTransportId());
-		assertEquals(period, s.getPeriod());
-		assertArrayEquals(secret, s.getSecret());
-		assertEquals(outgoing, s.getOutgoingStreamCounter());
-		assertEquals(centre, s.getWindowCentre());
-		assertArrayEquals(bitmap, s.getWindowBitmap());
-
-		// Update the reordering window and retrieve the secret again
+		// Update the reordering window and retrieve the transport keys
 		random.nextBytes(bitmap);
-		db.setReorderingWindow(txn, contactId, transportId, period, centre,
-				bitmap);
-		secrets = db.getSecrets(txn);
-		assertEquals(1, secrets.size());
-		s = secrets.iterator().next();
-		assertEquals(contactId, s.getContactId());
-		assertEquals(transportId, s.getTransportId());
-		assertEquals(period, s.getPeriod());
-		assertArrayEquals(secret, s.getSecret());
-		assertEquals(outgoing, s.getOutgoingStreamCounter());
-		assertEquals(centre, s.getWindowCentre());
-		assertArrayEquals(bitmap, s.getWindowBitmap());
-
-		// Updating a nonexistent window should not throw an exception
-		db.setReorderingWindow(txn, contactId, transportId, period + 1, 1,
-				bitmap);
-		// The nonexistent window should not have been created
-		secrets = db.getSecrets(txn);
-		assertEquals(1, secrets.size());
-		s = secrets.iterator().next();
-		assertEquals(contactId, s.getContactId());
-		assertEquals(transportId, s.getTransportId());
-		assertEquals(period, s.getPeriod());
-		assertArrayEquals(secret, s.getSecret());
-		assertEquals(outgoing, s.getOutgoingStreamCounter());
-		assertEquals(centre, s.getWindowCentre());
-		assertArrayEquals(bitmap, s.getWindowBitmap());
-
-		db.commitTransaction(txn);
-		db.close();
-	}
-
-	@Test
-	public void testEndpoints() throws Exception {
-		// Create some endpoints
-		long epoch1 = 123, epoch2 = 234;
-		int latency1 = 345, latency2 = 456;
-		boolean alice1 = true, alice2 = false;
-		TransportId transportId1 = new TransportId("bar");
-		TransportId transportId2 = new TransportId("baz");
-		Endpoint ep1 = new Endpoint(contactId, transportId1, epoch1, alice1);
-		Endpoint ep2 = new Endpoint(contactId, transportId2, epoch2, alice2);
-
-		Database<Connection> db = open(false);
-		Connection txn = db.startTransaction();
-
-		// Initially there should be no endpoints in the database
-		assertEquals(Collections.emptyList(), db.getEndpoints(txn));
-
-		// Add the contact, the transports and the endpoints
-		db.addLocalAuthor(txn, localAuthor);
-		assertEquals(contactId, db.addContact(txn, author, localAuthorId));
-		db.addTransport(txn, transportId1, latency1);
-		db.addTransport(txn, transportId2, latency2);
-		db.addEndpoint(txn, ep1);
-		db.addEndpoint(txn, ep2);
-
-		// Retrieve the endpoints
-		Collection<Endpoint> endpoints = db.getEndpoints(txn);
-		assertEquals(2, endpoints.size());
-		boolean foundFirst = false, foundSecond = false;
-		for (Endpoint ep : endpoints) {
-			assertEquals(contactId, ep.getContactId());
-			if (ep.getTransportId().equals(transportId1)) {
-				assertEquals(epoch1, ep.getEpoch());
-				assertEquals(alice1, ep.getAlice());
-				foundFirst = true;
-			} else if (ep.getTransportId().equals(transportId2)) {
-				assertEquals(epoch2, ep.getEpoch());
-				assertEquals(alice2, ep.getAlice());
-				foundSecond = true;
-			} else {
-				fail();
-			}
-		}
-		assertTrue(foundFirst);
-		assertTrue(foundSecond);
-
-		// Removing the contact should remove the endpoints
-		db.removeContact(txn, contactId);
-		assertEquals(Collections.emptyList(), db.getEndpoints(txn));
+		db.setReorderingWindow(txn, contactId, transportId, rotationPeriod,
+				base + 1, bitmap);
+		Map<ContactId, TransportKeys> newKeys =
+				db.getTransportKeys(txn, transportId);
+		assertEquals(1, newKeys.size());
+		Entry<ContactId, TransportKeys> e =
+				newKeys.entrySet().iterator().next();
+		assertEquals(contactId, e.getKey());
+		TransportKeys k = e.getValue();
+		assertEquals(transportId, k.getTransportId());
+		IncomingKeys inCurr = k.getCurrentIncomingKeys();
+		assertEquals(rotationPeriod, inCurr.getRotationPeriod());
+		assertEquals(base + 1, inCurr.getWindowBase());
+		assertArrayEquals(bitmap, inCurr.getWindowBitmap());
 
 		db.commitTransaction(txn);
 		db.close();
@@ -1431,27 +1262,30 @@ public class H2DatabaseTest extends BriarTestCase {
 		db.addLocalAuthor(txn, localAuthor);
 		assertEquals(contactId, db.addContact(txn, author, localAuthorId));
 		assertEquals(contactId1, db.addContact(txn, author1, localAuthorId));
-		db.setGroups(txn, contactId, Arrays.asList(group), 1);
-		db.setGroups(txn, contactId1, Arrays.asList(group), 1);
+		db.setGroups(txn, contactId, Collections.singletonList(group), 1);
+		db.setGroups(txn, contactId1, Collections.singletonList(group), 1);
 
 		// The group should be available
 		assertEquals(Collections.emptyList(), db.getGroups(txn));
-		assertEquals(Arrays.asList(group), db.getAvailableGroups(txn));
+		assertEquals(Collections.singletonList(group),
+				db.getAvailableGroups(txn));
 
 		// Subscribe to the group - it should no longer be available
 		db.addGroup(txn, group);
-		assertEquals(Arrays.asList(group), db.getGroups(txn));
+		assertEquals(Collections.singletonList(group), db.getGroups(txn));
 		assertEquals(Collections.emptyList(), db.getAvailableGroups(txn));
 
 		// Unsubscribe from the group - it should be available again
 		db.removeGroup(txn, groupId);
 		assertEquals(Collections.emptyList(), db.getGroups(txn));
-		assertEquals(Arrays.asList(group), db.getAvailableGroups(txn));
+		assertEquals(Collections.singletonList(group),
+				db.getAvailableGroups(txn));
 
 		// The first contact unsubscribes - it should still be available
 		db.setGroups(txn, contactId, Collections.<Group>emptyList(), 2);
 		assertEquals(Collections.emptyList(), db.getGroups(txn));
-		assertEquals(Arrays.asList(group), db.getAvailableGroups(txn));
+		assertEquals(Collections.singletonList(group),
+				db.getAvailableGroups(txn));
 
 		// The second contact unsubscribes - it should no longer be available
 		db.setGroups(txn, contactId1, Collections.<Group>emptyList(), 2);
@@ -1501,9 +1335,8 @@ public class H2DatabaseTest extends BriarTestCase {
 				db.getInboxMessageHeaders(txn, contactId));
 
 		// Add a message to the inbox group - the header should be returned
-		boolean local = true, seen = false;
-		db.addMessage(txn, message, local);
-		db.addStatus(txn, contactId, messageId, false, seen);
+		db.addMessage(txn, message, true);
+		db.addStatus(txn, contactId, messageId, false, false);
 		Collection<MessageHeader> headers =
 				db.getInboxMessageHeaders(txn, contactId);
 		assertEquals(1, headers.size());
@@ -1514,7 +1347,7 @@ public class H2DatabaseTest extends BriarTestCase {
 		assertEquals(localAuthor, header.getAuthor());
 		assertEquals(contentType, header.getContentType());
 		assertEquals(timestamp, header.getTimestamp());
-		assertEquals(local, header.isLocal());
+		assertEquals(true, header.isLocal());
 		assertEquals(false, header.isRead());
 		assertEquals(STORED, header.getStatus());
 		assertFalse(header.isRead());
@@ -1560,7 +1393,7 @@ public class H2DatabaseTest extends BriarTestCase {
 		// Add a contact who subscribes to a group
 		db.addLocalAuthor(txn, localAuthor);
 		assertEquals(contactId, db.addContact(txn, author, localAuthorId));
-		db.setGroups(txn, contactId, Arrays.asList(group), 1);
+		db.setGroups(txn, contactId, Collections.singletonList(group), 1);
 
 		// Subscribe to the group and make it visible to the contact
 		db.addGroup(txn, group);
@@ -1571,7 +1404,7 @@ public class H2DatabaseTest extends BriarTestCase {
 		db.addStatus(txn, contactId, messageId, false, false);
 		Collection<MessageId> sendable = db.getMessagesToSend(txn, contactId,
 				ONE_MEGABYTE);
-		assertEquals(Arrays.asList(messageId), sendable);
+		assertEquals(Collections.singletonList(messageId), sendable);
 
 		// Mark the message as seen - it should no longer be sendable
 		db.raiseSeenFlag(txn, contactId, messageId);
@@ -1584,9 +1417,9 @@ public class H2DatabaseTest extends BriarTestCase {
 		assertEquals(Collections.emptyList(), sendable);
 
 		// The contact resubscribes - the message should be sendable again
-		db.setGroups(txn, contactId, Arrays.asList(group), 3);
+		db.setGroups(txn, contactId, Collections.singletonList(group), 3);
 		sendable = db.getMessagesToSend(txn, contactId, ONE_MEGABYTE);
-		assertEquals(Arrays.asList(messageId), sendable);
+		assertEquals(Collections.singletonList(messageId), sendable);
 
 		db.commitTransaction(txn);
 		db.close();
@@ -1616,6 +1449,26 @@ public class H2DatabaseTest extends BriarTestCase {
 		return db;
 	}
 
+	private TransportKeys createTransportKeys() {
+		SecretKey inPrevTagKey = TestUtils.createSecretKey();
+		SecretKey inPrevHeaderKey = TestUtils.createSecretKey();
+		IncomingKeys inPrev = new IncomingKeys(inPrevTagKey, inPrevHeaderKey,
+				1, 123, new byte[4]);
+		SecretKey inCurrTagKey = TestUtils.createSecretKey();
+		SecretKey inCurrHeaderKey = TestUtils.createSecretKey();
+		IncomingKeys inCurr = new IncomingKeys(inCurrTagKey, inCurrHeaderKey,
+				2, 234, new byte[4]);
+		SecretKey inNextTagKey = TestUtils.createSecretKey();
+		SecretKey inNextHeaderKey = TestUtils.createSecretKey();
+		IncomingKeys inNext = new IncomingKeys(inNextTagKey, inNextHeaderKey,
+				3, 345, new byte[4]);
+		SecretKey outCurrTagKey = TestUtils.createSecretKey();
+		SecretKey outCurrHeaderKey = TestUtils.createSecretKey();
+		OutgoingKeys outCurr = new OutgoingKeys(outCurrTagKey, outCurrHeaderKey,
+				2, 456);
+		return new TransportKeys(transportId, inPrev, inCurr, inNext, outCurr);
+	}
+
 	@After
 	public void tearDown() {
 		TestUtils.deleteTestDirectory(testDir);

briar-tests/src/org/briarproject/messaging/SimplexMessagingIntegrationTest.java

@@ -13,7 +13,8 @@ import org.briarproject.api.AuthorId;
 import org.briarproject.api.ContactId;
 import org.briarproject.api.LocalAuthor;
 import org.briarproject.api.TransportId;
-import org.briarproject.api.crypto.KeyManager;
+import org.briarproject.api.crypto.CryptoComponent;
+import org.briarproject.api.crypto.SecretKey;
 import org.briarproject.api.db.DatabaseComponent;
 import org.briarproject.api.event.Event;
 import org.briarproject.api.event.EventBus;
@@ -29,11 +30,11 @@ import org.briarproject.api.messaging.PacketReader;
 import org.briarproject.api.messaging.PacketReaderFactory;
 import org.briarproject.api.messaging.PacketWriter;
 import org.briarproject.api.messaging.PacketWriterFactory;
-import org.briarproject.api.transport.Endpoint;
+import org.briarproject.api.transport.KeyManager;
 import org.briarproject.api.transport.StreamContext;
 import org.briarproject.api.transport.StreamReaderFactory;
 import org.briarproject.api.transport.StreamWriterFactory;
-import org.briarproject.api.transport.TagRecogniser;
+import org.briarproject.api.transport.TransportKeys;
 import org.briarproject.crypto.CryptoModule;
 import org.briarproject.data.DataModule;
 import org.briarproject.db.DatabaseModule;
@@ -49,7 +50,7 @@ import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.InputStream;
 import java.io.OutputStream;
-import java.util.Random;
+import java.util.Collections;
 
 import static org.briarproject.api.AuthorConstants.MAX_PUBLIC_KEY_LENGTH;
 import static org.briarproject.api.messaging.MessagingConstants.GROUP_SALT_LENGTH;
@@ -63,26 +64,18 @@ import static org.junit.Assert.assertTrue;
 public class SimplexMessagingIntegrationTest extends BriarTestCase {
 
 	private static final int MAX_LATENCY = 2 * 60 * 1000; // 2 minutes
-	private static final int ROTATION_PERIOD =
-			MAX_CLOCK_DIFFERENCE + MAX_LATENCY;
+	private static final long ROTATION_PERIOD_LENGTH =
+			MAX_LATENCY + MAX_CLOCK_DIFFERENCE;
 
 	private final File testDir = TestUtils.getTestDirectory();
 	private final File aliceDir = new File(testDir, "alice");
 	private final File bobDir = new File(testDir, "bob");
-	private final TransportId transportId;
-	private final byte[] initialSecret;
-	private final long epoch;
+	private final TransportId transportId = new TransportId("id");
+	private final SecretKey master = TestUtils.createSecretKey();
+	private final long timestamp = System.currentTimeMillis();
 
 	private Injector alice, bob;
 
-	public SimplexMessagingIntegrationTest() throws Exception {
-		transportId = new TransportId("id");
-		// Create matching secrets for Alice and Bob
-		initialSecret = new byte[32];
-		new Random().nextBytes(initialSecret);
-		epoch = System.currentTimeMillis() - 2 * ROTATION_PERIOD;
-	}
-
 	@Before
 	public void setUp() {
 		testDir.mkdirs();
@@ -125,14 +118,17 @@ public class SimplexMessagingIntegrationTest extends BriarTestCase {
 		Group group = gf.createGroup("Group", new byte[GROUP_SALT_LENGTH]);
 		db.addGroup(group);
 		db.setInboxGroup(contactId, group);
-		// Add the transport and the endpoint
+		// Add the transport
 		db.addTransport(transportId, MAX_LATENCY);
-		Endpoint ep = new Endpoint(contactId, transportId, epoch, true);
-		db.addEndpoint(ep);
-		keyManager.endpointAdded(ep, MAX_LATENCY, initialSecret);
+		// Derive and store the transport keys
+		long rotationPeriod = timestamp / ROTATION_PERIOD_LENGTH;
+		CryptoComponent crypto = alice.getInstance(CryptoComponent.class);
+		TransportKeys keys = crypto.deriveTransportKeys(transportId, master,
+				rotationPeriod, true);
+		db.addTransportKeys(contactId, keys);
+		keyManager.contactAdded(contactId, Collections.singletonList(keys));
 		// Send Bob a message
 		String contentType = "text/plain";
-		long timestamp = System.currentTimeMillis();
 		byte[] body = "Hi Bob!".getBytes("UTF-8");
 		MessageFactory messageFactory = alice.getInstance(MessageFactory.class);
 		Message message = messageFactory.createAnonymousMessage(null, group,
@@ -166,7 +162,7 @@ public class SimplexMessagingIntegrationTest extends BriarTestCase {
 		return out.toByteArray();
 	}
 
-	private void read(byte[] b) throws Exception {
+	private void read(byte[] stream) throws Exception {
 		// Open Bob's database
 		DatabaseComponent db = bob.getInstance(DatabaseComponent.class);
 		assertFalse(db.open());
@@ -188,21 +184,24 @@ public class SimplexMessagingIntegrationTest extends BriarTestCase {
 		Group group = gf.createGroup("Group", new byte[GROUP_SALT_LENGTH]);
 		db.addGroup(group);
 		db.setInboxGroup(contactId, group);
-		// Add the transport and the endpoint
+		// Add the transport
 		db.addTransport(transportId, MAX_LATENCY);
-		Endpoint ep = new Endpoint(contactId, transportId, epoch, false);
-		db.addEndpoint(ep);
-		keyManager.endpointAdded(ep, MAX_LATENCY, initialSecret);
+		// Derive and store the transport keys
+		long rotationPeriod = timestamp / ROTATION_PERIOD_LENGTH;
+		CryptoComponent crypto = bob.getInstance(CryptoComponent.class);
+		TransportKeys keys = crypto.deriveTransportKeys(transportId, master,
+				rotationPeriod, false);
+		db.addTransportKeys(contactId, keys);
+		keyManager.contactAdded(contactId, Collections.singletonList(keys));
 		// Set up an event listener
 		MessageListener listener = new MessageListener();
 		bob.getInstance(EventBus.class).addListener(listener);
-		// Create a tag recogniser and recognise the tag
-		ByteArrayInputStream in = new ByteArrayInputStream(b);
-		TagRecogniser rec = bob.getInstance(TagRecogniser.class);
+		// Read and recognise the tag
+		ByteArrayInputStream in = new ByteArrayInputStream(stream);
 		byte[] tag = new byte[TAG_LENGTH];
 		int read = in.read(tag);
 		assertEquals(tag.length, read);
-		StreamContext ctx = rec.recogniseTag(transportId, tag);
+		StreamContext ctx = keyManager.recogniseTag(transportId, tag);
 		assertNotNull(ctx);
 		// Create a stream reader
 		StreamReaderFactory streamReaderFactory =

briar-tests/src/org/briarproject/transport/KeyManagerImplTest.java

@@ -1,600 +1,14 @@
 package org.briarproject.transport;
 
 import org.briarproject.BriarTestCase;
-import org.briarproject.api.ContactId;
-import org.briarproject.api.TransportId;
-import org.briarproject.api.crypto.CryptoComponent;
-import org.briarproject.api.db.DatabaseComponent;
-import org.briarproject.api.event.EventBus;
-import org.briarproject.api.event.EventListener;
-import org.briarproject.api.system.Clock;
-import org.briarproject.api.system.Timer;
-import org.briarproject.api.transport.Endpoint;
-import org.briarproject.api.transport.StreamContext;
-import org.briarproject.api.transport.TagRecogniser;
-import org.briarproject.api.transport.TemporarySecret;
-import org.jmock.Expectations;
-import org.jmock.Mockery;
 import org.junit.Test;
 
-import java.util.Arrays;
-import java.util.Collections;
-
-import static org.briarproject.api.transport.TransportConstants.MAX_CLOCK_DIFFERENCE;
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
 
 public class KeyManagerImplTest extends BriarTestCase {
 
-	private static final long EPOCH = 1000L * 1000L * 1000L * 1000L;
-	private static final int MAX_LATENCY = 2 * 60 * 1000; // 2 minutes
-	private static final int ROTATION_PERIOD =
-			MAX_CLOCK_DIFFERENCE + MAX_LATENCY;
-
-	private final ContactId contactId;
-	private final TransportId transportId;
-	private final byte[] secret0, secret1, secret2, secret3, secret4;
-	private final byte[] initialSecret;
-
-	public KeyManagerImplTest() {
-		contactId = new ContactId(234);
-		transportId = new TransportId("id");
-		secret0 = new byte[32];
-		secret1 = new byte[32];
-		secret2 = new byte[32];
-		secret3 = new byte[32];
-		secret4 = new byte[32];
-		for (int i = 0; i < secret0.length; i++) secret0[i] = 1;
-		for (int i = 0; i < secret1.length; i++) secret1[i] = 2;
-		for (int i = 0; i < secret2.length; i++) secret2[i] = 3;
-		for (int i = 0; i < secret3.length; i++) secret3[i] = 4;
-		for (int i = 0; i < secret4.length; i++) secret4[i] = 5;
-		initialSecret = new byte[32];
-		for (int i = 0; i < initialSecret.length; i++) initialSecret[i] = 123;
-	}
-
 	@Test
-	public void testStartAndStop() throws Exception {
-		Mockery context = new Mockery();
-		final CryptoComponent crypto = context.mock(CryptoComponent.class);
-		final DatabaseComponent db = context.mock(DatabaseComponent.class);
-		final EventBus eventBus = context.mock(EventBus.class);
-		final TagRecogniser tagRecogniser = context.mock(TagRecogniser.class);
-		final Clock clock = context.mock(Clock.class);
-		final Timer timer = context.mock(Timer.class);
-
-		final KeyManagerImpl keyManager = new KeyManagerImpl(crypto, db,
-				eventBus, tagRecogniser, clock, timer);
-
-		context.checking(new Expectations() {{
-			// start()
-			oneOf(eventBus).addListener(with(any(EventListener.class)));
-			oneOf(db).getSecrets();
-			will(returnValue(Collections.emptyList()));
-			oneOf(db).getTransportLatencies();
-			will(returnValue(Collections.emptyMap()));
-			oneOf(clock).currentTimeMillis();
-			will(returnValue(EPOCH));
-			oneOf(timer).scheduleAtFixedRate(with(keyManager),
-					with(any(long.class)), with(any(long.class)));
-			// stop()
-			oneOf(eventBus).removeListener(with(any(EventListener.class)));
-			oneOf(timer).cancel();
-			oneOf(tagRecogniser).removeSecrets();
-		}});
-
-		assertTrue(keyManager.start());
-		keyManager.stop();
-
-		context.assertIsSatisfied();
-	}
-
-	@Test
-	public void testEndpointAdded() throws Exception {
-		Mockery context = new Mockery();
-		final CryptoComponent crypto = context.mock(CryptoComponent.class);
-		final DatabaseComponent db = context.mock(DatabaseComponent.class);
-		final EventBus eventBus = context.mock(EventBus.class);
-		final TagRecogniser tagRecogniser = context.mock(TagRecogniser.class);
-		final Clock clock = context.mock(Clock.class);
-		final Timer timer = context.mock(Timer.class);
-
-		final KeyManagerImpl keyManager = new KeyManagerImpl(crypto, db,
-				eventBus, tagRecogniser, clock, timer);
-
-		// The secrets for periods 0 - 2 should be derived
-		Endpoint ep = new Endpoint(contactId, transportId, EPOCH, true);
-		final TemporarySecret s0 = new TemporarySecret(ep, 0, secret0);
-		final TemporarySecret s1 = new TemporarySecret(ep, 1, secret1);
-		final TemporarySecret s2 = new TemporarySecret(ep, 2, secret2);
-
-		context.checking(new Expectations() {{
-			// start()
-			oneOf(eventBus).addListener(with(any(EventListener.class)));
-			oneOf(db).getSecrets();
-			will(returnValue(Collections.emptyList()));
-			oneOf(db).getTransportLatencies();
-			will(returnValue(Collections.singletonMap(transportId,
-					MAX_LATENCY)));
-			oneOf(clock).currentTimeMillis();
-			will(returnValue(EPOCH));
-			oneOf(timer).scheduleAtFixedRate(with(keyManager),
-					with(any(long.class)), with(any(long.class)));
-			// endpointAdded() during rotation period 1
-			oneOf(clock).currentTimeMillis();
-			will(returnValue(EPOCH));
-			oneOf(crypto).deriveNextSecret(initialSecret, 0);
-			will(returnValue(secret0));
-			oneOf(crypto).deriveNextSecret(secret0, 1);
-			will(returnValue(secret1));
-			oneOf(crypto).deriveNextSecret(secret1, 2);
-			will(returnValue(secret2));
-			oneOf(db).addSecrets(Arrays.asList(s0, s1, s2));
-			// The secrets for periods 0 - 2 should be added to the recogniser
-			oneOf(tagRecogniser).addSecret(s0);
-			oneOf(tagRecogniser).addSecret(s1);
-			oneOf(tagRecogniser).addSecret(s2);
-			// stop()
-			oneOf(eventBus).removeListener(with(any(EventListener.class)));
-			oneOf(timer).cancel();
-			oneOf(tagRecogniser).removeSecrets();
-		}});
-
-		assertTrue(keyManager.start());
-		keyManager.endpointAdded(ep, MAX_LATENCY, initialSecret);
-		keyManager.stop();
-
-		context.assertIsSatisfied();
-	}
-
-	@Test
-	public void testEndpointAddedAndGetConnectionContext() throws Exception {
-		Mockery context = new Mockery();
-		final CryptoComponent crypto = context.mock(CryptoComponent.class);
-		final DatabaseComponent db = context.mock(DatabaseComponent.class);
-		final EventBus eventBus = context.mock(EventBus.class);
-		final TagRecogniser tagRecogniser = context.mock(TagRecogniser.class);
-		final Clock clock = context.mock(Clock.class);
-		final Timer timer = context.mock(Timer.class);
-
-		final KeyManagerImpl keyManager = new KeyManagerImpl(crypto, db,
-				eventBus, tagRecogniser, clock, timer);
-
-		// The secrets for periods 0 - 2 should be derived
-		Endpoint ep = new Endpoint(contactId, transportId, EPOCH, true);
-		final TemporarySecret s0 = new TemporarySecret(ep, 0, secret0);
-		final TemporarySecret s1 = new TemporarySecret(ep, 1, secret1);
-		final TemporarySecret s2 = new TemporarySecret(ep, 2, secret2);
-
-		context.checking(new Expectations() {{
-			// start()
-			oneOf(eventBus).addListener(with(any(EventListener.class)));
-			oneOf(db).getSecrets();
-			will(returnValue(Collections.emptyList()));
-			oneOf(db).getTransportLatencies();
-			will(returnValue(Collections.singletonMap(transportId,
-					MAX_LATENCY)));
-			oneOf(clock).currentTimeMillis();
-			will(returnValue(EPOCH));
-			oneOf(timer).scheduleAtFixedRate(with(keyManager),
-					with(any(long.class)), with(any(long.class)));
-			// endpointAdded() during rotation period 1
-			oneOf(clock).currentTimeMillis();
-			will(returnValue(EPOCH));
-			oneOf(crypto).deriveNextSecret(initialSecret, 0);
-			will(returnValue(secret0));
-			oneOf(crypto).deriveNextSecret(secret0, 1);
-			will(returnValue(secret1));
-			oneOf(crypto).deriveNextSecret(secret1, 2);
-			will(returnValue(secret2));
-			oneOf(db).addSecrets(Arrays.asList(s0, s1, s2));
-			// The secrets for periods 0 - 2 should be added to the recogniser
-			oneOf(tagRecogniser).addSecret(s0);
-			oneOf(tagRecogniser).addSecret(s1);
-			oneOf(tagRecogniser).addSecret(s2);
-			// getConnectionContext()
-			oneOf(db).incrementStreamCounter(contactId, transportId, 1);
-			will(returnValue(0L));
-			// stop()
-			oneOf(eventBus).removeListener(with(any(EventListener.class)));
-			oneOf(timer).cancel();
-			oneOf(tagRecogniser).removeSecrets();
-		}});
-
-		assertTrue(keyManager.start());
-		keyManager.endpointAdded(ep, MAX_LATENCY, initialSecret);
-		StreamContext ctx =
-				keyManager.getStreamContext(contactId, transportId);
-		assertNotNull(ctx);
-		assertEquals(contactId, ctx.getContactId());
-		assertEquals(transportId, ctx.getTransportId());
-		assertArrayEquals(secret1, ctx.getSecret());
-		assertEquals(0, ctx.getStreamNumber());
-		assertEquals(true, ctx.getAlice());
-		keyManager.stop();
-
-		context.assertIsSatisfied();
-	}
-
-	@Test
-	public void testLoadSecretsAtEpoch() throws Exception {
-		Mockery context = new Mockery();
-		final CryptoComponent crypto = context.mock(CryptoComponent.class);
-		final DatabaseComponent db = context.mock(DatabaseComponent.class);
-		final EventBus eventBus = context.mock(EventBus.class);
-		final TagRecogniser tagRecogniser = context.mock(TagRecogniser.class);
-		final Clock clock = context.mock(Clock.class);
-		final Timer timer = context.mock(Timer.class);
-
-		final KeyManagerImpl keyManager = new KeyManagerImpl(crypto, db,
-				eventBus, tagRecogniser, clock, timer);
-
-		// The DB contains the secrets for periods 0 - 2
-		Endpoint ep = new Endpoint(contactId, transportId, EPOCH, true);
-		final TemporarySecret s0 = new TemporarySecret(ep, 0, secret0);
-		final TemporarySecret s1 = new TemporarySecret(ep, 1, secret1);
-		final TemporarySecret s2 = new TemporarySecret(ep, 2, secret2);
-
-		context.checking(new Expectations() {{
-			// start()
-			oneOf(eventBus).addListener(with(any(EventListener.class)));
-			oneOf(db).getSecrets();
-			will(returnValue(Arrays.asList(s0, s1, s2)));
-			oneOf(db).getTransportLatencies();
-			will(returnValue(Collections.singletonMap(transportId,
-					MAX_LATENCY)));
-			// The current time is the epoch, the start of period 1
-			oneOf(clock).currentTimeMillis();
-			will(returnValue(EPOCH));
-			// The secrets for periods 0 - 2 should be added to the recogniser
-			oneOf(tagRecogniser).addSecret(s0);
-			oneOf(tagRecogniser).addSecret(s1);
-			oneOf(tagRecogniser).addSecret(s2);
-			oneOf(timer).scheduleAtFixedRate(with(keyManager),
-					with(any(long.class)), with(any(long.class)));
-			// stop()
-			oneOf(eventBus).removeListener(with(any(EventListener.class)));
-			oneOf(timer).cancel();
-			oneOf(tagRecogniser).removeSecrets();
-		}});
-
-		assertTrue(keyManager.start());
-		keyManager.stop();
-
-		context.assertIsSatisfied();
-	}
-
-	@Test
-	public void testLoadSecretsAtStartOfPeriod2() throws Exception {
-		Mockery context = new Mockery();
-		final CryptoComponent crypto = context.mock(CryptoComponent.class);
-		final DatabaseComponent db = context.mock(DatabaseComponent.class);
-		final EventBus eventBus = context.mock(EventBus.class);
-		final TagRecogniser tagRecogniser = context.mock(TagRecogniser.class);
-		final Clock clock = context.mock(Clock.class);
-		final Timer timer = context.mock(Timer.class);
-
-		final KeyManagerImpl keyManager = new KeyManagerImpl(crypto, db,
-				eventBus, tagRecogniser, clock, timer);
-
-		// The DB contains the secrets for periods 0 - 2
-		Endpoint ep = new Endpoint(contactId, transportId, EPOCH, true);
-		final TemporarySecret s0 = new TemporarySecret(ep, 0, secret0);
-		final TemporarySecret s1 = new TemporarySecret(ep, 1, secret1);
-		final TemporarySecret s2 = new TemporarySecret(ep, 2, secret2);
-		// The secret for period 3 should be derived and stored
-		final TemporarySecret s3 = new TemporarySecret(ep, 3, secret3);
-
-		context.checking(new Expectations() {{
-			// start()
-			oneOf(eventBus).addListener(with(any(EventListener.class)));
-			oneOf(db).getSecrets();
-			will(returnValue(Arrays.asList(s0, s1, s2)));
-			oneOf(db).getTransportLatencies();
-			will(returnValue(Collections.singletonMap(transportId,
-					MAX_LATENCY)));
-			// The current time is the start of period 2
-			oneOf(clock).currentTimeMillis();
-			will(returnValue(EPOCH + ROTATION_PERIOD));
-			// The secret for period 3 should be derived and stored
-			oneOf(crypto).deriveNextSecret(secret0, 1);
-			will(returnValue(secret1));
-			oneOf(crypto).deriveNextSecret(secret1, 2);
-			will(returnValue(secret2));
-			oneOf(crypto).deriveNextSecret(secret2, 3);
-			will(returnValue(secret3));
-			oneOf(db).addSecrets(Arrays.asList(s3));
-			// The secrets for periods 1 - 3 should be added to the recogniser
-			oneOf(tagRecogniser).addSecret(s1);
-			oneOf(tagRecogniser).addSecret(s2);
-			oneOf(tagRecogniser).addSecret(s3);
-			oneOf(timer).scheduleAtFixedRate(with(keyManager),
-					with(any(long.class)), with(any(long.class)));
-			// stop()
-			oneOf(eventBus).removeListener(with(any(EventListener.class)));
-			oneOf(timer).cancel();
-			oneOf(tagRecogniser).removeSecrets();
-		}});
-
-		assertTrue(keyManager.start());
-		keyManager.stop();
-
-		context.assertIsSatisfied();
-	}
-
-	@Test
-	public void testLoadSecretsAtEndOfPeriod3() throws Exception {
-		Mockery context = new Mockery();
-		final CryptoComponent crypto = context.mock(CryptoComponent.class);
-		final DatabaseComponent db = context.mock(DatabaseComponent.class);
-		final EventBus eventBus = context.mock(EventBus.class);
-		final TagRecogniser tagRecogniser = context.mock(TagRecogniser.class);
-		final Clock clock = context.mock(Clock.class);
-		final Timer timer = context.mock(Timer.class);
-
-		final KeyManagerImpl keyManager = new KeyManagerImpl(crypto, db,
-				eventBus, tagRecogniser, clock, timer);
-
-		// The DB contains the secrets for periods 0 - 2
-		Endpoint ep = new Endpoint(contactId, transportId, EPOCH, true);
-		final TemporarySecret s0 = new TemporarySecret(ep, 0, secret0);
-		final TemporarySecret s1 = new TemporarySecret(ep, 1, secret1);
-		final TemporarySecret s2 = new TemporarySecret(ep, 2, secret2);
-		// The secrets for periods 3 and 4 should be derived and stored
-		final TemporarySecret s3 = new TemporarySecret(ep, 3, secret3);
-		final TemporarySecret s4 = new TemporarySecret(ep, 4, secret4);
-
-		context.checking(new Expectations() {{
-			// start()
-			oneOf(eventBus).addListener(with(any(EventListener.class)));
-			oneOf(db).getSecrets();
-			will(returnValue(Arrays.asList(s0, s1, s2)));
-			oneOf(db).getTransportLatencies();
-			will(returnValue(Collections.singletonMap(transportId,
-					MAX_LATENCY)));
-			// The current time is the end of period 3
-			oneOf(clock).currentTimeMillis();
-			will(returnValue(EPOCH + 3 * ROTATION_PERIOD - 1));
-			// The secrets for periods 3 and 4 should be derived from secret 1
-			oneOf(crypto).deriveNextSecret(secret1, 2);
-			will(returnValue(secret2));
-			oneOf(crypto).deriveNextSecret(secret2, 3);
-			will(returnValue(secret3));
-			oneOf(crypto).deriveNextSecret(secret3, 4);
-			will(returnValue(secret4));
-			// The new secrets should be stored
-			oneOf(db).addSecrets(Arrays.asList(s3, s4));
-			// The secrets for periods 2 - 4 should be added to the recogniser
-			oneOf(tagRecogniser).addSecret(s2);
-			oneOf(tagRecogniser).addSecret(s3);
-			oneOf(tagRecogniser).addSecret(s4);
-			oneOf(timer).scheduleAtFixedRate(with(keyManager),
-					with(any(long.class)), with(any(long.class)));
-			// stop()
-			oneOf(eventBus).removeListener(with(any(EventListener.class)));
-			oneOf(timer).cancel();
-			oneOf(tagRecogniser).removeSecrets();
-		}});
-
-		assertTrue(keyManager.start());
-		keyManager.stop();
-
-		context.assertIsSatisfied();
-	}
-
-	@Test
-	public void testLoadSecretsAndRotateInSamePeriod() throws Exception {
-		Mockery context = new Mockery();
-		final CryptoComponent crypto = context.mock(CryptoComponent.class);
-		final DatabaseComponent db = context.mock(DatabaseComponent.class);
-		final EventBus eventBus = context.mock(EventBus.class);
-		final TagRecogniser tagRecogniser = context.mock(TagRecogniser.class);
-		final Clock clock = context.mock(Clock.class);
-		final Timer timer = context.mock(Timer.class);
-
-		final KeyManagerImpl keyManager = new KeyManagerImpl(crypto, db,
-				eventBus, tagRecogniser, clock, timer);
-
-		// The DB contains the secrets for periods 0 - 2
-		Endpoint ep = new Endpoint(contactId, transportId, EPOCH, true);
-		final TemporarySecret s0 = new TemporarySecret(ep, 0, secret0);
-		final TemporarySecret s1 = new TemporarySecret(ep, 1, secret1);
-		final TemporarySecret s2 = new TemporarySecret(ep, 2, secret2);
-
-		context.checking(new Expectations() {{
-			// start()
-			oneOf(eventBus).addListener(with(any(EventListener.class)));
-			oneOf(db).getSecrets();
-			will(returnValue(Arrays.asList(s0, s1, s2)));
-			oneOf(db).getTransportLatencies();
-			will(returnValue(Collections.singletonMap(transportId,
-					MAX_LATENCY)));
-			// The current time is the epoch, the start of period 1
-			oneOf(clock).currentTimeMillis();
-			will(returnValue(EPOCH));
-			// The secrets for periods 0 - 2 should be added to the recogniser
-			oneOf(tagRecogniser).addSecret(s0);
-			oneOf(tagRecogniser).addSecret(s1);
-			oneOf(tagRecogniser).addSecret(s2);
-			oneOf(timer).scheduleAtFixedRate(with(keyManager),
-					with(any(long.class)), with(any(long.class)));
-			// run() during period 1: the secrets should not be affected
-			oneOf(clock).currentTimeMillis();
-			will(returnValue(EPOCH + 1));
-			// getConnectionContext()
-			oneOf(db).incrementStreamCounter(contactId, transportId, 1);
-			will(returnValue(0L));
-			// stop()
-			oneOf(eventBus).removeListener(with(any(EventListener.class)));
-			oneOf(timer).cancel();
-			oneOf(tagRecogniser).removeSecrets();
-		}});
-
-		assertTrue(keyManager.start());
-		keyManager.run();
-		StreamContext ctx =
-				keyManager.getStreamContext(contactId, transportId);
-		assertNotNull(ctx);
-		assertEquals(contactId, ctx.getContactId());
-		assertEquals(transportId, ctx.getTransportId());
-		assertArrayEquals(secret1, ctx.getSecret());
-		assertEquals(0, ctx.getStreamNumber());
-		assertEquals(true, ctx.getAlice());
-		keyManager.stop();
-
-		context.assertIsSatisfied();
-	}
-
-	@Test
-	public void testLoadSecretsAndRotateInNextPeriod() throws Exception {
-		Mockery context = new Mockery();
-		final CryptoComponent crypto = context.mock(CryptoComponent.class);
-		final DatabaseComponent db = context.mock(DatabaseComponent.class);
-		final EventBus eventBus = context.mock(EventBus.class);
-		final TagRecogniser tagRecogniser = context.mock(TagRecogniser.class);
-		final Clock clock = context.mock(Clock.class);
-		final Timer timer = context.mock(Timer.class);
-
-		final KeyManagerImpl keyManager = new KeyManagerImpl(crypto, db,
-				eventBus, tagRecogniser, clock, timer);
-
-		// The DB contains the secrets for periods 0 - 2
-		Endpoint ep = new Endpoint(contactId, transportId, EPOCH, true);
-		final TemporarySecret s0 = new TemporarySecret(ep, 0, secret0);
-		final TemporarySecret s1 = new TemporarySecret(ep, 1, secret1);
-		final TemporarySecret s2 = new TemporarySecret(ep, 2, secret2);
-		// The secret for period 3 should be derived and stored
-		final TemporarySecret s3 = new TemporarySecret(ep, 3, secret3);
-
-		context.checking(new Expectations() {{
-			// start()
-			oneOf(eventBus).addListener(with(any(EventListener.class)));
-			oneOf(db).getSecrets();
-			will(returnValue(Arrays.asList(s0, s1, s2)));
-			oneOf(db).getTransportLatencies();
-			will(returnValue(Collections.singletonMap(transportId,
-					MAX_LATENCY)));
-			// The current time is the epoch, the start of period 1
-			oneOf(clock).currentTimeMillis();
-			will(returnValue(EPOCH));
-			// The secrets for periods 0 - 2 should be added to the recogniser
-			oneOf(tagRecogniser).addSecret(s0);
-			oneOf(tagRecogniser).addSecret(s1);
-			oneOf(tagRecogniser).addSecret(s2);
-			oneOf(timer).scheduleAtFixedRate(with(keyManager),
-					with(any(long.class)), with(any(long.class)));
-			// run() during period 2: the secrets should be rotated
-			oneOf(clock).currentTimeMillis();
-			will(returnValue(EPOCH + ROTATION_PERIOD + 1));
-			oneOf(crypto).deriveNextSecret(secret0, 1);
-			will(returnValue(secret1));
-			oneOf(crypto).deriveNextSecret(secret1, 2);
-			will(returnValue(secret2));
-			oneOf(crypto).deriveNextSecret(secret2, 3);
-			will(returnValue(secret3));
-			oneOf(tagRecogniser).removeSecret(contactId, transportId, 0);
-			oneOf(db).addSecrets(Arrays.asList(s3));
-			oneOf(tagRecogniser).addSecret(s3);
-			// getConnectionContext()
-			oneOf(db).incrementStreamCounter(contactId, transportId, 2);
-			will(returnValue(0L));
-			// stop()
-			oneOf(eventBus).removeListener(with(any(EventListener.class)));
-			oneOf(timer).cancel();
-			oneOf(tagRecogniser).removeSecrets();
-		}});
-
-		assertTrue(keyManager.start());
-		keyManager.run();
-		StreamContext ctx =
-				keyManager.getStreamContext(contactId, transportId);
-		assertNotNull(ctx);
-		assertEquals(contactId, ctx.getContactId());
-		assertEquals(transportId, ctx.getTransportId());
-		assertArrayEquals(secret2, ctx.getSecret());
-		assertEquals(0, ctx.getStreamNumber());
-		assertEquals(true, ctx.getAlice());
-		keyManager.stop();
-
-		context.assertIsSatisfied();
-	}
-
-	@Test
-	public void testLoadSecretsAndRotateAWholePeriodLate() throws Exception {
-		Mockery context = new Mockery();
-		final CryptoComponent crypto = context.mock(CryptoComponent.class);
-		final DatabaseComponent db = context.mock(DatabaseComponent.class);
-		final EventBus eventBus = context.mock(EventBus.class);
-		final TagRecogniser tagRecogniser = context.mock(TagRecogniser.class);
-		final Clock clock = context.mock(Clock.class);
-		final Timer timer = context.mock(Timer.class);
-
-		final KeyManagerImpl keyManager = new KeyManagerImpl(crypto, db,
-				eventBus, tagRecogniser, clock, timer);
-
-		// The DB contains the secrets for periods 0 - 2
-		Endpoint ep = new Endpoint(contactId, transportId, EPOCH, true);
-		final TemporarySecret s0 = new TemporarySecret(ep, 0, secret0);
-		final TemporarySecret s1 = new TemporarySecret(ep, 1, secret1);
-		final TemporarySecret s2 = new TemporarySecret(ep, 2, secret2);
-		// The secrets for periods 3 and 4 should be derived and stored
-		final TemporarySecret s3 = new TemporarySecret(ep, 3, secret3);
-		final TemporarySecret s4 = new TemporarySecret(ep, 4, secret4);
-
-		context.checking(new Expectations() {{
-			// start()
-			oneOf(eventBus).addListener(with(any(EventListener.class)));
-			oneOf(db).getSecrets();
-			will(returnValue(Arrays.asList(s0, s1, s2)));
-			oneOf(db).getTransportLatencies();
-			will(returnValue(Collections.singletonMap(transportId,
-					MAX_LATENCY)));
-			// The current time is the epoch, the start of period 1
-			oneOf(clock).currentTimeMillis();
-			will(returnValue(EPOCH));
-			// The secrets for periods 0 - 2 should be added to the recogniser
-			oneOf(tagRecogniser).addSecret(s0);
-			oneOf(tagRecogniser).addSecret(s1);
-			oneOf(tagRecogniser).addSecret(s2);
-			oneOf(timer).scheduleAtFixedRate(with(keyManager),
-					with(any(long.class)), with(any(long.class)));
-			// run() during period 3 (late): the secrets should be rotated
-			oneOf(clock).currentTimeMillis();
-			will(returnValue(EPOCH + 2 * ROTATION_PERIOD + 1));
-			oneOf(crypto).deriveNextSecret(secret1, 2);
-			will(returnValue(secret2));
-			oneOf(crypto).deriveNextSecret(secret2, 3);
-			will(returnValue(secret3));
-			oneOf(crypto).deriveNextSecret(secret3, 4);
-			will(returnValue(secret4));
-			oneOf(tagRecogniser).removeSecret(contactId, transportId, 0);
-			oneOf(tagRecogniser).removeSecret(contactId, transportId, 1);
-			oneOf(db).addSecrets(Arrays.asList(s3, s4));
-			oneOf(tagRecogniser).addSecret(s3);
-			oneOf(tagRecogniser).addSecret(s4);
-			// getConnectionContext()
-			oneOf(db).incrementStreamCounter(contactId, transportId, 3);
-			will(returnValue(0L));
-			// stop()
-			oneOf(eventBus).removeListener(with(any(EventListener.class)));
-			oneOf(timer).cancel();
-			oneOf(tagRecogniser).removeSecrets();
-		}});
-
-		assertTrue(keyManager.start());
-		keyManager.run();
-		StreamContext ctx =
-				keyManager.getStreamContext(contactId, transportId);
-		assertNotNull(ctx);
-		assertEquals(contactId, ctx.getContactId());
-		assertEquals(transportId, ctx.getTransportId());
-		assertArrayEquals(secret3, ctx.getSecret());
-		assertEquals(0, ctx.getStreamNumber());
-		assertEquals(true, ctx.getAlice());
-		keyManager.stop();
-
-		context.assertIsSatisfied();
+	public void testUnitTestsExist() {
+		fail(); // FIXME: Write tests
 	}
 }

briar-tests/src/org/briarproject/transport/KeyRotationIntegrationTest.java

@@ -1,772 +0,0 @@
-package org.briarproject.transport;
-
-import org.briarproject.BriarTestCase;
-import org.briarproject.api.ContactId;
-import org.briarproject.api.TransportId;
-import org.briarproject.api.crypto.CryptoComponent;
-import org.briarproject.api.crypto.SecretKey;
-import org.briarproject.api.db.DatabaseComponent;
-import org.briarproject.api.event.EventBus;
-import org.briarproject.api.event.EventListener;
-import org.briarproject.api.system.Clock;
-import org.briarproject.api.system.Timer;
-import org.briarproject.api.transport.Endpoint;
-import org.briarproject.api.transport.StreamContext;
-import org.briarproject.api.transport.TagRecogniser;
-import org.briarproject.api.transport.TemporarySecret;
-import org.briarproject.util.ByteUtils;
-import org.hamcrest.Description;
-import org.jmock.Expectations;
-import org.jmock.Mockery;
-import org.jmock.api.Action;
-import org.jmock.api.Invocation;
-import org.junit.Test;
-
-import java.util.Arrays;
-import java.util.Collections;
-
-import static org.briarproject.api.transport.TransportConstants.MAX_CLOCK_DIFFERENCE;
-import static org.briarproject.api.transport.TransportConstants.TAG_LENGTH;
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-
-public class KeyRotationIntegrationTest extends BriarTestCase {
-
-	private static final long EPOCH = 1000L * 1000L * 1000L * 1000L;
-	private static final int MAX_LATENCY = 2 * 60 * 1000; // 2 minutes
-	private static final int ROTATION_PERIOD =
-			MAX_CLOCK_DIFFERENCE + MAX_LATENCY;
-
-	private final ContactId contactId;
-	private final TransportId transportId;
-	private final byte[] secret0, secret1, secret2, secret3, secret4;
-	private final byte[] key0, key1, key2, key3, key4;
-	private final SecretKey k0, k1, k2, k3, k4;
-	private final byte[] initialSecret;
-
-	public KeyRotationIntegrationTest() {
-		contactId = new ContactId(234);
-		transportId = new TransportId("id");
-		secret0 = new byte[32];
-		secret1 = new byte[32];
-		secret2 = new byte[32];
-		secret3 = new byte[32];
-		secret4 = new byte[32];
-		for (int i = 0; i < secret0.length; i++) secret0[i] = 1;
-		for (int i = 0; i < secret1.length; i++) secret1[i] = 2;
-		for (int i = 0; i < secret2.length; i++) secret2[i] = 3;
-		for (int i = 0; i < secret3.length; i++) secret3[i] = 4;
-		for (int i = 0; i < secret4.length; i++) secret4[i] = 5;
-		key0 = new byte[32];
-		key1 = new byte[32];
-		key2 = new byte[32];
-		key3 = new byte[32];
-		key4 = new byte[32];
-		k0 = new SecretKey(key0);
-		k1 = new SecretKey(key1);
-		k2 = new SecretKey(key2);
-		k3 = new SecretKey(key3);
-		k4 = new SecretKey(key4);
-		for (int i = 0; i < key0.length; i++) key0[i] = 1;
-		for (int i = 0; i < key1.length; i++) key1[i] = 2;
-		for (int i = 0; i < key2.length; i++) key2[i] = 3;
-		for (int i = 0; i < key3.length; i++) key3[i] = 4;
-		for (int i = 0; i < key4.length; i++) key4[i] = 5;
-		initialSecret = new byte[32];
-		for (int i = 0; i < initialSecret.length; i++) initialSecret[i] = 123;
-	}
-
-	@Test
-	public void testStartAndStop() throws Exception {
-		Mockery context = new Mockery();
-		final CryptoComponent crypto = context.mock(CryptoComponent.class);
-		final DatabaseComponent db = context.mock(DatabaseComponent.class);
-		final EventBus eventBus = context.mock(EventBus.class);
-		final Clock clock = context.mock(Clock.class);
-		final Timer timer = context.mock(Timer.class);
-
-		final TagRecogniser tagRecogniser = new TagRecogniserImpl(crypto, db);
-		final KeyManagerImpl keyManager = new KeyManagerImpl(crypto, db,
-				eventBus, tagRecogniser, clock, timer);
-
-		context.checking(new Expectations() {{
-			// start()
-			oneOf(eventBus).addListener(with(any(EventListener.class)));
-			oneOf(db).getSecrets();
-			will(returnValue(Collections.emptyList()));
-			oneOf(db).getTransportLatencies();
-			will(returnValue(Collections.emptyMap()));
-			oneOf(clock).currentTimeMillis();
-			will(returnValue(EPOCH));
-			oneOf(timer).scheduleAtFixedRate(with(keyManager),
-					with(any(long.class)), with(any(long.class)));
-			// stop()
-			oneOf(eventBus).removeListener(with(any(EventListener.class)));
-			oneOf(timer).cancel();
-		}});
-
-		assertTrue(keyManager.start());
-		keyManager.stop();
-
-		context.assertIsSatisfied();
-	}
-
-	@Test
-	public void testEndpointAdded() throws Exception {
-		Mockery context = new Mockery();
-		final CryptoComponent crypto = context.mock(CryptoComponent.class);
-		final DatabaseComponent db = context.mock(DatabaseComponent.class);
-		final EventBus eventBus = context.mock(EventBus.class);
-		final Clock clock = context.mock(Clock.class);
-		final Timer timer = context.mock(Timer.class);
-
-		final TagRecogniser tagRecogniser = new TagRecogniserImpl(crypto, db);
-		final KeyManagerImpl keyManager = new KeyManagerImpl(crypto, db,
-				eventBus, tagRecogniser, clock, timer);
-
-		// The secrets for periods 0 - 2 should be derived
-		Endpoint ep = new Endpoint(contactId, transportId, EPOCH, true);
-		final TemporarySecret s0 = new TemporarySecret(ep, 0, secret0);
-		final TemporarySecret s1 = new TemporarySecret(ep, 1, secret1);
-		final TemporarySecret s2 = new TemporarySecret(ep, 2, secret2);
-
-		context.checking(new Expectations() {{
-			// start()
-			oneOf(eventBus).addListener(with(any(EventListener.class)));
-			oneOf(db).getSecrets();
-			will(returnValue(Collections.emptyList()));
-			oneOf(db).getTransportLatencies();
-			will(returnValue(Collections.singletonMap(transportId,
-					MAX_LATENCY)));
-			oneOf(clock).currentTimeMillis();
-			will(returnValue(EPOCH));
-			oneOf(timer).scheduleAtFixedRate(with(keyManager),
-					with(any(long.class)), with(any(long.class)));
-			// endpointAdded() during rotation period 1
-			oneOf(clock).currentTimeMillis();
-			will(returnValue(EPOCH));
-			oneOf(crypto).deriveNextSecret(initialSecret, 0);
-			will(returnValue(secret0));
-			oneOf(crypto).deriveNextSecret(secret0, 1);
-			will(returnValue(secret1));
-			oneOf(crypto).deriveNextSecret(secret1, 2);
-			will(returnValue(secret2));
-			oneOf(db).addSecrets(Arrays.asList(s0, s1, s2));
-			// The recogniser should derive the tags for period 0
-			oneOf(crypto).deriveTagKey(secret0, false);
-			will(returnValue(k0));
-			for (int i = 0; i < 16; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(k0),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-			// The recogniser should derive the tags for period 1
-			oneOf(crypto).deriveTagKey(secret1, false);
-			will(returnValue(k1));
-			for (int i = 0; i < 16; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(k1),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-			// The recogniser should derive the tags for period 2
-			oneOf(crypto).deriveTagKey(secret2, false);
-			will(returnValue(k2));
-			for (int i = 0; i < 16; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(k2),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-			// stop()
-			// The recogniser should derive the tags for period 0
-			oneOf(crypto).deriveTagKey(secret0, false);
-			will(returnValue(k0));
-			for (int i = 0; i < 16; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(k0),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-			// The recogniser should derive the tags for period 1
-			oneOf(crypto).deriveTagKey(secret1, false);
-			will(returnValue(k1));
-			for (int i = 0; i < 16; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(k1),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-			// The recogniser should derive the tags for period 2
-			oneOf(crypto).deriveTagKey(secret2, false);
-			will(returnValue(k2));
-			for (int i = 0; i < 16; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(k2),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-			// Remove the listener and stop the timer
-			oneOf(eventBus).removeListener(with(any(EventListener.class)));
-			oneOf(timer).cancel();
-		}});
-
-		assertTrue(keyManager.start());
-		keyManager.endpointAdded(ep, MAX_LATENCY, initialSecret);
-		keyManager.stop();
-
-		context.assertIsSatisfied();
-	}
-
-	@Test
-	public void testEndpointAddedAndGetConnectionContext() throws Exception {
-		Mockery context = new Mockery();
-		final CryptoComponent crypto = context.mock(CryptoComponent.class);
-		final DatabaseComponent db = context.mock(DatabaseComponent.class);
-		final EventBus eventBus = context.mock(EventBus.class);
-		final Clock clock = context.mock(Clock.class);
-		final Timer timer = context.mock(Timer.class);
-
-		final TagRecogniser tagRecogniser = new TagRecogniserImpl(crypto, db);
-		final KeyManagerImpl keyManager = new KeyManagerImpl(crypto, db,
-				eventBus, tagRecogniser, clock, timer);
-
-		// The secrets for periods 0 - 2 should be derived
-		Endpoint ep = new Endpoint(contactId, transportId, EPOCH, true);
-		final TemporarySecret s0 = new TemporarySecret(ep, 0, secret0);
-		final TemporarySecret s1 = new TemporarySecret(ep, 1, secret1);
-		final TemporarySecret s2 = new TemporarySecret(ep, 2, secret2);
-
-		context.checking(new Expectations() {{
-			// start()
-			oneOf(eventBus).addListener(with(any(EventListener.class)));
-			oneOf(db).getSecrets();
-			will(returnValue(Collections.emptyList()));
-			oneOf(db).getTransportLatencies();
-			will(returnValue(Collections.singletonMap(transportId,
-					MAX_LATENCY)));
-			oneOf(clock).currentTimeMillis();
-			will(returnValue(EPOCH));
-			oneOf(timer).scheduleAtFixedRate(with(keyManager),
-					with(any(long.class)), with(any(long.class)));
-			// endpointAdded() during rotation period 1
-			oneOf(clock).currentTimeMillis();
-			will(returnValue(EPOCH));
-			oneOf(crypto).deriveNextSecret(initialSecret, 0);
-			will(returnValue(secret0));
-			oneOf(crypto).deriveNextSecret(secret0, 1);
-			will(returnValue(secret1));
-			oneOf(crypto).deriveNextSecret(secret1, 2);
-			will(returnValue(secret2));
-			oneOf(db).addSecrets(Arrays.asList(s0, s1, s2));
-			// The recogniser should derive the tags for period 0
-			oneOf(crypto).deriveTagKey(secret0, false);
-			will(returnValue(k0));
-			for (int i = 0; i < 16; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(k0),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-			// The recogniser should derive the tags for period 1
-			oneOf(crypto).deriveTagKey(secret1, false);
-			will(returnValue(k1));
-			for (int i = 0; i < 16; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(k1),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-			// The recogniser should derive the tags for period 2
-			oneOf(crypto).deriveTagKey(secret2, false);
-			will(returnValue(k2));
-			for (int i = 0; i < 16; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(k2),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-			// getConnectionContext()
-			oneOf(db).incrementStreamCounter(contactId, transportId, 1);
-			will(returnValue(0L));
-			// stop()
-			// The recogniser should derive the tags for period 0
-			oneOf(crypto).deriveTagKey(secret0, false);
-			will(returnValue(k0));
-			for (int i = 0; i < 16; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(k0),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-			// The recogniser should derive the tags for period 1
-			oneOf(crypto).deriveTagKey(secret1, false);
-			will(returnValue(k1));
-			for (int i = 0; i < 16; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(k1),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-			// The recogniser should derive the tags for period 2
-			oneOf(crypto).deriveTagKey(secret2, false);
-			will(returnValue(k2));
-			for (int i = 0; i < 16; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(k2),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-			// Remove the listener and stop the timer
-			oneOf(eventBus).removeListener(with(any(EventListener.class)));
-			oneOf(timer).cancel();
-		}});
-
-		assertTrue(keyManager.start());
-		keyManager.endpointAdded(ep, MAX_LATENCY, initialSecret);
-		StreamContext ctx =
-				keyManager.getStreamContext(contactId, transportId);
-		assertNotNull(ctx);
-		assertEquals(contactId, ctx.getContactId());
-		assertEquals(transportId, ctx.getTransportId());
-		assertArrayEquals(secret1, ctx.getSecret());
-		assertEquals(0, ctx.getStreamNumber());
-		assertEquals(true, ctx.getAlice());
-		keyManager.stop();
-
-		context.assertIsSatisfied();
-	}
-
-	@Test
-	public void testEndpointAddedAndAcceptConnection() throws Exception {
-		Mockery context = new Mockery();
-		final CryptoComponent crypto = context.mock(CryptoComponent.class);
-		final DatabaseComponent db = context.mock(DatabaseComponent.class);
-		final EventBus eventBus = context.mock(EventBus.class);
-		final Clock clock = context.mock(Clock.class);
-		final Timer timer = context.mock(Timer.class);
-
-		final TagRecogniser tagRecogniser = new TagRecogniserImpl(crypto, db);
-		final KeyManagerImpl keyManager = new KeyManagerImpl(crypto, db,
-				eventBus, tagRecogniser, clock, timer);
-
-		// The secrets for periods 0 - 2 should be derived
-		Endpoint ep = new Endpoint(contactId, transportId, EPOCH, true);
-		final TemporarySecret s0 = new TemporarySecret(ep, 0, secret0);
-		final TemporarySecret s1 = new TemporarySecret(ep, 1, secret1);
-		final TemporarySecret s2 = new TemporarySecret(ep, 2, secret2);
-
-		context.checking(new Expectations() {{
-			// start()
-			oneOf(eventBus).addListener(with(any(EventListener.class)));
-			oneOf(db).getSecrets();
-			will(returnValue(Collections.emptyList()));
-			oneOf(db).getTransportLatencies();
-			will(returnValue(Collections.singletonMap(transportId,
-					MAX_LATENCY)));
-			oneOf(clock).currentTimeMillis();
-			will(returnValue(EPOCH));
-			oneOf(timer).scheduleAtFixedRate(with(keyManager),
-					with(any(long.class)), with(any(long.class)));
-			// endpointAdded() during rotation period 1
-			oneOf(clock).currentTimeMillis();
-			will(returnValue(EPOCH));
-			oneOf(crypto).deriveNextSecret(initialSecret, 0);
-			will(returnValue(secret0));
-			oneOf(crypto).deriveNextSecret(secret0, 1);
-			will(returnValue(secret1));
-			oneOf(crypto).deriveNextSecret(secret1, 2);
-			will(returnValue(secret2));
-			oneOf(db).addSecrets(Arrays.asList(s0, s1, s2));
-			// The recogniser should derive the tags for period 0
-			oneOf(crypto).deriveTagKey(secret0, false);
-			will(returnValue(k0));
-			for (int i = 0; i < 16; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(k0),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-			// The recogniser should derive the tags for period 1
-			oneOf(crypto).deriveTagKey(secret1, false);
-			will(returnValue(k1));
-			for (int i = 0; i < 16; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(k1),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-			// The recogniser should derive the tags for period 2
-			oneOf(crypto).deriveTagKey(secret2, false);
-			will(returnValue(k2));
-			for (int i = 0; i < 16; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(k2),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-			// acceptConnection()
-			oneOf(crypto).deriveTagKey(secret2, false);
-			will(returnValue(k2));
-			oneOf(crypto).encodeTag(with(any(byte[].class)), with(k2),
-					with(16L));
-			will(new EncodeTagAction());
-			oneOf(db).setReorderingWindow(contactId, transportId, 2, 1,
-					new byte[] {0, 1, 0, 0});
-			// stop()
-			// The recogniser should derive the tags for period 0
-			oneOf(crypto).deriveTagKey(secret0, false);
-			will(returnValue(k0));
-			for (int i = 0; i < 16; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(k0),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-			// The recogniser should derive the tags for period 1
-			oneOf(crypto).deriveTagKey(secret1, false);
-			will(returnValue(k1));
-			for (int i = 0; i < 16; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(k1),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-			// The recogniser should derive the updated tags for period 2
-			oneOf(crypto).deriveTagKey(secret2, false);
-			will(returnValue(k2));
-			for (int i = 1; i < 17; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(k2),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-			// Remove the listener and stop the timer
-			oneOf(eventBus).removeListener(with(any(EventListener.class)));
-			oneOf(timer).cancel();
-		}});
-
-		assertTrue(keyManager.start());
-		keyManager.endpointAdded(ep, MAX_LATENCY, initialSecret);
-		// Recognise the tag for connection 0 in period 2
-		byte[] tag = new byte[TAG_LENGTH];
-		encodeTag(tag, key2, 0);
-		StreamContext ctx = tagRecogniser.recogniseTag(transportId, tag);
-		assertNotNull(ctx);
-		assertEquals(contactId, ctx.getContactId());
-		assertEquals(transportId, ctx.getTransportId());
-		assertArrayEquals(secret2, ctx.getSecret());
-		assertEquals(0, ctx.getStreamNumber());
-		assertEquals(true, ctx.getAlice());
-		keyManager.stop();
-
-		context.assertIsSatisfied();
-	}
-
-	@Test
-	public void testLoadSecretsAtEpoch() throws Exception {
-		Mockery context = new Mockery();
-		final CryptoComponent crypto = context.mock(CryptoComponent.class);
-		final DatabaseComponent db = context.mock(DatabaseComponent.class);
-		final EventBus eventBus = context.mock(EventBus.class);
-		final Clock clock = context.mock(Clock.class);
-		final Timer timer = context.mock(Timer.class);
-
-		final TagRecogniser tagRecogniser = new TagRecogniserImpl(crypto, db);
-		final KeyManagerImpl keyManager = new KeyManagerImpl(crypto, db,
-				eventBus, tagRecogniser, clock, timer);
-
-		// The DB contains the secrets for periods 0 - 2
-		Endpoint ep = new Endpoint(contactId, transportId, EPOCH, true);
-		final TemporarySecret s0 = new TemporarySecret(ep, 0, secret0);
-		final TemporarySecret s1 = new TemporarySecret(ep, 1, secret1);
-		final TemporarySecret s2 = new TemporarySecret(ep, 2, secret2);
-
-		context.checking(new Expectations() {{
-			// start()
-			oneOf(eventBus).addListener(with(any(EventListener.class)));
-			oneOf(db).getSecrets();
-			will(returnValue(Arrays.asList(s0, s1, s2)));
-			oneOf(db).getTransportLatencies();
-			will(returnValue(Collections.singletonMap(transportId,
-					MAX_LATENCY)));
-			// The current time is the epoch, the start of period 1
-			oneOf(clock).currentTimeMillis();
-			will(returnValue(EPOCH));
-			// The recogniser should derive the tags for period 0
-			oneOf(crypto).deriveTagKey(secret0, false);
-			will(returnValue(k0));
-			for (int i = 0; i < 16; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(k0),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-			// The recogniser should derive the tags for period 1
-			oneOf(crypto).deriveTagKey(secret1, false);
-			will(returnValue(k1));
-			for (int i = 0; i < 16; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(k1),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-			// The recogniser should derive the tags for period 2
-			oneOf(crypto).deriveTagKey(secret2, false);
-			will(returnValue(k2));
-			for (int i = 0; i < 16; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(k2),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-			// Start the timer
-			oneOf(timer).scheduleAtFixedRate(with(keyManager),
-					with(any(long.class)), with(any(long.class)));
-			// stop()
-			// The recogniser should remove the tags for period 0
-			oneOf(crypto).deriveTagKey(secret0, false);
-			will(returnValue(k0));
-			for (int i = 0; i < 16; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(k0),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-			// The recogniser should derive the tags for period 1
-			oneOf(crypto).deriveTagKey(secret1, false);
-			will(returnValue(k1));
-			for (int i = 0; i < 16; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(k1),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-			// The recogniser should derive the tags for period 2
-			oneOf(crypto).deriveTagKey(secret2, false);
-			will(returnValue(k2));
-			for (int i = 0; i < 16; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(k2),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-			// Remove the listener and stop the timer
-			oneOf(eventBus).removeListener(with(any(EventListener.class)));
-			oneOf(timer).cancel();
-		}});
-
-		assertTrue(keyManager.start());
-		keyManager.stop();
-
-		context.assertIsSatisfied();
-	}
-
-	@Test
-	public void testLoadSecretsAtStartOfPeriod2() throws Exception {
-		Mockery context = new Mockery();
-		final CryptoComponent crypto = context.mock(CryptoComponent.class);
-		final DatabaseComponent db = context.mock(DatabaseComponent.class);
-		final EventBus eventBus = context.mock(EventBus.class);
-		final Clock clock = context.mock(Clock.class);
-		final Timer timer = context.mock(Timer.class);
-
-		final TagRecogniser tagRecogniser = new TagRecogniserImpl(crypto, db);
-		final KeyManagerImpl keyManager = new KeyManagerImpl(crypto, db,
-				eventBus, tagRecogniser, clock, timer);
-
-		// The DB contains the secrets for periods 0 - 2
-		Endpoint ep = new Endpoint(contactId, transportId, EPOCH, true);
-		final TemporarySecret s0 = new TemporarySecret(ep, 0, secret0);
-		final TemporarySecret s1 = new TemporarySecret(ep, 1, secret1);
-		final TemporarySecret s2 = new TemporarySecret(ep, 2, secret2);
-		// The secret for period 3 should be derived and stored
-		final TemporarySecret s3 = new TemporarySecret(ep, 3, secret3);
-
-		context.checking(new Expectations() {{
-			// start()
-			oneOf(eventBus).addListener(with(any(EventListener.class)));
-			oneOf(db).getSecrets();
-			will(returnValue(Arrays.asList(s0, s1, s2)));
-			oneOf(db).getTransportLatencies();
-			will(returnValue(Collections.singletonMap(transportId,
-					MAX_LATENCY)));
-			// The current time is the start of period 2
-			oneOf(clock).currentTimeMillis();
-			will(returnValue(EPOCH + ROTATION_PERIOD));
-			// The secret for period 3 should be derived and stored
-			oneOf(crypto).deriveNextSecret(secret0, 1);
-			will(returnValue(secret1));
-			oneOf(crypto).deriveNextSecret(secret1, 2);
-			will(returnValue(secret2));
-			oneOf(crypto).deriveNextSecret(secret2, 3);
-			will(returnValue(secret3));
-			oneOf(db).addSecrets(Arrays.asList(s3));
-			// The recogniser should derive the tags for period 1
-			oneOf(crypto).deriveTagKey(secret1, false);
-			will(returnValue(k1));
-			for (int i = 0; i < 16; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(k1),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-			// The recogniser should derive the tags for period 2
-			oneOf(crypto).deriveTagKey(secret2, false);
-			will(returnValue(k2));
-			for (int i = 0; i < 16; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(k2),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-			// The recogniser should derive the tags for period 3
-			oneOf(crypto).deriveTagKey(secret3, false);
-			will(returnValue(k3));
-			for (int i = 0; i < 16; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(k3),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-			// Start the timer
-			oneOf(timer).scheduleAtFixedRate(with(keyManager),
-					with(any(long.class)), with(any(long.class)));
-			// stop()
-			// The recogniser should derive the tags for period 1
-			oneOf(crypto).deriveTagKey(secret1, false);
-			will(returnValue(k1));
-			for (int i = 0; i < 16; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(k1),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-			// The recogniser should derive the tags for period 2
-			oneOf(crypto).deriveTagKey(secret2, false);
-			will(returnValue(k2));
-			for (int i = 0; i < 16; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(k2),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-			// The recogniser should remove the tags for period 3
-			oneOf(crypto).deriveTagKey(secret3, false);
-			will(returnValue(k3));
-			for (int i = 0; i < 16; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(k3),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-			// Remove the listener and stop the timer
-			oneOf(eventBus).removeListener(with(any(EventListener.class)));
-			oneOf(timer).cancel();
-		}});
-
-		assertTrue(keyManager.start());
-		keyManager.stop();
-
-		context.assertIsSatisfied();
-	}
-
-	@Test
-	public void testLoadSecretsAtEndOfPeriod3() throws Exception {
-		Mockery context = new Mockery();
-		final CryptoComponent crypto = context.mock(CryptoComponent.class);
-		final DatabaseComponent db = context.mock(DatabaseComponent.class);
-		final EventBus eventBus = context.mock(EventBus.class);
-		final Clock clock = context.mock(Clock.class);
-		final Timer timer = context.mock(Timer.class);
-
-		final TagRecogniser tagRecogniser = new TagRecogniserImpl(crypto, db);
-		final KeyManagerImpl keyManager = new KeyManagerImpl(crypto, db,
-				eventBus, tagRecogniser, clock, timer);
-
-		// The DB contains the secrets for periods 0 - 2
-		Endpoint ep = new Endpoint(contactId, transportId, EPOCH, true);
-		final TemporarySecret s0 = new TemporarySecret(ep, 0, secret0);
-		final TemporarySecret s1 = new TemporarySecret(ep, 1, secret1);
-		final TemporarySecret s2 = new TemporarySecret(ep, 2, secret2);
-		// The secrets for periods 3 and 4 should be derived and stored
-		final TemporarySecret s3 = new TemporarySecret(ep, 3, secret3);
-		final TemporarySecret s4 = new TemporarySecret(ep, 4, secret4);
-
-		context.checking(new Expectations() {{
-			// start()
-			oneOf(eventBus).addListener(with(any(EventListener.class)));
-			oneOf(db).getSecrets();
-			will(returnValue(Arrays.asList(s0, s1, s2)));
-			oneOf(db).getTransportLatencies();
-			will(returnValue(Collections.singletonMap(transportId,
-					MAX_LATENCY)));
-			// The current time is the end of period 3
-			oneOf(clock).currentTimeMillis();
-			will(returnValue(EPOCH + 3 * ROTATION_PERIOD - 1));
-			// The secrets for periods 3 and 4 should be derived from secret 1
-			oneOf(crypto).deriveNextSecret(secret1, 2);
-			will(returnValue(secret2));
-			oneOf(crypto).deriveNextSecret(secret2, 3);
-			will(returnValue(secret3));
-			oneOf(crypto).deriveNextSecret(secret3, 4);
-			will(returnValue(secret4));
-			// The new secrets should be stored
-			oneOf(db).addSecrets(Arrays.asList(s3, s4));
-			// The recogniser should derive the tags for period 2
-			oneOf(crypto).deriveTagKey(secret2, false);
-			will(returnValue(k2));
-			for (int i = 0; i < 16; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(k2),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-			// The recogniser should derive the tags for period 3
-			oneOf(crypto).deriveTagKey(secret3, false);
-			will(returnValue(k3));
-			for (int i = 0; i < 16; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(k3),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-			// The recogniser should derive the tags for period 4
-			oneOf(crypto).deriveTagKey(secret4, false);
-			will(returnValue(k4));
-			for (int i = 0; i < 16; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(k4),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-			// Start the timer
-			oneOf(timer).scheduleAtFixedRate(with(keyManager),
-					with(any(long.class)), with(any(long.class)));
-			// stop()
-			// The recogniser should derive the tags for period 2
-			oneOf(crypto).deriveTagKey(secret2, false);
-			will(returnValue(k2));
-			for (int i = 0; i < 16; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(k2),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-			// The recogniser should remove the tags for period 3
-			oneOf(crypto).deriveTagKey(secret3, false);
-			will(returnValue(k3));
-			for (int i = 0; i < 16; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(k3),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-			// The recogniser should derive the tags for period 4
-			oneOf(crypto).deriveTagKey(secret4, false);
-			will(returnValue(k4));
-			for (int i = 0; i < 16; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(k4),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-			// Remove the listener and stop the timer
-			oneOf(eventBus).removeListener(with(any(EventListener.class)));
-			oneOf(timer).cancel();
-		}});
-
-		assertTrue(keyManager.start());
-		keyManager.stop();
-
-		context.assertIsSatisfied();
-	}
-
-	private void encodeTag(byte[] tag, byte[] rawKey, long streamNumber) {
-		// Encode a fake tag based on the key and stream number
-		System.arraycopy(rawKey, 0, tag, 0, tag.length);
-		ByteUtils.writeUint32(streamNumber, tag, 0);
-	}
-
-	private class EncodeTagAction implements Action {
-
-		public void describeTo(Description description) {
-			description.appendText("Encodes a tag");
-		}
-
-		public Object invoke(Invocation invocation) throws Throwable {
-			byte[] tag = (byte[]) invocation.getParameter(0);
-			SecretKey key = (SecretKey) invocation.getParameter(1);
-			long streamNumber = (Long) invocation.getParameter(2);
-			encodeTag(tag, key.getBytes(), streamNumber);
-			return null;
-		}
-	}
-}

briar-tests/src/org/briarproject/transport/ReorderingWindowTest.java

@@ -1,5 +1,10 @@
 package org.briarproject.transport;
 
+import org.briarproject.BriarTestCase;
+import org.briarproject.api.transport.TransportConstants;
+import org.briarproject.transport.ReorderingWindow.Change;
+import org.junit.Assert;
+import org.junit.Test;
 import org.briarproject.BriarTestCase;
 import org.junit.Test;
 
@@ -13,148 +18,102 @@ import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Random;
+
+import static org.briarproject.api.transport.TransportConstants.REORDERING_WINDOW_SIZE;
+import static org.junit.Assert.assertArrayEquals;
+
 public class ReorderingWindowTest extends BriarTestCase {
 
 	@Test
-	public void testWindowSliding() {
-		ReorderingWindow w = new ReorderingWindow();
-		for (int i = 0; i < 100; i++) {
-			assertFalse(w.isSeen(i));
-			w.setSeen(i);
-			assertTrue(w.isSeen(i));
-		}
-	}
-
-	@Test
-	public void testWindowJumping() {
-		ReorderingWindow w = new ReorderingWindow();
-		for (int i = 0; i < 100; i += 13) {
-			assertFalse(w.isSeen(i));
-			w.setSeen(i);
-			assertTrue(w.isSeen(i));
-		}
-	}
-
-	@Test
-	public void testWindowUpperLimit() {
-		ReorderingWindow w = new ReorderingWindow();
-		// Centre is 0, highest value in window is 15
-		w.setSeen(15);
-		// Centre is 16, highest value in window is 31
-		w.setSeen(31);
-		try {
-			// Centre is 32, highest value in window is 47
-			w.setSeen(48);
-			fail();
-		} catch (IllegalArgumentException expected) {}
-		// Centre is max - 1, highest value in window is max
+	public void testBitmapConversion() {
+		Random random = new Random();
 		byte[] bitmap = new byte[REORDERING_WINDOW_SIZE / 8];
-		w = new ReorderingWindow(MAX_32_BIT_UNSIGNED - 1, bitmap);
-		assertFalse(w.isSeen(MAX_32_BIT_UNSIGNED - 1));
-		assertFalse(w.isSeen(MAX_32_BIT_UNSIGNED));
-		// Values greater than max should never be allowed
-		try {
-			w.setSeen(MAX_32_BIT_UNSIGNED + 1);
-			fail();
-		} catch (IllegalArgumentException expected) {}
-		w.setSeen(MAX_32_BIT_UNSIGNED);
-		assertTrue(w.isSeen(MAX_32_BIT_UNSIGNED));
-		// Centre should have moved to max + 1
-		assertEquals(MAX_32_BIT_UNSIGNED + 1, w.getCentre());
-		// The bit corresponding to max should be set
-		byte[] expectedBitmap = new byte[REORDERING_WINDOW_SIZE / 8];
-		expectedBitmap[expectedBitmap.length / 2 - 1] = 1; // 00000001
-		assertArrayEquals(expectedBitmap, w.getBitmap());
-		// Values greater than max should never be allowed even if centre > max
-		try {
-			w.setSeen(MAX_32_BIT_UNSIGNED + 1);
-			fail();
-		} catch (IllegalArgumentException expected) {}
+		for (int i = 0; i < 1000; i++) {
+			random.nextBytes(bitmap);
+			ReorderingWindow window = new ReorderingWindow(0L, bitmap);
+			assertArrayEquals(bitmap, window.getBitmap());
+		}
 	}
 
 	@Test
-	public void testWindowLowerLimit() {
-		ReorderingWindow w = new ReorderingWindow();
-		// Centre is 0, negative values should never be allowed
-		try {
-			w.setSeen(-1);
-			fail();
-		} catch (IllegalArgumentException expected) {}
-		// Slide the window
-		w.setSeen(15);
-		// Centre is 16, lowest value in window is 0
-		w.setSeen(0);
-		// Slide the window
-		w.setSeen(16);
-		// Centre is 17, lowest value in window is 1
-		w.setSeen(1);
-		try {
-			w.setSeen(0);
-			fail();
-		} catch (IllegalArgumentException expected) {}
-		// Slide the window
-		w.setSeen(25);
-		// Centre is 26, lowest value in window is 10
-		w.setSeen(10);
-		try {
-			w.setSeen(9);
-			fail();
-		} catch (IllegalArgumentException expected) {}
-		// Centre should still be 26
-		assertEquals(26, w.getCentre());
-		// The bits corresponding to 10, 15, 16 and 25 should be set
-		byte[] expectedBitmap = new byte[REORDERING_WINDOW_SIZE / 8];
-		expectedBitmap[0] = (byte) 134; // 10000110
-		expectedBitmap[1] = 1; // 00000001
-		assertArrayEquals(expectedBitmap, w.getBitmap());
+	public void testWindowSlidesWhenFirstElementIsSeen() {
+		byte[] bitmap = new byte[REORDERING_WINDOW_SIZE / 8];
+		ReorderingWindow window = new ReorderingWindow(0L, bitmap);
+		// Set the first element seen
+		Change change = window.setSeen(0L);
+		// The window should slide by one element
+		assertEquals(1L, window.getBase());
+		assertEquals(Collections.singletonList((long) REORDERING_WINDOW_SIZE), change.getAdded());
+		assertEquals(Collections.singletonList(0L), change.getRemoved());
+		// All elements in the window should be unseen
+		assertArrayEquals(bitmap, window.getBitmap());
 	}
 
 	@Test
-	public void testCannotSetSeenTwice() {
-		ReorderingWindow w = new ReorderingWindow();
-		w.setSeen(15);
-		try {
-			w.setSeen(15);
-			fail();
-		} catch (IllegalArgumentException expected) {}
+	public void testWindowDoesNotSlideWhenElementBelowMidpointIsSeen() {
+		byte[] bitmap = new byte[REORDERING_WINDOW_SIZE / 8];
+		ReorderingWindow window = new ReorderingWindow(0L, bitmap);
+		// Set an element below the midpoint seen
+		Change change = window.setSeen(1L);
+		// The window should not slide
+		assertEquals(0L, window.getBase());
+		assertEquals(Collections.emptyList(), change.getAdded());
+		assertEquals(Collections.singletonList(1L), change.getRemoved());
+		// The second element in the window should be seen
+		bitmap[0] = 0x40; // 0100 0000
+		assertArrayEquals(bitmap, window.getBitmap());
 	}
 
 	@Test
-	public void testGetUnseenStreamNumbers() {
-		ReorderingWindow w = new ReorderingWindow();
-		// Centre is 0; window should cover 0 to 15, inclusive, with none seen
-		Collection<Long> unseen = w.getUnseen();
-		assertEquals(16, unseen.size());
-		for (int i = 0; i < 16; i++) {
-			assertTrue(unseen.contains(Long.valueOf(i)));
-			assertFalse(w.isSeen(i));
-		}
-		w.setSeen(3);
-		w.setSeen(4);
-		// Centre is 5; window should cover 0 to 20, inclusive, with two seen
-		unseen = w.getUnseen();
-		assertEquals(19, unseen.size());
-		for (int i = 0; i < 21; i++) {
-			if (i == 3 || i == 4) {
-				assertFalse(unseen.contains(Long.valueOf(i)));
-				assertTrue(w.isSeen(i));
-			} else {
-				assertTrue(unseen.contains(Long.valueOf(i)));
-				assertFalse(w.isSeen(i));
-			}
-		}
-		w.setSeen(19);
-		// Centre is 20; window should cover 4 to 35, inclusive, with two seen
-		unseen = w.getUnseen();
-		assertEquals(30, unseen.size());
-		for (int i = 4; i < 36; i++) {
-			if (i == 4 || i == 19) {
-				assertFalse(unseen.contains(Long.valueOf(i)));
-				assertTrue(w.isSeen(i));
-			} else {
-				assertTrue(unseen.contains(Long.valueOf(i)));
-				assertFalse(w.isSeen(i));
-			}
-		}
+	public void testWindowSlidesWhenElementAboveMidpointIsSeen() {
+		byte[] bitmap = new byte[REORDERING_WINDOW_SIZE / 8];
+		ReorderingWindow window = new ReorderingWindow(0, bitmap);
+		long aboveMidpoint = REORDERING_WINDOW_SIZE / 2;
+		// Set an element above the midpoint seen
+		Change change = window.setSeen(aboveMidpoint);
+		// The window should slide by one element
+		assertEquals(1L, window.getBase());
+		assertEquals(Collections.singletonList((long) REORDERING_WINDOW_SIZE), change.getAdded());
+		assertEquals(Arrays.asList(0L, aboveMidpoint), change.getRemoved());
+		// The highest element below the midpoint should be seen
+		bitmap[bitmap.length / 2 - 1] = (byte) 0x01; // 0000 0001
+		assertArrayEquals(bitmap, window.getBitmap());
+	}
+
+	@Test
+	public void testWindowSlidesUntilLowestElementIsUnseenWhenFirstElementIsSeen() {
+		byte[] bitmap = new byte[REORDERING_WINDOW_SIZE / 8];
+		ReorderingWindow window = new ReorderingWindow(0L, bitmap);
+		window.setSeen(1L);
+		// Set the first element seen
+		Change change = window.setSeen(0L);
+		// The window should slide by two elements
+		assertEquals(2L, window.getBase());
+		assertEquals(Arrays.asList((long) REORDERING_WINDOW_SIZE,
+				(long) (REORDERING_WINDOW_SIZE + 1)), change.getAdded());
+		assertEquals(Collections.singletonList(0L), change.getRemoved());
+		// All elements in the window should be unseen
+		assertArrayEquals(bitmap, window.getBitmap());
+	}
+
+	@Test
+	public void testWindowSlidesUntilLowestElementIsUnseenWhenElementAboveMidpointIsSeen() {
+		byte[] bitmap = new byte[REORDERING_WINDOW_SIZE / 8];
+		ReorderingWindow window = new ReorderingWindow(0L, bitmap);
+		window.setSeen(1L);
+		long aboveMidpoint = REORDERING_WINDOW_SIZE / 2;
+		// Set an element above the midpoint seen
+		Change change = window.setSeen(aboveMidpoint);
+		// The window should slide by two elements
+		assertEquals(2L, window.getBase());
+		assertEquals(Arrays.asList((long) REORDERING_WINDOW_SIZE,
+				(long) (REORDERING_WINDOW_SIZE + 1)), change.getAdded());
+		assertEquals(Arrays.asList(0L, aboveMidpoint), change.getRemoved());
+		// The second-highest element below the midpoint should be seen
+		bitmap[bitmap.length / 2 - 1] = (byte) 0x02; // 0000 0010
+		assertArrayEquals(bitmap, window.getBitmap());
 	}
 }

briar-tests/src/org/briarproject/transport/TransportKeyManagerTest.java

@@ -0,0 +1,14 @@
+package org.briarproject.transport;
+
+import org.briarproject.BriarTestCase;
+import org.junit.Test;
+
+import static org.junit.Assert.fail;
+
+public class TransportKeyManagerTest extends BriarTestCase {
+
+	@Test
+	public void testUnitTestsExist() {
+		fail(); // FIXME: Write tests
+	}
+}

briar-tests/src/org/briarproject/transport/TransportTagRecogniserTest.java

@@ -1,130 +0,0 @@
-package org.briarproject.transport;
-
-import org.briarproject.BriarTestCase;
-import org.briarproject.api.ContactId;
-import org.briarproject.api.TransportId;
-import org.briarproject.api.crypto.CryptoComponent;
-import org.briarproject.api.crypto.SecretKey;
-import org.briarproject.api.db.DatabaseComponent;
-import org.briarproject.api.transport.StreamContext;
-import org.briarproject.api.transport.TemporarySecret;
-import org.briarproject.util.ByteUtils;
-import org.hamcrest.Description;
-import org.jmock.Expectations;
-import org.jmock.Mockery;
-import org.jmock.api.Action;
-import org.jmock.api.Invocation;
-import org.junit.Test;
-
-import java.util.Random;
-
-import static org.briarproject.api.transport.TransportConstants.TAG_LENGTH;
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-
-public class TransportTagRecogniserTest extends BriarTestCase {
-
-	private final ContactId contactId = new ContactId(234);
-	private final TransportId transportId = new TransportId("id");
-	private final SecretKey tagKey = new SecretKey(new byte[32]);
-
-	@Test
-	public void testAddAndRemoveSecret() {
-		Mockery context = new Mockery();
-		final CryptoComponent crypto = context.mock(CryptoComponent.class);
-		final byte[] secret = new byte[32];
-		new Random().nextBytes(secret);
-		final boolean alice = false;
-		final DatabaseComponent db = context.mock(DatabaseComponent.class);
-		context.checking(new Expectations() {{
-			// Add secret
-			oneOf(crypto).deriveTagKey(secret, !alice);
-			will(returnValue(tagKey));
-			for (int i = 0; i < 16; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(tagKey),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-			// Remove secret
-			oneOf(crypto).deriveTagKey(secret, !alice);
-			will(returnValue(tagKey));
-			for (int i = 0; i < 16; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(tagKey),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-		}});
-		TemporarySecret s = new TemporarySecret(contactId, transportId, 123,
-				alice, 0, secret, 0, 0, new byte[4]);
-		TransportTagRecogniser recogniser =
-				new TransportTagRecogniser(crypto, db, transportId);
-		recogniser.addSecret(s);
-		recogniser.removeSecret(contactId, 0);
-		context.assertIsSatisfied();
-	}
-
-	@Test
-	public void testRecogniseTag() throws Exception {
-		Mockery context = new Mockery();
-		final CryptoComponent crypto = context.mock(CryptoComponent.class);
-		final byte[] secret = new byte[32];
-		new Random().nextBytes(secret);
-		final boolean alice = false;
-		final DatabaseComponent db = context.mock(DatabaseComponent.class);
-		context.checking(new Expectations() {{
-			// Add secret
-			oneOf(crypto).deriveTagKey(secret, !alice);
-			will(returnValue(tagKey));
-			for (int i = 0; i < 16; i++) {
-				oneOf(crypto).encodeTag(with(any(byte[].class)), with(tagKey),
-						with((long) i));
-				will(new EncodeTagAction());
-			}
-			// Recognise tag 0
-			oneOf(crypto).deriveTagKey(secret, !alice);
-			will(returnValue(tagKey));
-			// The window should slide to include tag 16
-			oneOf(crypto).encodeTag(with(any(byte[].class)), with(tagKey),
-					with(16L));
-			will(new EncodeTagAction());
-			// The updated window should be stored
-			oneOf(db).setReorderingWindow(contactId, transportId, 0, 1,
-					new byte[] {0, 1, 0, 0});
-			// Recognise tag again - no expectations
-		}});
-		TemporarySecret s = new TemporarySecret(contactId, transportId, 123,
-				alice, 0, secret, 0, 0, new byte[4]);
-		TransportTagRecogniser recogniser =
-				new TransportTagRecogniser(crypto, db, transportId);
-		recogniser.addSecret(s);
-		// Tag 0 should be expected
-		byte[] tag = new byte[TAG_LENGTH];
-		StreamContext ctx = recogniser.recogniseTag(tag);
-		assertNotNull(ctx);
-		assertEquals(contactId, ctx.getContactId());
-		assertEquals(transportId, ctx.getTransportId());
-		assertArrayEquals(secret, ctx.getSecret());
-		assertEquals(0, ctx.getStreamNumber());
-		assertEquals(alice, ctx.getAlice());
-		// Tag 0 should not be expected again
-		assertNull(recogniser.recogniseTag(tag));
-		context.assertIsSatisfied();
-	}
-
-	private static class EncodeTagAction implements Action {
-
-		public void describeTo(Description description) {
-			description.appendText("Encodes a tag");
-		}
-
-		public Object invoke(Invocation invocation) throws Throwable {
-			byte[] tag = (byte[]) invocation.getParameter(0);
-			long streamNumber = (Long) invocation.getParameter(2);
-			// Encode a fake tag based on the stream number
-			ByteUtils.writeUint32(streamNumber, tag, 0);
-			return null;
-		}
-	}
-}