refactore trust enum to be FingerprintStatus class with trust and active

4 files changed, 215 insertions, 190 deletions

diff --git a/src/main/java/de/pixart/messenger/crypto/axolotl/AxolotlService.java b/src/main/java/de/pixart/messenger/crypto/axolotl/AxolotlService.java
index a7503c089..384a19067 100644
--- a/src/main/java/de/pixart/messenger/crypto/axolotl/AxolotlService.java
+++ b/src/main/java/de/pixart/messenger/crypto/axolotl/AxolotlService.java
@@ -185,8 +185,8 @@ public class AxolotlService implements OnAdvancedStreamFeaturesLoaded {
 		}
 
 		private void fillMap(SQLiteAxolotlStore store) {
-            List<Integer> deviceIds = store.getSubDeviceSessions(account.getJid().toBareJid().toPreppedString());
-            putDevicesForJid(account.getJid().toBareJid().toPreppedString(), deviceIds, store);
+			List<Integer> deviceIds = store.getSubDeviceSessions(account.getJid().toBareJid().toPreppedString());
+			putDevicesForJid(account.getJid().toBareJid().toPreppedString(), deviceIds, store);
 			for (Contact contact : account.getRoster().getContacts()) {
 				Jid bareJid = contact.getJid().toBareJid();
 				String address = bareJid.toString();
@@ -256,18 +256,18 @@ public class AxolotlService implements OnAdvancedStreamFeaturesLoaded {
 		return axolotlStore.getIdentityKeyPair().getPublicKey().getFingerprint().replaceAll("\\s", "");
 	}
 
-	public Set<IdentityKey> getKeysWithTrust(XmppAxolotlSession.Trust trust) {
-		return axolotlStore.getContactKeysWithTrust(account.getJid().toBareJid().toPreppedString(), trust);
+	public Set<IdentityKey> getKeysWithTrust(FingerprintStatus status) {
+		return axolotlStore.getContactKeysWithTrust(account.getJid().toBareJid().toPreppedString(), status);
 	}
 
-	public Set<IdentityKey> getKeysWithTrust(XmppAxolotlSession.Trust trust, Jid jid) {
-		return axolotlStore.getContactKeysWithTrust(jid.toBareJid().toPreppedString(), trust);
+	public Set<IdentityKey> getKeysWithTrust(FingerprintStatus status, Jid jid) {
+		return axolotlStore.getContactKeysWithTrust(jid.toBareJid().toPreppedString(), status);
 	}
 
-	public Set<IdentityKey> getKeysWithTrust(XmppAxolotlSession.Trust trust, List<Jid> jids) {
+	public Set<IdentityKey> getKeysWithTrust(FingerprintStatus status, List<Jid> jids) {
 		Set<IdentityKey> keys = new HashSet<>();
 		for(Jid jid : jids) {
-			keys.addAll(axolotlStore.getContactKeysWithTrust(jid.toPreppedString(), trust));
+			keys.addAll(axolotlStore.getContactKeysWithTrust(jid.toPreppedString(), status));
 		}
 		return keys;
 	}
@@ -355,19 +355,6 @@ public class AxolotlService implements OnAdvancedStreamFeaturesLoaded {
 		return this.deviceIds.get(account.getJid().toBareJid());
 	}
 
-	private void setTrustOnSessions(final Jid jid, @NonNull final Set<Integer> deviceIds,
-	                                final XmppAxolotlSession.Trust from,
-	                                final XmppAxolotlSession.Trust to) {
-		for (Integer deviceId : deviceIds) {
-			AxolotlAddress address = new AxolotlAddress(jid.toBareJid().toPreppedString(), deviceId);
-			XmppAxolotlSession session = sessions.get(address);
-			if (session != null && session.getFingerprint() != null
-					&& session.getTrust() == from) {
-				session.setTrust(to);
-			}
-		}
-	}
-
 	public void registerDevices(final Jid jid, @NonNull final Set<Integer> deviceIds) {
 		if (jid.toBareJid().equals(account.getJid().toBareJid())) {
 			if (!deviceIds.isEmpty()) {
@@ -389,23 +376,25 @@ public class AxolotlService implements OnAdvancedStreamFeaturesLoaded {
 		}
 		Set<Integer> expiredDevices = new HashSet<>(axolotlStore.getSubDeviceSessions(jid.toBareJid().toPreppedString()));
 		expiredDevices.removeAll(deviceIds);
-		setTrustOnSessions(jid, expiredDevices, XmppAxolotlSession.Trust.TRUSTED,
-				XmppAxolotlSession.Trust.INACTIVE_TRUSTED);
-		setTrustOnSessions(jid, expiredDevices, XmppAxolotlSession.Trust.TRUSTED_X509,
-				XmppAxolotlSession.Trust.INACTIVE_TRUSTED_X509);
-		setTrustOnSessions(jid, expiredDevices, XmppAxolotlSession.Trust.UNDECIDED,
-				XmppAxolotlSession.Trust.INACTIVE_UNDECIDED);
-		setTrustOnSessions(jid, expiredDevices, XmppAxolotlSession.Trust.UNTRUSTED,
-				XmppAxolotlSession.Trust.INACTIVE_UNTRUSTED);
+		for (Integer deviceId : expiredDevices) {
+			AxolotlAddress address = new AxolotlAddress(jid.toBareJid().toPreppedString(), deviceId);
+			XmppAxolotlSession session = sessions.get(address);
+			if (session != null && session.getFingerprint() != null) {
+				if (session.getTrust().isActive()) {
+					session.setTrust(session.getTrust().toInactive());
+				}
+			}
+		}
 		Set<Integer> newDevices = new HashSet<>(deviceIds);
-		setTrustOnSessions(jid, newDevices, XmppAxolotlSession.Trust.INACTIVE_TRUSTED,
-				XmppAxolotlSession.Trust.TRUSTED);
-		setTrustOnSessions(jid, newDevices, XmppAxolotlSession.Trust.INACTIVE_TRUSTED_X509,
-				XmppAxolotlSession.Trust.TRUSTED_X509);
-		setTrustOnSessions(jid, newDevices, XmppAxolotlSession.Trust.INACTIVE_UNDECIDED,
-				XmppAxolotlSession.Trust.UNDECIDED);
-		setTrustOnSessions(jid, newDevices, XmppAxolotlSession.Trust.INACTIVE_UNTRUSTED,
-				XmppAxolotlSession.Trust.UNTRUSTED);
+		for (Integer deviceId : newDevices) {
+			AxolotlAddress address = new AxolotlAddress(jid.toBareJid().toPreppedString(), deviceId);
+			XmppAxolotlSession session = sessions.get(address);
+			if (session != null && session.getFingerprint() != null) {
+				if (!session.getTrust().isActive()) {
+					session.setTrust(session.getTrust().toActive());
+				}
+			}
+		}
 		this.deviceIds.put(jid, deviceIds);
 		mXmppConnectionService.keyStatusUpdated(null);
 	}
@@ -428,7 +417,7 @@ public class AxolotlService implements OnAdvancedStreamFeaturesLoaded {
 	}
 
 	public void purgeKey(final String fingerprint) {
-		axolotlStore.setFingerprintTrust(fingerprint.replaceAll("\\s", ""), XmppAxolotlSession.Trust.COMPROMISED);
+		axolotlStore.setFingerprintTrust(fingerprint.replaceAll("\\s", ""), FingerprintStatus.createCompromised());
 	}
 
 	public void publishOwnDeviceIdIfNeeded() {
@@ -660,24 +649,24 @@ public class AxolotlService implements OnAdvancedStreamFeaturesLoaded {
 	}
 
 	public Pair<AxolotlCapability,Jid> isConversationAxolotlCapableDetailed(Conversation conversation) {
-        if (conversation.getMode() == Conversation.MODE_SINGLE || (conversation.getMucOptions().membersOnly() && conversation.getMucOptions().nonanonymous())) {
-            final List<Jid> jids = getCryptoTargets(conversation);
-            for(Jid jid : jids) {
-                if (!hasAny(jid) && (!deviceIds.containsKey(jid) || deviceIds.get(jid).isEmpty())) {
-                    if (conversation.getAccount().getRoster().getContact(jid).mutualPresenceSubscription()) {
-                        return new Pair<>(AxolotlCapability.MISSING_KEYS,jid);
-                    } else {
-                        return new Pair<>(AxolotlCapability.MISSING_PRESENCE,jid);
-                    }
+		if (conversation.getMode() == Conversation.MODE_SINGLE || (conversation.getMucOptions().membersOnly() && conversation.getMucOptions().nonanonymous())) {
+			final List<Jid> jids = getCryptoTargets(conversation);
+			for(Jid jid : jids) {
+				if (!hasAny(jid) && (!deviceIds.containsKey(jid) || deviceIds.get(jid).isEmpty())) {
+					if (conversation.getAccount().getRoster().getContact(jid).mutualPresenceSubscription()) {
+						return new Pair<>(AxolotlCapability.MISSING_KEYS,jid);
+					} else {
+						return new Pair<>(AxolotlCapability.MISSING_PRESENCE,jid);
+					}
 				}
 			}
-            if (jids.size() > 0) {
-                return new Pair<>(AxolotlCapability.FULL, null);
+			if (jids.size() > 0) {
+				return new Pair<>(AxolotlCapability.FULL, null);
 			} else {
 				return new Pair<>(AxolotlCapability.NO_MEMBERS, null);
 			}
-        } else {
-            return new Pair<>(AxolotlCapability.WRONG_CONFIGURATION, null);
+		} else {
+			return new Pair<>(AxolotlCapability.WRONG_CONFIGURATION, null);
 		}
 	}
 
@@ -691,16 +680,16 @@ public class AxolotlService implements OnAdvancedStreamFeaturesLoaded {
 		return jids;
 	}
 
-	public XmppAxolotlSession.Trust getFingerprintTrust(String fingerprint) {
-		return axolotlStore.getFingerprintTrust(fingerprint);
+	public FingerprintStatus getFingerprintTrust(String fingerprint) {
+		return axolotlStore.getFingerprintStatus(fingerprint);
 	}
 
 	public X509Certificate getFingerprintCertificate(String fingerprint) {
 		return axolotlStore.getFingerprintCertificate(fingerprint);
 	}
 
-	public void setFingerprintTrust(String fingerprint, XmppAxolotlSession.Trust trust) {
-		axolotlStore.setFingerprintTrust(fingerprint, trust);
+	public void setFingerprintTrust(String fingerprint, FingerprintStatus status) {
+		axolotlStore.setFingerprintTrust(fingerprint, status);
 	}
 
 	private void verifySessionWithPEP(final XmppAxolotlSession session) {
@@ -723,7 +712,7 @@ public class AxolotlService implements OnAdvancedStreamFeaturesLoaded {
 									mXmppConnectionService.getMemorizingTrustManager().getNonInteractive().checkClientTrusted(verification.first, "RSA");
 									String fingerprint = session.getFingerprint();
 									Log.d(Config.LOGTAG, "verified session with x.509 signature. fingerprint was: "+fingerprint);
-									setFingerprintTrust(fingerprint, XmppAxolotlSession.Trust.TRUSTED_X509);
+									setFingerprintTrust(fingerprint, FingerprintStatus.createActiveVerified(true));
 									axolotlStore.setFingerprintCertificate(fingerprint, verification.first[0]);
 									fetchStatusMap.put(address, FetchStatus.SUCCESS_VERIFIED);
 									Bundle information = CryptoHelper.extractCertificateInformation(verification.first[0]);
@@ -920,8 +909,8 @@ public class AxolotlService implements OnAdvancedStreamFeaturesLoaded {
 		sessions.addAll(findOwnSessions());
 		boolean verified = false;
 		for(XmppAxolotlSession session : sessions) {
-			if (session.getTrust().trusted()) {
-				if (session.getTrust() == XmppAxolotlSession.Trust.TRUSTED_X509) {
+			if (session.getTrust().isTrustedAndActive()) {
+				if (session.getTrust().getTrust() == FingerprintStatus.Trust.VERIFIED_X509) {
 					verified = true;
 				} else {
 					return false;
diff --git a/src/main/java/de/pixart/messenger/crypto/axolotl/FingerprintStatus.java b/src/main/java/de/pixart/messenger/crypto/axolotl/FingerprintStatus.java
new file mode 100644
index 000000000..38aef325e
--- /dev/null
+++ b/src/main/java/de/pixart/messenger/crypto/axolotl/FingerprintStatus.java
@@ -0,0 +1,122 @@
+package de.pixart.messenger.crypto.axolotl;
+
+import android.content.ContentValues;
+import android.database.Cursor;
+
+public class FingerprintStatus {
+
+    private Trust trust = Trust.UNTRUSTED;
+    private boolean active = false;
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        FingerprintStatus that = (FingerprintStatus) o;
+
+        return active == that.active && trust == that.trust;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = trust.hashCode();
+        result = 31 * result + (active ? 1 : 0);
+        return result;
+    }
+
+    private FingerprintStatus() {
+
+
+    }
+
+    public ContentValues toContentValues() {
+        final ContentValues contentValues = new ContentValues();
+        contentValues.put(SQLiteAxolotlStore.TRUST,trust.toString());
+        contentValues.put(SQLiteAxolotlStore.ACTIVE,active ? 1 : 0);
+        return contentValues;
+    }
+
+    public static FingerprintStatus fromCursor(Cursor cursor) {
+        final FingerprintStatus status = new FingerprintStatus();
+        try {
+            status.trust = Trust.valueOf(cursor.getString(cursor.getColumnIndex(SQLiteAxolotlStore.TRUST)));
+        } catch(IllegalArgumentException e) {
+            status.trust = Trust.UNTRUSTED;
+        }
+        status.active = cursor.getInt(cursor.getColumnIndex(SQLiteAxolotlStore.ACTIVE)) > 0;
+        return status;
+    }
+
+    public static FingerprintStatus createActiveUndecided() {
+        final FingerprintStatus status = new FingerprintStatus();
+        status.trust = Trust.UNDECIDED;
+        status.active = true;
+        return status;
+    }
+
+    public static FingerprintStatus createActiveVerified(boolean x509) {
+        final FingerprintStatus status = new FingerprintStatus();
+        status.trust = x509 ? Trust.VERIFIED_X509 : Trust.VERIFIED;
+        status.active = true;
+        return status;
+    }
+
+    public static FingerprintStatus createActive(boolean trusted) {
+        final FingerprintStatus status = new FingerprintStatus();
+        status.trust = trusted ? Trust.TRUSTED : Trust.UNTRUSTED;
+        status.active = true;
+        return status;
+    }
+
+    public boolean isTrustedAndActive() {
+        return active && isTrusted();
+    }
+
+    public boolean isTrusted() {
+        return trust == Trust.TRUSTED || trust == Trust.VERIFIED || trust == Trust.VERIFIED_X509;
+    }
+
+    public boolean isCompromised() {
+        return trust == Trust.COMPROMISED;
+    }
+
+    public boolean isActive() {
+        return active;
+    }
+
+    public FingerprintStatus toActive() {
+        FingerprintStatus status = new FingerprintStatus();
+        status.trust = trust;
+        status.active = true;
+        return status;
+    }
+
+    public FingerprintStatus toInactive() {
+        FingerprintStatus status = new FingerprintStatus();
+        status.trust = trust;
+        status.active = false;
+        return status;
+    }
+
+    public Trust getTrust() {
+        return trust;
+    }
+
+    public static FingerprintStatus createCompromised() {
+        FingerprintStatus status = new FingerprintStatus();
+        status.active = false;
+        status.trust = Trust.COMPROMISED;
+        return status;
+    }
+
+    public enum Trust {
+        COMPROMISED,
+        UNDECIDED,
+        UNTRUSTED,
+        TRUSTED,
+        VERIFIED,
+        VERIFIED_X509
+    }
+
+}
\ No newline at end of file
diff --git a/src/main/java/de/pixart/messenger/crypto/axolotl/SQLiteAxolotlStore.java b/src/main/java/de/pixart/messenger/crypto/axolotl/SQLiteAxolotlStore.java
index 7f28ad09e..66786084d 100644
--- a/src/main/java/de/pixart/messenger/crypto/axolotl/SQLiteAxolotlStore.java
+++ b/src/main/java/de/pixart/messenger/crypto/axolotl/SQLiteAxolotlStore.java
@@ -35,7 +35,9 @@ public class SQLiteAxolotlStore implements AxolotlStore {
 	public static final String KEY = "key";
 	public static final String FINGERPRINT = "fingerprint";
 	public static final String NAME = "name";
-	public static final String TRUSTED = "trusted";
+	public static final String TRUSTED = "trusted"; //no longer used
+	public static final String TRUST = "trust";
+	public static final String ACTIVE = "active";
 	public static final String OWN = "ownkey";
 	public static final String CERTIFICATE = "certificate";
 
@@ -51,11 +53,11 @@ public class SQLiteAxolotlStore implements AxolotlStore {
 	private int localRegistrationId;
 	private int currentPreKeyId = 0;
 
-	private final LruCache<String, XmppAxolotlSession.Trust> trustCache =
-			new LruCache<String, XmppAxolotlSession.Trust>(NUM_TRUSTS_TO_CACHE) {
+	private final LruCache<String, FingerprintStatus> trustCache =
+			new LruCache<String, FingerprintStatus>(NUM_TRUSTS_TO_CACHE) {
 				@Override
-				protected XmppAxolotlSession.Trust create(String fingerprint) {
-					return mXmppConnectionService.databaseBackend.isIdentityKeyTrusted(account, fingerprint);
+				protected FingerprintStatus create(String fingerprint) {
+					return mXmppConnectionService.databaseBackend.getFingerprintStatus(account, fingerprint);
 				}
 			};
 
@@ -208,12 +210,12 @@ public class SQLiteAxolotlStore implements AxolotlStore {
 		return true;
 	}
 
-	public XmppAxolotlSession.Trust getFingerprintTrust(String fingerprint) {
+	public FingerprintStatus getFingerprintStatus(String fingerprint) {
 		return (fingerprint == null)? null : trustCache.get(fingerprint);
 	}
 
-	public void setFingerprintTrust(String fingerprint, XmppAxolotlSession.Trust trust) {
-		mXmppConnectionService.databaseBackend.setIdentityKeyTrust(account, fingerprint, trust);
+	public void setFingerprintTrust(String fingerprint, FingerprintStatus status) {
+		mXmppConnectionService.databaseBackend.setIdentityKeyTrust(account, fingerprint, status);
 		trustCache.remove(fingerprint);
 	}
 
@@ -225,8 +227,8 @@ public class SQLiteAxolotlStore implements AxolotlStore {
 		return mXmppConnectionService.databaseBackend.getIdentityKeyCertifcate(account, fingerprint);
 	}
 
-	public Set<IdentityKey> getContactKeysWithTrust(String bareJid, XmppAxolotlSession.Trust trust) {
-		return mXmppConnectionService.databaseBackend.loadIdentityKeys(account, bareJid, trust);
+	public Set<IdentityKey> getContactKeysWithTrust(String bareJid, FingerprintStatus status) {
+		return mXmppConnectionService.databaseBackend.loadIdentityKeys(account, bareJid, status);
 	}
 
 	public long getContactNumTrustedKeys(String bareJid) {
diff --git a/src/main/java/de/pixart/messenger/crypto/axolotl/XmppAxolotlSession.java b/src/main/java/de/pixart/messenger/crypto/axolotl/XmppAxolotlSession.java
index c2cb2a3e7..a98583ac2 100644
--- a/src/main/java/de/pixart/messenger/crypto/axolotl/XmppAxolotlSession.java
+++ b/src/main/java/de/pixart/messenger/crypto/axolotl/XmppAxolotlSession.java
@@ -19,9 +19,6 @@ import org.whispersystems.libaxolotl.protocol.CiphertextMessage;
 import org.whispersystems.libaxolotl.protocol.PreKeyWhisperMessage;
 import org.whispersystems.libaxolotl.protocol.WhisperMessage;
 
-import java.util.HashMap;
-import java.util.Map;
-
 import de.pixart.messenger.Config;
 import de.pixart.messenger.entities.Account;
 
@@ -34,76 +31,6 @@ public class XmppAxolotlSession {
 	private Integer preKeyId = null;
 	private boolean fresh = true;
 
-	public enum Trust {
-		UNDECIDED(0),
-		TRUSTED(1),
-		UNTRUSTED(2),
-		COMPROMISED(3),
-		INACTIVE_TRUSTED(4),
-		INACTIVE_UNDECIDED(5),
-		INACTIVE_UNTRUSTED(6),
-		TRUSTED_X509(7),
-		INACTIVE_TRUSTED_X509(8);
-
-		private static final Map<Integer, Trust> trustsByValue = new HashMap<>();
-
-		static {
-			for (Trust trust : Trust.values()) {
-				trustsByValue.put(trust.getCode(), trust);
-			}
-		}
-
-		private final int code;
-
-		Trust(int code) {
-			this.code = code;
-		}
-
-		public int getCode() {
-			return this.code;
-		}
-
-		public String toString() {
-			switch (this) {
-				case UNDECIDED:
-					return "Trust undecided " + getCode();
-				case TRUSTED:
-					return "Trusted " + getCode();
-				case COMPROMISED:
-					return "Compromised " + getCode();
-				case INACTIVE_TRUSTED:
-					return "Inactive (Trusted)" + getCode();
-				case INACTIVE_UNDECIDED:
-					return "Inactive (Undecided)" + getCode();
-				case INACTIVE_UNTRUSTED:
-					return "Inactive (Untrusted)" + getCode();
-				case TRUSTED_X509:
-					return "Trusted (X509) " + getCode();
-				case INACTIVE_TRUSTED_X509:
-					return "Inactive (Trusted (X509)) " + getCode();
-				case UNTRUSTED:
-				default:
-					return "Untrusted " + getCode();
-			}
-		}
-
-		public static Trust fromBoolean(Boolean trusted) {
-			return trusted ? TRUSTED : UNTRUSTED;
-		}
-
-		public static Trust fromCode(int code) {
-			return trustsByValue.get(code);
-		}
-
-		public boolean trusted() {
-			return this == TRUSTED_X509 || this == TRUSTED;
-		}
-
-		public boolean trustedInactive() {
-			return this == INACTIVE_TRUSTED_X509 || this == INACTIVE_TRUSTED;
-		}
-	}
-
 	public XmppAxolotlSession(Account account, SQLiteAxolotlStore store, AxolotlAddress remoteAddress, IdentityKey identityKey) {
 		this(account, store, remoteAddress);
 		this.identityKey = identityKey;
@@ -145,75 +72,60 @@ public class XmppAxolotlSession {
 		this.fresh = false;
 	}
 
-	protected void setTrust(Trust trust) {
-		sqLiteAxolotlStore.setFingerprintTrust(getFingerprint(), trust);
+	protected void setTrust(FingerprintStatus status) {
+		sqLiteAxolotlStore.setFingerprintTrust(getFingerprint(), status);
 	}
 
-	protected Trust getTrust() {
-		Trust trust = sqLiteAxolotlStore.getFingerprintTrust(getFingerprint());
-		return (trust == null) ? Trust.UNDECIDED : trust;
+	protected FingerprintStatus getTrust() {
+		FingerprintStatus status = sqLiteAxolotlStore.getFingerprintStatus(getFingerprint());
+		return (status == null) ? FingerprintStatus.createActiveUndecided() : status;
 	}
 
 	@Nullable
 	public byte[] processReceiving(byte[] encryptedKey) {
 		byte[] plaintext = null;
-		Trust trust = getTrust();
-		switch (trust) {
-			case INACTIVE_TRUSTED:
-			case UNDECIDED:
-			case UNTRUSTED:
-			case TRUSTED:
-			case INACTIVE_TRUSTED_X509:
-			case TRUSTED_X509:
+		FingerprintStatus status = getTrust();
+		if (!status.isCompromised()) {
+			try {
 				try {
-					try {
-						PreKeyWhisperMessage message = new PreKeyWhisperMessage(encryptedKey);
-						if (!message.getPreKeyId().isPresent()) {
-							Log.w(Config.LOGTAG, AxolotlService.getLogprefix(account) + "PreKeyWhisperMessage did not contain a PreKeyId");
-							break;
-						}
-						Log.i(Config.LOGTAG, AxolotlService.getLogprefix(account) + "PreKeyWhisperMessage received, new session ID:" + message.getSignedPreKeyId() + "/" + message.getPreKeyId());
-						IdentityKey msgIdentityKey = message.getIdentityKey();
-						if (this.identityKey != null && !this.identityKey.equals(msgIdentityKey)) {
-							Log.e(Config.LOGTAG, AxolotlService.getLogprefix(account) + "Had session with fingerprint " + this.getFingerprint() + ", received message with fingerprint " + msgIdentityKey.getFingerprint());
-						} else {
-							this.identityKey = msgIdentityKey;
-							plaintext = cipher.decrypt(message);
-							preKeyId = message.getPreKeyId().get();
-						}
-					} catch (InvalidMessageException | InvalidVersionException e) {
-						Log.i(Config.LOGTAG, AxolotlService.getLogprefix(account) + "WhisperMessage received");
-						WhisperMessage message = new WhisperMessage(encryptedKey);
+					PreKeyWhisperMessage message = new PreKeyWhisperMessage(encryptedKey);
+					if (!message.getPreKeyId().isPresent()) {
+						Log.w(Config.LOGTAG, AxolotlService.getLogprefix(account) + "PreKeyWhisperMessage did not contain a PreKeyId");
+						return null;
+					}
+					Log.i(Config.LOGTAG, AxolotlService.getLogprefix(account) + "PreKeyWhisperMessage received, new session ID:" + message.getSignedPreKeyId() + "/" + message.getPreKeyId());
+					IdentityKey msgIdentityKey = message.getIdentityKey();
+					if (this.identityKey != null && !this.identityKey.equals(msgIdentityKey)) {
+						Log.e(Config.LOGTAG, AxolotlService.getLogprefix(account) + "Had session with fingerprint " + this.getFingerprint() + ", received message with fingerprint " + msgIdentityKey.getFingerprint());
+					} else {
+						this.identityKey = msgIdentityKey;
 						plaintext = cipher.decrypt(message);
-					} catch (InvalidKeyException | InvalidKeyIdException | UntrustedIdentityException e) {
-						Log.w(Config.LOGTAG, AxolotlService.getLogprefix(account) + "Error decrypting axolotl header, " + e.getClass().getName() + ": " + e.getMessage());
+						preKeyId = message.getPreKeyId().get();
 					}
-				} catch (LegacyMessageException | InvalidMessageException | DuplicateMessageException | NoSessionException e) {
+				} catch (InvalidMessageException | InvalidVersionException e) {
+					Log.i(Config.LOGTAG, AxolotlService.getLogprefix(account) + "WhisperMessage received");
+					WhisperMessage message = new WhisperMessage(encryptedKey);
+					plaintext = cipher.decrypt(message);
+				} catch (InvalidKeyException | InvalidKeyIdException | UntrustedIdentityException e) {
 					Log.w(Config.LOGTAG, AxolotlService.getLogprefix(account) + "Error decrypting axolotl header, " + e.getClass().getName() + ": " + e.getMessage());
 				}
+			} catch (LegacyMessageException | InvalidMessageException | DuplicateMessageException | NoSessionException e) {
+				Log.w(Config.LOGTAG, AxolotlService.getLogprefix(account) + "Error decrypting axolotl header, " + e.getClass().getName() + ": " + e.getMessage());
+			}
 
-				if (plaintext != null) {
-					if (trust == Trust.INACTIVE_TRUSTED) {
-						setTrust(Trust.TRUSTED);
-					} else if (trust == Trust.INACTIVE_TRUSTED_X509) {
-						setTrust(Trust.TRUSTED_X509);
-					}
+			if (plaintext != null) {
+				if (!status.isActive()) {
+					setTrust(status.toActive());
 				}
-
-				break;
-
-			case COMPROMISED:
-			default:
-				// ignore
-				break;
+			}
 		}
 		return plaintext;
 	}
 
 	@Nullable
 	public byte[] processSending(@NonNull byte[] outgoingMessage) {
-		Trust trust = getTrust();
-		if (trust.trusted()) {
+		FingerprintStatus status = getTrust();
+		if (status.isTrustedAndActive()) {
 			CiphertextMessage ciphertextMessage = cipher.encrypt(outgoingMessage);
 			return ciphertextMessage.serialize();
 		} else {