Split transport identifiers into two: TransportId (globally unique)

and TransportIndex (locally unique).

This is the first step towards forward secrecy. Also removed the
Writable interface and unnecessary user-defined types, moved various
constants to ProtocolConstants and renamed some classes.

test/net/sf/briar/transport/ConnectionDecrypterImplTest.java

@@ -11,8 +11,8 @@ import javax.crypto.spec.IvParameterSpec;
 
 import junit.framework.TestCase;
 import net.sf.briar.TestUtils;
-import net.sf.briar.api.TransportId;
 import net.sf.briar.api.crypto.CryptoComponent;
+import net.sf.briar.api.protocol.TransportIndex;
 import net.sf.briar.crypto.CryptoModule;
 
 import org.apache.commons.io.output.ByteArrayOutputStream;
@@ -27,7 +27,7 @@ public class ConnectionDecrypterImplTest extends TestCase {
 
 	private final Cipher ivCipher, frameCipher;
 	private final SecretKey ivKey, frameKey;
-	private final TransportId transportId = new TransportId(123);
+	private final TransportIndex transportIndex = new TransportIndex(13);
 	private final long connection = 12345L;
 
 	public ConnectionDecrypterImplTest() {
@@ -52,7 +52,7 @@ public class ConnectionDecrypterImplTest extends TestCase {
 
 	private void testDecryption(boolean initiator) throws Exception {
 		// Calculate the plaintext and ciphertext for the IV
-		byte[] iv = IvEncoder.encodeIv(initiator, transportId, connection);
+		byte[] iv = IvEncoder.encodeIv(initiator, transportIndex, connection);
 		ivCipher.init(Cipher.ENCRYPT_MODE, ivKey);
 		byte[] encryptedIv  = ivCipher.doFinal(iv);
 		assertEquals(IV_LENGTH, encryptedIv.length);
@@ -85,7 +85,7 @@ public class ConnectionDecrypterImplTest extends TestCase {
 		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
 		// Use a ConnectionDecrypter to decrypt the ciphertext
 		ConnectionDecrypter d = new ConnectionDecrypterImpl(in, 
-				IvEncoder.encodeIv(initiator, transportId, connection),
+				IvEncoder.encodeIv(initiator, transportIndex, connection),
 				frameCipher, frameKey);
 		// First frame
 		byte[] decrypted = new byte[ciphertext.length];

test/net/sf/briar/transport/ConnectionEncrypterImplTest.java

@@ -10,8 +10,8 @@ import javax.crypto.SecretKey;
 import javax.crypto.spec.IvParameterSpec;
 
 import junit.framework.TestCase;
-import net.sf.briar.api.TransportId;
 import net.sf.briar.api.crypto.CryptoComponent;
+import net.sf.briar.api.protocol.TransportIndex;
 import net.sf.briar.crypto.CryptoModule;
 
 import org.junit.Test;
@@ -25,7 +25,7 @@ public class ConnectionEncrypterImplTest extends TestCase {
 
 	private final Cipher ivCipher, frameCipher;
 	private final SecretKey ivKey, frameKey;
-	private final TransportId transportId = new TransportId(123);
+	private final TransportIndex transportIndex = new TransportIndex(13);
 	private final long connection = 12345L;
 
 	public ConnectionEncrypterImplTest() {
@@ -50,7 +50,7 @@ public class ConnectionEncrypterImplTest extends TestCase {
 
 	private void testEncryption(boolean initiator) throws Exception {
 		// Calculate the expected ciphertext for the IV
-		byte[] iv = IvEncoder.encodeIv(initiator, transportId, connection);
+		byte[] iv = IvEncoder.encodeIv(initiator, transportIndex, connection);
 		ivCipher.init(Cipher.ENCRYPT_MODE, ivKey);
 		byte[] encryptedIv = ivCipher.doFinal(iv);
 		assertEquals(IV_LENGTH, encryptedIv.length);
@@ -82,7 +82,7 @@ public class ConnectionEncrypterImplTest extends TestCase {
 		byte[] expected = out.toByteArray();
 		// Use a ConnectionEncrypter to encrypt the plaintext
 		out.reset();
-		iv = IvEncoder.encodeIv(initiator, transportId, connection);
+		iv = IvEncoder.encodeIv(initiator, transportIndex, connection);
 		ConnectionEncrypter e = new ConnectionEncrypterImpl(out, Long.MAX_VALUE,
 				iv, ivCipher, frameCipher, ivKey, frameKey);
 		e.getOutputStream().write(plaintext);

test/net/sf/briar/transport/ConnectionRecogniserImplTest.java

@@ -9,10 +9,14 @@ import javax.crypto.Cipher;
 import javax.crypto.SecretKey;
 
 import junit.framework.TestCase;
+import net.sf.briar.TestUtils;
 import net.sf.briar.api.ContactId;
-import net.sf.briar.api.TransportId;
 import net.sf.briar.api.crypto.CryptoComponent;
 import net.sf.briar.api.db.DatabaseComponent;
+import net.sf.briar.api.protocol.Transport;
+import net.sf.briar.api.protocol.TransportId;
+import net.sf.briar.api.protocol.TransportIndex;
+import net.sf.briar.api.transport.ConnectionContext;
 import net.sf.briar.api.transport.ConnectionWindow;
 import net.sf.briar.crypto.CryptoModule;
 
@@ -29,6 +33,8 @@ public class ConnectionRecogniserImplTest extends TestCase {
 	private final ContactId contactId;
 	private final byte[] secret;
 	private final TransportId transportId;
+	private final TransportIndex localIndex, remoteIndex;
+	private final Collection<Transport> transports;
 	private final ConnectionWindow connectionWindow;
 
 	public ConnectionRecogniserImplTest() {
@@ -37,7 +43,12 @@ public class ConnectionRecogniserImplTest extends TestCase {
 		crypto = i.getInstance(CryptoComponent.class);
 		contactId = new ContactId(1);
 		secret = new byte[18];
-		transportId = new TransportId(123);
+		transportId = new TransportId(TestUtils.getRandomId());
+		localIndex = new TransportIndex(13);
+		remoteIndex = new TransportIndex(7);
+		Transport transport = new Transport(transportId, localIndex,
+				Collections.singletonMap("foo", "bar"));
+		transports = Collections.singletonList(transport);
 		connectionWindow = new ConnectionWindowImpl(0L, 0);
 	}
 
@@ -47,15 +58,20 @@ public class ConnectionRecogniserImplTest extends TestCase {
 		final DatabaseComponent db = context.mock(DatabaseComponent.class);
 		context.checking(new Expectations() {{
 			oneOf(db).addListener(with(any(ConnectionRecogniserImpl.class)));
+			// Initialise
+			oneOf(db).getLocalTransports();
+			will(returnValue(transports));
 			oneOf(db).getContacts();
 			will(returnValue(Collections.singleton(contactId)));
 			oneOf(db).getSharedSecret(contactId);
 			will(returnValue(secret));
-			oneOf(db).getConnectionWindow(contactId, transportId);
+			oneOf(db).getRemoteIndex(contactId, transportId);
+			will(returnValue(remoteIndex));
+			oneOf(db).getConnectionWindow(contactId, remoteIndex);
 			will(returnValue(connectionWindow));
 		}});
 		final ConnectionRecogniserImpl c =
-			new ConnectionRecogniserImpl(transportId, crypto, db);
+			new ConnectionRecogniserImpl(crypto, db);
 		assertNull(c.acceptConnection(new byte[IV_LENGTH]));
 		context.assertIsSatisfied();
 	}
@@ -66,26 +82,41 @@ public class ConnectionRecogniserImplTest extends TestCase {
 		SecretKey ivKey = crypto.deriveIncomingIvKey(secret);
 		Cipher ivCipher = crypto.getIvCipher();
 		ivCipher.init(Cipher.ENCRYPT_MODE, ivKey);
-		byte[] iv = IvEncoder.encodeIv(true, transportId, 3L);
+		byte[] iv = IvEncoder.encodeIv(true, remoteIndex, 3L);
 		byte[] encryptedIv = ivCipher.doFinal(iv);
 
 		Mockery context = new Mockery();
 		final DatabaseComponent db = context.mock(DatabaseComponent.class);
 		context.checking(new Expectations() {{
 			oneOf(db).addListener(with(any(ConnectionRecogniserImpl.class)));
+			// Initialise
+			oneOf(db).getLocalTransports();
+			will(returnValue(transports));
 			oneOf(db).getContacts();
 			will(returnValue(Collections.singleton(contactId)));
 			oneOf(db).getSharedSecret(contactId);
 			will(returnValue(secret));
-			oneOf(db).getConnectionWindow(contactId, transportId);
+			oneOf(db).getRemoteIndex(contactId, transportId);
+			will(returnValue(remoteIndex));
+			oneOf(db).getConnectionWindow(contactId, remoteIndex);
 			will(returnValue(connectionWindow));
-			oneOf(db).setConnectionWindow(contactId, transportId,
+			// Update the window
+			oneOf(db).getConnectionWindow(contactId, remoteIndex);
+			will(returnValue(connectionWindow));
+			oneOf(db).setConnectionWindow(contactId, remoteIndex,
 					connectionWindow);
+			oneOf(db).getSharedSecret(contactId);
+			will(returnValue(secret));
 		}});
 		final ConnectionRecogniserImpl c =
-			new ConnectionRecogniserImpl(transportId, crypto, db);
+			new ConnectionRecogniserImpl(crypto, db);
 		// First time - the IV should be expected
-		assertEquals(contactId, c.acceptConnection(encryptedIv));
+		ConnectionContext ctx = c.acceptConnection(encryptedIv);
+		assertNotNull(ctx);
+		assertEquals(contactId, ctx.getContactId());
+		assertEquals(transportId, ctx.getTransportId());
+		assertEquals(remoteIndex, ctx.getTransportIndex());
+		assertEquals(3L, ctx.getConnectionNumber());
 		// Second time - the IV should no longer be expected
 		assertNull(c.acceptConnection(encryptedIv));
 		// The window should have advanced

test/net/sf/briar/transport/ConnectionWriterTest.java

@@ -7,13 +7,16 @@ import java.io.ByteArrayOutputStream;
 
 import junit.framework.TestCase;
 import net.sf.briar.TestDatabaseModule;
-import net.sf.briar.api.TransportId;
+import net.sf.briar.api.protocol.TransportIndex;
 import net.sf.briar.api.transport.ConnectionWriter;
 import net.sf.briar.api.transport.ConnectionWriterFactory;
 import net.sf.briar.crypto.CryptoModule;
 import net.sf.briar.db.DatabaseModule;
 import net.sf.briar.protocol.ProtocolModule;
+import net.sf.briar.protocol.writers.ProtocolWritersModule;
 import net.sf.briar.serial.SerialModule;
+import net.sf.briar.transport.batch.TransportBatchModule;
+import net.sf.briar.transport.stream.TransportStreamModule;
 
 import org.junit.Test;
 
@@ -24,14 +27,16 @@ public class ConnectionWriterTest extends TestCase {
 
 	private final ConnectionWriterFactory connectionWriterFactory;
 	private final byte[] secret = new byte[100];
-	private final TransportId transportId = new TransportId(123);
+	private final TransportIndex transportIndex = new TransportIndex(13);
 	private final long connection = 12345L;
 
 	public ConnectionWriterTest() throws Exception {
 		super();
 		Injector i = Guice.createInjector(new CryptoModule(),
-				new DatabaseModule(), new ProtocolModule(), new SerialModule(),
-				new TestDatabaseModule(), new TransportModule());
+				new DatabaseModule(), new ProtocolModule(),
+				new ProtocolWritersModule(), new SerialModule(),
+				new TestDatabaseModule(), new TransportBatchModule(),
+				new TransportModule(), new TransportStreamModule());
 		connectionWriterFactory = i.getInstance(ConnectionWriterFactory.class);
 	}
 
@@ -40,7 +45,7 @@ public class ConnectionWriterTest extends TestCase {
 		ByteArrayOutputStream out =
 			new ByteArrayOutputStream(MIN_CONNECTION_LENGTH);
 		ConnectionWriter w = connectionWriterFactory.createConnectionWriter(out,
-				MIN_CONNECTION_LENGTH, transportId, connection, secret);
+				MIN_CONNECTION_LENGTH, transportIndex, connection, secret);
 		// Check that the connection writer thinks there's room for a packet
 		long capacity = w.getRemainingCapacity();
 		assertTrue(capacity >= MAX_PACKET_LENGTH);

test/net/sf/briar/transport/FrameReadWriteTest.java

@@ -14,8 +14,8 @@ import javax.crypto.Mac;
 import javax.crypto.SecretKey;
 
 import junit.framework.TestCase;
-import net.sf.briar.api.TransportId;
 import net.sf.briar.api.crypto.CryptoComponent;
+import net.sf.briar.api.protocol.TransportIndex;
 import net.sf.briar.api.transport.ConnectionReader;
 import net.sf.briar.api.transport.ConnectionWriter;
 import net.sf.briar.crypto.CryptoModule;
@@ -33,7 +33,7 @@ public class FrameReadWriteTest extends TestCase {
 	private final Mac mac;
 	private final Random random;
 	private final byte[] secret = new byte[100];
-	private final TransportId transportId = new TransportId(123);
+	private final TransportIndex transportIndex = new TransportIndex(13);
 	private final long connection = 12345L;
 
 	public FrameReadWriteTest() {
@@ -62,7 +62,7 @@ public class FrameReadWriteTest extends TestCase {
 
 	private void testWriteAndRead(boolean initiator) throws Exception {
 		// Create and encrypt the IV
-		byte[] iv = IvEncoder.encodeIv(initiator, transportId, connection);
+		byte[] iv = IvEncoder.encodeIv(initiator, transportIndex, connection);
 		ivCipher.init(Cipher.ENCRYPT_MODE, ivKey);
 		byte[] encryptedIv = ivCipher.doFinal(iv);
 		assertEquals(IV_LENGTH, encryptedIv.length);
@@ -90,7 +90,7 @@ public class FrameReadWriteTest extends TestCase {
 		// Decrypt the IV
 		ivCipher.init(Cipher.DECRYPT_MODE, ivKey);
 		byte[] recoveredIv = ivCipher.doFinal(recoveredEncryptedIv);
-		iv = IvEncoder.encodeIv(initiator, transportId, connection);
+		iv = IvEncoder.encodeIv(initiator, transportIndex, connection);
 		assertArrayEquals(iv, recoveredIv);
 		// Read the frames back
 		ConnectionDecrypter decrypter = new ConnectionDecrypterImpl(in, iv,

test/net/sf/briar/transport/batch/BatchConnectionReadWriteTest.java

@@ -7,28 +7,30 @@ import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.InputStream;
 import java.io.OutputStream;
+import java.util.Collection;
 import java.util.Collections;
-import java.util.Map;
 
 import junit.framework.TestCase;
 import net.sf.briar.TestDatabaseModule;
 import net.sf.briar.TestUtils;
 import net.sf.briar.api.ContactId;
-import net.sf.briar.api.TransportId;
-import net.sf.briar.api.TransportProperties;
 import net.sf.briar.api.db.DatabaseComponent;
 import net.sf.briar.api.db.event.DatabaseEvent;
 import net.sf.briar.api.db.event.DatabaseListener;
 import net.sf.briar.api.db.event.MessagesAddedEvent;
 import net.sf.briar.api.protocol.Message;
-import net.sf.briar.api.protocol.MessageEncoder;
 import net.sf.briar.api.protocol.ProtocolReaderFactory;
+import net.sf.briar.api.protocol.Transport;
+import net.sf.briar.api.protocol.TransportId;
+import net.sf.briar.api.protocol.TransportIndex;
+import net.sf.briar.api.protocol.TransportUpdate;
+import net.sf.briar.api.protocol.writers.MessageEncoder;
 import net.sf.briar.api.protocol.writers.ProtocolWriterFactory;
 import net.sf.briar.api.transport.BatchTransportReader;
 import net.sf.briar.api.transport.BatchTransportWriter;
+import net.sf.briar.api.transport.ConnectionContext;
 import net.sf.briar.api.transport.ConnectionReaderFactory;
 import net.sf.briar.api.transport.ConnectionRecogniser;
-import net.sf.briar.api.transport.ConnectionRecogniserFactory;
 import net.sf.briar.api.transport.ConnectionWriterFactory;
 import net.sf.briar.crypto.CryptoModule;
 import net.sf.briar.db.DatabaseModule;
@@ -36,6 +38,7 @@ import net.sf.briar.protocol.ProtocolModule;
 import net.sf.briar.protocol.writers.ProtocolWritersModule;
 import net.sf.briar.serial.SerialModule;
 import net.sf.briar.transport.TransportModule;
+import net.sf.briar.transport.stream.TransportStreamModule;
 
 import org.junit.After;
 import org.junit.Before;
@@ -49,15 +52,16 @@ public class BatchConnectionReadWriteTest extends TestCase {
 	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 = new TransportId(123);
-	private final Map<TransportId, TransportProperties> transports =
-		Collections.emptyMap();
+	private final TransportId transportId;
+	private final TransportIndex transportIndex;
 	private final byte[] aliceSecret, bobSecret;
 
 	private Injector alice, bob;
 
 	public BatchConnectionReadWriteTest() throws Exception {
 		super();
+		transportId = new TransportId(TestUtils.getRandomId());
+		transportIndex = new TransportIndex(1);
 		// Create matching secrets for Alice and Bob
 		aliceSecret = new byte[100];
 		aliceSecret[16] = (byte) 1;
@@ -71,12 +75,14 @@ public class BatchConnectionReadWriteTest extends TestCase {
 		alice = Guice.createInjector(new CryptoModule(), new DatabaseModule(),
 				new ProtocolModule(), new ProtocolWritersModule(),
 				new SerialModule(), new TestDatabaseModule(aliceDir),
-				new TransportModule());
+				new TransportBatchModule(), new TransportModule(),
+				new TransportStreamModule());
 		// Create Bob's injector
 		bob = Guice.createInjector(new CryptoModule(), new DatabaseModule(),
 				new ProtocolModule(), new ProtocolWritersModule(),
 				new SerialModule(), new TestDatabaseModule(bobDir),
-				new TransportModule());
+				new TransportBatchModule(), new TransportModule(),
+				new TransportStreamModule());
 	}
 
 	@Test
@@ -96,7 +102,7 @@ public class BatchConnectionReadWriteTest extends TestCase {
 		DatabaseComponent db = alice.getInstance(DatabaseComponent.class);
 		db.open(false);
 		// Add Bob as a contact and send him a message
-		ContactId contactId = db.addContact(transports, aliceSecret);
+		ContactId contactId = db.addContact(aliceSecret);
 		String subject = "Hello";
 		byte[] messageBody = "Hi Bob!".getBytes("UTF-8");
 		MessageEncoder encoder = alice.getInstance(MessageEncoder.class);
@@ -110,7 +116,8 @@ public class BatchConnectionReadWriteTest extends TestCase {
 			alice.getInstance(ProtocolWriterFactory.class);
 		BatchTransportWriter writer = new TestBatchTransportWriter(out);
 		OutgoingBatchConnection batchOut = new OutgoingBatchConnection(
-				connFactory, db, protoFactory, transportId, contactId, writer);
+				connFactory, db, protoFactory, transportIndex, contactId,
+				writer);
 		// Write whatever needs to be written
 		batchOut.write();
 		// Close Alice's database
@@ -127,18 +134,33 @@ public class BatchConnectionReadWriteTest extends TestCase {
 		MessageListener listener = new MessageListener();
 		db.addListener(listener);
 		// Add Alice as a contact
-		ContactId contactId = db.addContact(transports, bobSecret);
+		ContactId contactId = db.addContact(bobSecret);
+		// Add the transport
+		assertEquals(transportIndex, db.addTransport(transportId));
+		// Fake a transport update from Alice
+		TransportUpdate transportUpdate = new TransportUpdate() {
+
+			public Collection<Transport> getTransports() {
+				Transport t = new Transport(transportId, transportIndex);
+				return Collections.singletonList(t);
+			}
+
+			public long getTimestamp() {
+				return System.currentTimeMillis();
+			}
+		};
+		db.receiveTransportUpdate(contactId, transportUpdate);
 		// Create a connection recogniser and recognise the connection
 		ByteArrayInputStream in = new ByteArrayInputStream(b);
-		ConnectionRecogniserFactory recFactory =
-			bob.getInstance(ConnectionRecogniserFactory.class);
-		ConnectionRecogniser rec =
-			recFactory.createConnectionRecogniser(transportId);
+		ConnectionRecogniser rec = bob.getInstance(ConnectionRecogniser.class);
 		byte[] encryptedIv = new byte[IV_LENGTH];
 		int read = in.read(encryptedIv);
 		assertEquals(encryptedIv.length, read);
-		ContactId accepted = rec.acceptConnection(encryptedIv);
-		assertEquals(contactId, accepted);
+		ConnectionContext ctx = rec.acceptConnection(encryptedIv);
+		assertNotNull(ctx);
+		assertEquals(contactId, ctx.getContactId());
+		assertEquals(transportId, ctx.getTransportId());
+		assertEquals(transportIndex, ctx.getTransportIndex());
 		// Create an incoming batch connection
 		ConnectionReaderFactory connFactory =
 			bob.getInstance(ConnectionReaderFactory.class);
@@ -146,8 +168,8 @@ public class BatchConnectionReadWriteTest extends TestCase {
 			bob.getInstance(ProtocolReaderFactory.class);
 		BatchTransportReader reader = new TestBatchTransportReader(in);
 		IncomingBatchConnection batchIn = new IncomingBatchConnection(
-				connFactory, db, protoFactory, transportId, contactId, reader,
-				encryptedIv);
+				connFactory, db, protoFactory, transportIndex, contactId,
+				reader, encryptedIv);
 		// No messages should have been added yet
 		assertFalse(listener.messagesAdded);
 		// Read whatever needs to be read