Create DB tables for static keys.

2026-02-14 19:59:05 +01:00 · 2019-04-09 14:48:45 +01:00
parent ff2f710495
commit b568405f59
17 changed files with 324 additions and 196 deletions
--- a/bramble-core/src/main/java/org/briarproject/bramble/crypto/TransportCryptoImpl.java
+++ b/bramble-core/src/main/java/org/briarproject/bramble/crypto/TransportCryptoImpl.java
@@ -36,45 +36,44 @@ class TransportCryptoImpl implements TransportCrypto {

 	@Override
 	public TransportKeys deriveTransportKeys(TransportId t,
-			SecretKey master, long rotationPeriod, boolean alice,
-			boolean active) {
+			SecretKey master, long timePeriod, boolean alice, boolean active) {
 		// Keys for the previous period are derived from the master secret
 		SecretKey inTagPrev = deriveTagKey(master, t, !alice);
 		SecretKey inHeaderPrev = deriveHeaderKey(master, t, !alice);
 		SecretKey outTagPrev = deriveTagKey(master, t, alice);
 		SecretKey outHeaderPrev = deriveHeaderKey(master, t, alice);
 		// Derive the keys for the current and next periods
-		SecretKey inTagCurr = rotateKey(inTagPrev, rotationPeriod);
-		SecretKey inHeaderCurr = rotateKey(inHeaderPrev, rotationPeriod);
-		SecretKey inTagNext = rotateKey(inTagCurr, rotationPeriod + 1);
-		SecretKey inHeaderNext = rotateKey(inHeaderCurr, rotationPeriod + 1);
-		SecretKey outTagCurr = rotateKey(outTagPrev, rotationPeriod);
-		SecretKey outHeaderCurr = rotateKey(outHeaderPrev, rotationPeriod);
+		SecretKey inTagCurr = rotateKey(inTagPrev, timePeriod);
+		SecretKey inHeaderCurr = rotateKey(inHeaderPrev, timePeriod);
+		SecretKey inTagNext = rotateKey(inTagCurr, timePeriod + 1);
+		SecretKey inHeaderNext = rotateKey(inHeaderCurr, timePeriod + 1);
+		SecretKey outTagCurr = rotateKey(outTagPrev, timePeriod);
+		SecretKey outHeaderCurr = rotateKey(outHeaderPrev, timePeriod);
 		// Initialise the reordering windows and stream counters
 		IncomingKeys inPrev = new IncomingKeys(inTagPrev, inHeaderPrev,
-				rotationPeriod - 1);
+				timePeriod - 1);
 		IncomingKeys inCurr = new IncomingKeys(inTagCurr, inHeaderCurr,
-				rotationPeriod);
+				timePeriod);
 		IncomingKeys inNext = new IncomingKeys(inTagNext, inHeaderNext,
-				rotationPeriod + 1);
+				timePeriod + 1);
 		OutgoingKeys outCurr = new OutgoingKeys(outTagCurr, outHeaderCurr,
-				rotationPeriod, active);
+				timePeriod, active);
 		// Collect and return the keys
 		return new TransportKeys(t, inPrev, inCurr, inNext, outCurr);
 	}

 	@Override
 	public TransportKeys rotateTransportKeys(TransportKeys k,
-			long rotationPeriod) {
-		if (k.getRotationPeriod() >= rotationPeriod) return k;
+			long timePeriod) {
+		if (k.getTimePeriod() >= timePeriod) return k;
 		IncomingKeys inPrev = k.getPreviousIncomingKeys();
 		IncomingKeys inCurr = k.getCurrentIncomingKeys();
 		IncomingKeys inNext = k.getNextIncomingKeys();
 		OutgoingKeys outCurr = k.getCurrentOutgoingKeys();
-		long startPeriod = outCurr.getRotationPeriod();
+		long startPeriod = outCurr.getTimePeriod();
 		boolean active = outCurr.isActive();
 		// Rotate the keys
-		for (long p = startPeriod + 1; p <= rotationPeriod; p++) {
+		for (long p = startPeriod + 1; p <= timePeriod; p++) {
 			inPrev = inCurr;
 			inCurr = inNext;
 			SecretKey inNextTag = rotateKey(inNext.getTagKey(), p + 1);
@@ -89,9 +88,9 @@ class TransportCryptoImpl implements TransportCrypto {
 				outCurr);
 	}

-	private SecretKey rotateKey(SecretKey k, long rotationPeriod) {
+	private SecretKey rotateKey(SecretKey k, long timePeriod) {
 		byte[] period = new byte[INT_64_BYTES];
-		ByteUtils.writeUint64(rotationPeriod, period, 0);
+		ByteUtils.writeUint64(timePeriod, period, 0);
 		return crypto.deriveKey(ROTATE_LABEL, k, period);
 	}

--- a/bramble-core/src/main/java/org/briarproject/bramble/db/Database.java
+++ b/bramble-core/src/main/java/org/briarproject/bramble/db/Database.java
@@ -635,10 +635,10 @@ interface Database<T> {

 	/**
 	 * Sets the reordering window for the given key set and transport in the
-	 * given rotation period.
+	 * given time period.
 	 */
 	void setReorderingWindow(T txn, KeySetId k, TransportId t,
-			long rotationPeriod, long base, byte[] bitmap) throws DbException;
+			long timePeriod, long base, byte[] bitmap) throws DbException;

 	/**
 	 * Marks the given transport keys as usable for outgoing streams.
--- a/bramble-core/src/main/java/org/briarproject/bramble/db/DatabaseComponentImpl.java
+++ b/bramble-core/src/main/java/org/briarproject/bramble/db/DatabaseComponentImpl.java
@@ -956,13 +956,13 @@ class DatabaseComponentImpl<T> implements DatabaseComponent {

 	@Override
 	public void setReorderingWindow(Transaction transaction, KeySetId k,
-			TransportId t, long rotationPeriod, long base, byte[] bitmap)
+			TransportId t, long timePeriod, long base, byte[] bitmap)
 			throws DbException {
 		if (transaction.isReadOnly()) throw new IllegalArgumentException();
 		T txn = unbox(transaction);
 		if (!db.containsTransport(txn, t))
 			throw new NoSuchTransportException();
-		db.setReorderingWindow(txn, k, t, rotationPeriod, base, bitmap);
+		db.setReorderingWindow(txn, k, t, timePeriod, base, bitmap);
 	}

 	@Override
--- a/bramble-core/src/main/java/org/briarproject/bramble/db/JdbcDatabase.java
+++ b/bramble-core/src/main/java/org/briarproject/bramble/db/JdbcDatabase.java
@@ -85,9 +85,9 @@ import static org.briarproject.bramble.util.LogUtils.now;
 abstract class JdbcDatabase implements Database<Connection> {

 	// Package access for testing
-	static final int CODE_SCHEMA_VERSION = 41;
+	static final int CODE_SCHEMA_VERSION = 42;

-	// Rotation period offsets for incoming transport keys
+	// Time period offsets for incoming transport keys
 	private static final int OFFSET_PREV = -1;
 	private static final int OFFSET_CURR = 0;
 	private static final int OFFSET_NEXT = 1;
@@ -248,7 +248,7 @@ abstract class JdbcDatabase implements Database<Connection> {
 			"CREATE TABLE outgoingKeys"
 					+ " (transportId _STRING NOT NULL,"
 					+ " keySetId _COUNTER,"
-					+ " rotationPeriod BIGINT NOT NULL,"
+					+ " timePeriod BIGINT NOT NULL,"
 					+ " contactId INT NOT NULL,"
 					+ " tagKey _SECRET NOT NULL,"
 					+ " headerKey _SECRET NOT NULL,"
@@ -267,8 +267,7 @@ abstract class JdbcDatabase implements Database<Connection> {
 			"CREATE TABLE incomingKeys"
 					+ " (transportId _STRING NOT NULL,"
 					+ " keySetId INT NOT NULL,"
-					+ " rotationPeriod BIGINT NOT NULL,"
-					+ " contactId INT NOT NULL,"
+					+ " timePeriod BIGINT NOT NULL,"
 					+ " tagKey _SECRET NOT NULL,"
 					+ " headerKey _SECRET NOT NULL,"
 					+ " base BIGINT NOT NULL,"
@@ -280,9 +279,49 @@ abstract class JdbcDatabase implements Database<Connection> {
 					+ " ON DELETE CASCADE,"
 					+ " FOREIGN KEY (keySetId)"
 					+ " REFERENCES outgoingKeys (keySetId)"
+					+ " ON DELETE CASCADE)";
+
+	private static final String CREATE_PENDING_CONTACTS =
+			"CREATE TABLE pendingContacts"
+			+ " (pendingContactId _HASH NOT NULL,"
+			+ " PRIMARY KEY (pendingContactId))";
+
+	private static final String CREATE_OUTGOING_STATIC_KEYS =
+			"CREATE TABLE outgoingStaticKeys"
+					+ " (transportId _STRING NOT NULL,"
+					+ " staticKeySetId _COUNTER,"
+					+ " rootKey _SECRET NOT NULL,"
+					+ " timePeriod BIGINT NOT NULL,"
+					+ " stream BIGINT NOT NULL,"
+					+ " contactId INT," // Null if contact is pending
+					+ " pendingContactId _HASH," // Null if not pending
+					+ " PRIMARY KEY (transportId, staticKeySetId),"
+					+ " FOREIGN KEY (transportId)"
+					+ " REFERENCES transports (transportId)"
 					+ " ON DELETE CASCADE,"
+					+ " UNIQUE (staticKeySetId),"
 					+ " FOREIGN KEY (contactId)"
 					+ " REFERENCES contacts (contactId)"
+					+ " ON DELETE CASCADE,"
+					+ " FOREIGN KEY (pendingContactId)"
+					+ " REFERENCES pendingContacts (pendingContactId)"
+					+ " ON DELETE CASCADE)";
+
+	private static final String CREATE_INCOMING_STATIC_KEYS =
+			"CREATE TABLE incomingStaticKeys"
+					+ " (transportId _STRING NOT NULL,"
+					+ " staticKeySetId INT NOT NULL,"
+					+ " timePeriod BIGINT NOT NULL,"
+					+ " base BIGINT NOT NULL,"
+					+ " bitmap _BINARY NOT NULL,"
+					+ " periodOffset INT NOT NULL,"
+					+ " PRIMARY KEY (transportId, staticKeySetId,"
+					+ " periodOffset),"
+					+ " FOREIGN KEY (transportId)"
+					+ " REFERENCES transports (transportId)"
+					+ " ON DELETE CASCADE,"
+					+ " FOREIGN KEY (staticKeySetId)"
+					+ " REFERENCES outgoingStaticKeys (staticKeySetId)"
 					+ " ON DELETE CASCADE)";

 	private static final String INDEX_CONTACTS_BY_AUTHOR_ID =
@@ -428,7 +467,8 @@ abstract class JdbcDatabase implements Database<Connection> {
 		return Arrays.asList(
 				new Migration38_39(),
 				new Migration39_40(),
-				new Migration40_41(dbTypes)
+				new Migration40_41(dbTypes),
+				new Migration41_42(dbTypes)
 		);
 	}

@@ -478,6 +518,9 @@ abstract class JdbcDatabase implements Database<Connection> {
 			s.executeUpdate(dbTypes.replaceTypes(CREATE_TRANSPORTS));
 			s.executeUpdate(dbTypes.replaceTypes(CREATE_OUTGOING_KEYS));
 			s.executeUpdate(dbTypes.replaceTypes(CREATE_INCOMING_KEYS));
+			s.executeUpdate(dbTypes.replaceTypes(CREATE_PENDING_CONTACTS));
+			s.executeUpdate(dbTypes.replaceTypes(CREATE_OUTGOING_STATIC_KEYS));
+			s.executeUpdate(dbTypes.replaceTypes(CREATE_INCOMING_STATIC_KEYS));
 			s.close();
 		} catch (SQLException e) {
 			tryToClose(s, LOG, WARNING);
@@ -922,13 +965,13 @@ abstract class JdbcDatabase implements Database<Connection> {
 		try {
 			// Store the outgoing keys
 			String sql = "INSERT INTO outgoingKeys (contactId, transportId,"
-					+ " rotationPeriod, tagKey, headerKey, stream, active)"
+					+ " timePeriod, tagKey, headerKey, stream, active)"
 					+ " VALUES (?, ?, ?, ?, ?, ?, ?)";
 			ps = txn.prepareStatement(sql);
 			ps.setInt(1, c.getInt());
 			ps.setString(2, k.getTransportId().getString());
 			OutgoingKeys outCurr = k.getCurrentOutgoingKeys();
-			ps.setLong(3, outCurr.getRotationPeriod());
+			ps.setLong(3, outCurr.getTimePeriod());
 			ps.setBytes(4, outCurr.getTagKey().getBytes());
 			ps.setBytes(5, outCurr.getHeaderKey().getBytes());
 			ps.setLong(6, outCurr.getStreamCounter());
@@ -947,40 +990,39 @@ abstract class JdbcDatabase implements Database<Connection> {
 			rs.close();
 			ps.close();
 			// Store the incoming keys
-			sql = "INSERT INTO incomingKeys (keySetId, contactId, transportId,"
-					+ " rotationPeriod, tagKey, headerKey, base, bitmap,"
+			sql = "INSERT INTO incomingKeys (keySetId, transportId,"
+					+ " timePeriod, tagKey, headerKey, base, bitmap,"
 					+ " periodOffset)"
-					+ " VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)";
+					+ " VALUES (?, ?, ?, ?, ?, ?, ?, ?)";
 			ps = txn.prepareStatement(sql);
 			ps.setInt(1, keySetId.getInt());
-			ps.setInt(2, c.getInt());
-			ps.setString(3, k.getTransportId().getString());
-			// Previous rotation period
+			ps.setString(2, k.getTransportId().getString());
+			// Previous time period
 			IncomingKeys inPrev = k.getPreviousIncomingKeys();
-			ps.setLong(4, inPrev.getRotationPeriod());
-			ps.setBytes(5, inPrev.getTagKey().getBytes());
-			ps.setBytes(6, inPrev.getHeaderKey().getBytes());
-			ps.setLong(7, inPrev.getWindowBase());
-			ps.setBytes(8, inPrev.getWindowBitmap());
-			ps.setInt(9, OFFSET_PREV);
+			ps.setLong(3, inPrev.getTimePeriod());
+			ps.setBytes(4, inPrev.getTagKey().getBytes());
+			ps.setBytes(5, inPrev.getHeaderKey().getBytes());
+			ps.setLong(6, inPrev.getWindowBase());
+			ps.setBytes(7, inPrev.getWindowBitmap());
+			ps.setInt(8, OFFSET_PREV);
 			ps.addBatch();
-			// Current rotation period
+			// Current time period
 			IncomingKeys inCurr = k.getCurrentIncomingKeys();
-			ps.setLong(4, inCurr.getRotationPeriod());
-			ps.setBytes(5, inCurr.getTagKey().getBytes());
-			ps.setBytes(6, inCurr.getHeaderKey().getBytes());
-			ps.setLong(7, inCurr.getWindowBase());
-			ps.setBytes(8, inCurr.getWindowBitmap());
-			ps.setInt(9, OFFSET_CURR);
+			ps.setLong(3, inCurr.getTimePeriod());
+			ps.setBytes(4, inCurr.getTagKey().getBytes());
+			ps.setBytes(5, inCurr.getHeaderKey().getBytes());
+			ps.setLong(6, inCurr.getWindowBase());
+			ps.setBytes(7, inCurr.getWindowBitmap());
+			ps.setInt(8, OFFSET_CURR);
 			ps.addBatch();
-			// Next rotation period
+			// Next time period
 			IncomingKeys inNext = k.getNextIncomingKeys();
-			ps.setLong(4, inNext.getRotationPeriod());
-			ps.setBytes(5, inNext.getTagKey().getBytes());
-			ps.setBytes(6, inNext.getHeaderKey().getBytes());
-			ps.setLong(7, inNext.getWindowBase());
-			ps.setBytes(8, inNext.getWindowBitmap());
-			ps.setInt(9, OFFSET_NEXT);
+			ps.setLong(3, inNext.getTimePeriod());
+			ps.setBytes(4, inNext.getTagKey().getBytes());
+			ps.setBytes(5, inNext.getHeaderKey().getBytes());
+			ps.setLong(6, inNext.getWindowBase());
+			ps.setBytes(7, inNext.getWindowBitmap());
+			ps.setInt(8, OFFSET_NEXT);
 			ps.addBatch();
 			int[] batchAffected = ps.executeBatch();
 			if (batchAffected.length != 3) throw new DbStateException();
@@ -2155,8 +2197,7 @@ abstract class JdbcDatabase implements Database<Connection> {
 		ResultSet rs = null;
 		try {
 			// Retrieve the incoming keys
-			String sql = "SELECT rotationPeriod, tagKey, headerKey,"
-					+ " base, bitmap"
+			String sql = "SELECT timePeriod, tagKey, headerKey, base, bitmap"
 					+ " FROM incomingKeys"
 					+ " WHERE transportId = ?"
 					+ " ORDER BY keySetId, periodOffset";
@@ -2165,18 +2206,18 @@ abstract class JdbcDatabase implements Database<Connection> {
 			rs = ps.executeQuery();
 			List<IncomingKeys> inKeys = new ArrayList<>();
 			while (rs.next()) {
-				long rotationPeriod = rs.getLong(1);
+				long timePeriod = rs.getLong(1);
 				SecretKey tagKey = new SecretKey(rs.getBytes(2));
 				SecretKey headerKey = new SecretKey(rs.getBytes(3));
 				long windowBase = rs.getLong(4);
 				byte[] windowBitmap = rs.getBytes(5);
-				inKeys.add(new IncomingKeys(tagKey, headerKey, rotationPeriod,
+				inKeys.add(new IncomingKeys(tagKey, headerKey, timePeriod,
 						windowBase, windowBitmap));
 			}
 			rs.close();
 			ps.close();
 			// Retrieve the outgoing keys in the same order
-			sql = "SELECT keySetId, contactId, rotationPeriod,"
+			sql = "SELECT keySetId, contactId, timePeriod,"
 					+ " tagKey, headerKey, stream, active"
 					+ " FROM outgoingKeys"
 					+ " WHERE transportId = ?"
@@ -2190,13 +2231,13 @@ abstract class JdbcDatabase implements Database<Connection> {
 				if (inKeys.size() < (i + 1) * 3) throw new DbStateException();
 				KeySetId keySetId = new KeySetId(rs.getInt(1));
 				ContactId contactId = new ContactId(rs.getInt(2));
-				long rotationPeriod = rs.getLong(3);
+				long timePeriod = rs.getLong(3);
 				SecretKey tagKey = new SecretKey(rs.getBytes(4));
 				SecretKey headerKey = new SecretKey(rs.getBytes(5));
 				long streamCounter = rs.getLong(6);
 				boolean active = rs.getBoolean(7);
 				OutgoingKeys outCurr = new OutgoingKeys(tagKey, headerKey,
-						rotationPeriod, streamCounter, active);
+						timePeriod, streamCounter, active);
 				IncomingKeys inPrev = inKeys.get(i * 3);
 				IncomingKeys inCurr = inKeys.get(i * 3 + 1);
 				IncomingKeys inNext = inKeys.get(i * 3 + 2);
@@ -2894,18 +2935,18 @@ abstract class JdbcDatabase implements Database<Connection> {

 	@Override
 	public void setReorderingWindow(Connection txn, KeySetId k, TransportId t,
-			long rotationPeriod, long base, byte[] bitmap) throws DbException {
+			long timePeriod, long base, byte[] bitmap) throws DbException {
 		PreparedStatement ps = null;
 		try {
 			String sql = "UPDATE incomingKeys SET base = ?, bitmap = ?"
 					+ " WHERE transportId = ? AND keySetId = ?"
-					+ " AND rotationPeriod = ?";
+					+ " AND timePeriod = ?";
 			ps = txn.prepareStatement(sql);
 			ps.setLong(1, base);
 			ps.setBytes(2, bitmap);
 			ps.setString(3, t.getString());
 			ps.setInt(4, k.getInt());
-			ps.setLong(5, rotationPeriod);
+			ps.setLong(5, timePeriod);
 			int affected = ps.executeUpdate();
 			if (affected < 0 || affected > 1) throw new DbStateException();
 			ps.close();
@@ -2977,13 +3018,13 @@ abstract class JdbcDatabase implements Database<Connection> {
 		PreparedStatement ps = null;
 		try {
 			// Update the outgoing keys
-			String sql = "UPDATE outgoingKeys SET rotationPeriod = ?,"
+			String sql = "UPDATE outgoingKeys SET timePeriod = ?,"
 					+ " tagKey = ?, headerKey = ?, stream = ?"
 					+ " WHERE transportId = ? AND keySetId = ?";
 			ps = txn.prepareStatement(sql);
 			TransportKeys k = ks.getTransportKeys();
 			OutgoingKeys outCurr = k.getCurrentOutgoingKeys();
-			ps.setLong(1, outCurr.getRotationPeriod());
+			ps.setLong(1, outCurr.getTimePeriod());
 			ps.setBytes(2, outCurr.getTagKey().getBytes());
 			ps.setBytes(3, outCurr.getHeaderKey().getBytes());
 			ps.setLong(4, outCurr.getStreamCounter());
@@ -2993,34 +3034,34 @@ abstract class JdbcDatabase implements Database<Connection> {
 			if (affected < 0 || affected > 1) throw new DbStateException();
 			ps.close();
 			// Update the incoming keys
-			sql = "UPDATE incomingKeys SET rotationPeriod = ?,"
+			sql = "UPDATE incomingKeys SET timePeriod = ?,"
 					+ " tagKey = ?, headerKey = ?, base = ?, bitmap = ?"
 					+ " WHERE transportId = ? AND keySetId = ?"
 					+ " AND periodOffset = ?";
 			ps = txn.prepareStatement(sql);
 			ps.setString(6, k.getTransportId().getString());
 			ps.setInt(7, ks.getKeySetId().getInt());
-			// Previous rotation period
+			// Previous time period
 			IncomingKeys inPrev = k.getPreviousIncomingKeys();
-			ps.setLong(1, inPrev.getRotationPeriod());
+			ps.setLong(1, inPrev.getTimePeriod());
 			ps.setBytes(2, inPrev.getTagKey().getBytes());
 			ps.setBytes(3, inPrev.getHeaderKey().getBytes());
 			ps.setLong(4, inPrev.getWindowBase());
 			ps.setBytes(5, inPrev.getWindowBitmap());
 			ps.setInt(8, OFFSET_PREV);
 			ps.addBatch();
-			// Current rotation period
+			// Current time period
 			IncomingKeys inCurr = k.getCurrentIncomingKeys();
-			ps.setLong(1, inCurr.getRotationPeriod());
+			ps.setLong(1, inCurr.getTimePeriod());
 			ps.setBytes(2, inCurr.getTagKey().getBytes());
 			ps.setBytes(3, inCurr.getHeaderKey().getBytes());
 			ps.setLong(4, inCurr.getWindowBase());
 			ps.setBytes(5, inCurr.getWindowBitmap());
 			ps.setInt(8, OFFSET_CURR);
 			ps.addBatch();
-			// Next rotation period
+			// Next time period
 			IncomingKeys inNext = k.getNextIncomingKeys();
-			ps.setLong(1, inNext.getRotationPeriod());
+			ps.setLong(1, inNext.getTimePeriod());
 			ps.setBytes(2, inNext.getTagKey().getBytes());
 			ps.setBytes(3, inNext.getHeaderKey().getBytes());
 			ps.setLong(4, inNext.getWindowBase());
--- a/bramble-core/src/main/java/org/briarproject/bramble/db/Migration40_41.java
+++ b/bramble-core/src/main/java/org/briarproject/bramble/db/Migration40_41.java
@@ -17,7 +17,7 @@ class Migration40_41 implements Migration<Connection> {

 	private final DatabaseTypes dbTypes;

-	public Migration40_41(DatabaseTypes databaseTypes) {
+	Migration40_41(DatabaseTypes databaseTypes) {
 		this.dbTypes = databaseTypes;
 	}

--- a/bramble-core/src/main/java/org/briarproject/bramble/db/Migration41_42.java
+++ b/bramble-core/src/main/java/org/briarproject/bramble/db/Migration41_42.java
@@ -0,0 +1,89 @@
+package org.briarproject.bramble.db;
+
+import org.briarproject.bramble.api.db.DbException;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.logging.Logger;
+
+import static java.util.logging.Level.WARNING;
+import static java.util.logging.Logger.getLogger;
+import static org.briarproject.bramble.db.JdbcUtils.tryToClose;
+
+class Migration41_42 implements Migration<Connection> {
+
+	private static final Logger LOG = getLogger(Migration41_42.class.getName());
+
+	private final DatabaseTypes dbTypes;
+
+	Migration41_42(DatabaseTypes dbTypes) {
+		this.dbTypes = dbTypes;
+	}
+
+	@Override
+	public int getStartVersion() {
+		return 41;
+	}
+
+	@Override
+	public int getEndVersion() {
+		return 42;
+	}
+
+	@Override
+	public void migrate(Connection txn) throws DbException {
+		Statement s = null;
+		try {
+			s = txn.createStatement();
+			s.execute("ALTER TABLE outgoingKeys"
+					+ " ALTER COLUMN rotationPeriod"
+					+ " RENAME TO timePeriod");
+			s.execute("ALTER TABLE incomingKeys"
+					+ " ALTER COLUMN rotationPeriod"
+					+ " RENAME TO timePeriod");
+			s.execute("ALTER TABLE incomingKeys"
+					+ " DROP COLUMN contactId");
+			s.execute(dbTypes.replaceTypes("CREATE TABLE pendingContacts"
+							+ " (pendingContactId _HASH NOT NULL,"
+							+ " PRIMARY KEY (pendingContactId))"));
+			s.execute(dbTypes.replaceTypes("CREATE TABLE outgoingStaticKeys"
+							+ " (transportId _STRING NOT NULL,"
+							+ " staticKeySetId _COUNTER,"
+							+ " rootKey _SECRET NOT NULL,"
+							+ " timePeriod BIGINT NOT NULL,"
+							+ " stream BIGINT NOT NULL,"
+							+ " contactId INT," // Null if contact is pending
+							+ " pendingContactId _HASH," // Null if not pending
+							+ " PRIMARY KEY (transportId, staticKeySetId),"
+							+ " FOREIGN KEY (transportId)"
+							+ " REFERENCES transports (transportId)"
+							+ " ON DELETE CASCADE,"
+							+ " UNIQUE (staticKeySetId),"
+							+ " FOREIGN KEY (contactId)"
+							+ " REFERENCES contacts (contactId)"
+							+ " ON DELETE CASCADE,"
+							+ " FOREIGN KEY (pendingContactId)"
+							+ " REFERENCES pendingContacts (pendingContactId)"
+							+ " ON DELETE CASCADE)"));
+			s.execute(dbTypes.replaceTypes("CREATE TABLE incomingStaticKeys"
+							+ " (transportId _STRING NOT NULL,"
+							+ " staticKeySetId INT NOT NULL,"
+							+ " timePeriod BIGINT NOT NULL,"
+							+ " base BIGINT NOT NULL,"
+							+ " bitmap _BINARY NOT NULL,"
+							+ " periodOffset INT NOT NULL,"
+							+ " PRIMARY KEY (transportId, staticKeySetId,"
+							+ " periodOffset),"
+							+ " FOREIGN KEY (transportId)"
+							+ " REFERENCES transports (transportId)"
+							+ " ON DELETE CASCADE,"
+							+ " FOREIGN KEY (staticKeySetId)"
+							+ " REFERENCES outgoingStaticKeys (staticKeySetId)"
+							+ " ON DELETE CASCADE)"));
+		} catch (SQLException e) {
+			tryToClose(s, LOG, WARNING);
+			throw new DbException(e);
+		}
+	}
+}
--- a/bramble-core/src/main/java/org/briarproject/bramble/transport/MutableIncomingKeys.java
+++ b/bramble-core/src/main/java/org/briarproject/bramble/transport/MutableIncomingKeys.java
@@ -11,18 +11,18 @@ import javax.annotation.concurrent.NotThreadSafe;
 class MutableIncomingKeys {

 	private final SecretKey tagKey, headerKey;
-	private final long rotationPeriod;
+	private final long timePeriod;
 	private final ReorderingWindow window;

 	MutableIncomingKeys(IncomingKeys in) {
 		tagKey = in.getTagKey();
 		headerKey = in.getHeaderKey();
-		rotationPeriod = in.getRotationPeriod();
+		timePeriod = in.getTimePeriod();
 		window = new ReorderingWindow(in.getWindowBase(), in.getWindowBitmap());
 	}

 	IncomingKeys snapshot() {
-		return new IncomingKeys(tagKey, headerKey, rotationPeriod,
+		return new IncomingKeys(tagKey, headerKey, timePeriod,
 				window.getBase(), window.getBitmap());
 	}

@@ -34,8 +34,8 @@ class MutableIncomingKeys {
 		return headerKey;
 	}

-	long getRotationPeriod() {
-		return rotationPeriod;
+	long getTimePeriod() {
+		return timePeriod;
 	}

 	ReorderingWindow getWindow() {
--- a/bramble-core/src/main/java/org/briarproject/bramble/transport/MutableOutgoingKeys.java
+++ b/bramble-core/src/main/java/org/briarproject/bramble/transport/MutableOutgoingKeys.java
@@ -11,20 +11,20 @@ import javax.annotation.concurrent.NotThreadSafe;
 class MutableOutgoingKeys {

 	private final SecretKey tagKey, headerKey;
-	private final long rotationPeriod;
+	private final long timePeriod;
 	private long streamCounter;
 	private boolean active;

 	MutableOutgoingKeys(OutgoingKeys out) {
 		tagKey = out.getTagKey();
 		headerKey = out.getHeaderKey();
-		rotationPeriod = out.getRotationPeriod();
+		timePeriod = out.getTimePeriod();
 		streamCounter = out.getStreamCounter();
 		active = out.isActive();
 	}

 	OutgoingKeys snapshot() {
-		return new OutgoingKeys(tagKey, headerKey, rotationPeriod,
+		return new OutgoingKeys(tagKey, headerKey, timePeriod,
 				streamCounter, active);
 	}

@@ -36,8 +36,8 @@ class MutableOutgoingKeys {
 		return headerKey;
 	}

-	long getRotationPeriod() {
-		return rotationPeriod;
+	long getTimePeriod() {
+		return timePeriod;
 	}

 	long getStreamCounter() {
--- a/bramble-core/src/main/java/org/briarproject/bramble/transport/TransportKeyManagerImpl.java
+++ b/bramble-core/src/main/java/org/briarproject/bramble/transport/TransportKeyManagerImpl.java
@@ -51,7 +51,7 @@ class TransportKeyManagerImpl implements TransportKeyManager {
 	private final ScheduledExecutorService scheduler;
 	private final Clock clock;
 	private final TransportId transportId;
-	private final long rotationPeriodLength;
+	private final long timePeriodLength;
 	private final AtomicBoolean used = new AtomicBoolean(false);
 	private final ReentrantLock lock = new ReentrantLock();

@@ -70,7 +70,7 @@ class TransportKeyManagerImpl implements TransportKeyManager {
 		this.scheduler = scheduler;
 		this.clock = clock;
 		this.transportId = transportId;
-		rotationPeriodLength = maxLatency + MAX_CLOCK_DIFFERENCE;
+		timePeriodLength = maxLatency + MAX_CLOCK_DIFFERENCE;
 	}

 	@Override
@@ -81,7 +81,7 @@ class TransportKeyManagerImpl implements TransportKeyManager {
 		try {
 			// Load the transport keys from the DB
 			Collection<KeySet> loaded = db.getTransportKeys(txn, transportId);
-			// Rotate the keys to the current rotation period
+			// Rotate the keys to the current time period
 			RotationResult rotationResult = rotateKeys(loaded, now);
 			// Initialise mutable state for all contacts
 			addKeys(rotationResult.current);
@@ -97,13 +97,13 @@ class TransportKeyManagerImpl implements TransportKeyManager {

 	private RotationResult rotateKeys(Collection<KeySet> keys, long now) {
 		RotationResult rotationResult = new RotationResult();
-		long rotationPeriod = now / rotationPeriodLength;
+		long timePeriod = now / timePeriodLength;
 		for (KeySet ks : keys) {
 			TransportKeys k = ks.getTransportKeys();
 			TransportKeys k1 =
-					transportCrypto.rotateTransportKeys(k, rotationPeriod);
+					transportCrypto.rotateTransportKeys(k, timePeriod);
 			KeySet ks1 = new KeySet(ks.getKeySetId(), ks.getContactId(), k1);
-			if (k1.getRotationPeriod() > k.getRotationPeriod())
+			if (k1.getTimePeriod() > k.getTimePeriod())
 				rotationResult.rotated.add(ks1);
 			rotationResult.current.add(ks1);
 		}
@@ -155,7 +155,7 @@ class TransportKeyManagerImpl implements TransportKeyManager {
 	}

 	private void scheduleKeyRotation(long now) {
-		long delay = rotationPeriodLength - now % rotationPeriodLength;
+		long delay = timePeriodLength - now % timePeriodLength;
 		scheduler.schedule((Runnable) this::rotateKeys, delay, MILLISECONDS);
 	}

@@ -174,14 +174,14 @@ class TransportKeyManagerImpl implements TransportKeyManager {
 			long timestamp, boolean alice, boolean active) throws DbException {
 		lock.lock();
 		try {
-			// Work out what rotation period the timestamp belongs to
-			long rotationPeriod = timestamp / rotationPeriodLength;
+			// Work out what time period the timestamp belongs to
+			long timePeriod = timestamp / timePeriodLength;
 			// Derive the transport keys
 			TransportKeys k = transportCrypto.deriveTransportKeys(transportId,
-					master, rotationPeriod, alice, active);
-			// Rotate the keys to the current rotation period if necessary
-			rotationPeriod = clock.currentTimeMillis() / rotationPeriodLength;
-			k = transportCrypto.rotateTransportKeys(k, rotationPeriod);
+					master, timePeriod, alice, active);
+			// Rotate the keys to the current time period if necessary
+			timePeriod = clock.currentTimeMillis() / timePeriodLength;
+			k = transportCrypto.rotateTransportKeys(k, timePeriod);
 			// Write the keys back to the DB
 			KeySetId keySetId = db.addTransportKeys(txn, c, k);
 			// Initialise mutable state for the contact
@@ -300,7 +300,7 @@ class TransportKeyManagerImpl implements TransportKeyManager {
 			}
 			// Write the window back to the DB
 			db.setReorderingWindow(txn, tagCtx.keySetId, transportId,
-					inKeys.getRotationPeriod(), window.getBase(),
+					inKeys.getTimePeriod(), window.getBase(),
 					window.getBitmap());
 			// If the outgoing keys are inactive, activate them
 			MutableKeySet ks = keys.get(tagCtx.keySetId);
@@ -322,7 +322,7 @@ class TransportKeyManagerImpl implements TransportKeyManager {
 		long now = clock.currentTimeMillis();
 		lock.lock();
 		try {
-			// Rotate the keys to the current rotation period
+			// Rotate the keys to the current time period
 			Collection<KeySet> snapshot = new ArrayList<>(keys.size());
 			for (MutableKeySet ks : keys.values()) {
 				snapshot.add(new KeySet(ks.getKeySetId(), ks.getContactId(),