1 files changed, 144 insertions, 98 deletions

diff --git a/src/main/java/eu/siacs/conversations/crypto/axolotl/XmppAxolotlMessage.java b/src/main/java/eu/siacs/conversations/crypto/axolotl/XmppAxolotlMessage.java
index 24afeaeae..cf950d6da 100644
--- a/src/main/java/eu/siacs/conversations/crypto/axolotl/XmppAxolotlMessage.java
+++ b/src/main/java/eu/siacs/conversations/crypto/axolotl/XmppAxolotlMessage.java
@@ -1,15 +1,16 @@
 package eu.siacs.conversations.crypto.axolotl;
 
-import android.support.annotation.Nullable;
 import android.util.Base64;
+import android.util.Log;
 
 import java.security.InvalidAlgorithmParameterException;
 import java.security.InvalidKeyException;
 import java.security.NoSuchAlgorithmException;
 import java.security.NoSuchProviderException;
 import java.security.SecureRandom;
-import java.util.HashSet;
-import java.util.Set;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 
 import javax.crypto.BadPaddingException;
 import javax.crypto.Cipher;
@@ -20,112 +21,142 @@ import javax.crypto.SecretKey;
 import javax.crypto.spec.IvParameterSpec;
 import javax.crypto.spec.SecretKeySpec;
 
+import eu.siacs.conversations.Config;
 import eu.siacs.conversations.xml.Element;
 import eu.siacs.conversations.xmpp.jid.Jid;
 
 public class XmppAxolotlMessage {
+	public static final String CONTAINERTAG = "encrypted";
+	public static final String HEADER = "header";
+	public static final String SOURCEID = "sid";
+	public static final String KEYTAG = "key";
+	public static final String REMOTEID = "rid";
+	public static final String IVTAG = "iv";
+	public static final String PAYLOAD = "payload";
+
+	private static final String KEYTYPE = "AES";
+	private static final String CIPHERMODE = "AES/GCM/NoPadding";
+	private static final String PROVIDER = "BC";
+
 	private byte[] innerKey;
-	private byte[] ciphertext;
-	private byte[] iv;
-	private final Set<XmppAxolotlMessageHeader> headers;
+	private byte[] ciphertext = null;
+	private byte[] iv = null;
+	private final Map<Integer, byte[]> keys;
 	private final Jid from;
 	private final int sourceDeviceId;
 
-	public static class XmppAxolotlMessageHeader {
-		private final int recipientDeviceId;
-		private final byte[] content;
-
-		public XmppAxolotlMessageHeader(int deviceId, byte[] content) {
-			this.recipientDeviceId = deviceId;
-			this.content = content;
-		}
+	public static class XmppAxolotlPlaintextMessage {
+		private final String plaintext;
+		private final String fingerprint;
 
-		public XmppAxolotlMessageHeader(Element header) {
-			if("header".equals(header.getName())) {
-				this.recipientDeviceId = Integer.parseInt(header.getAttribute("rid"));
-				this.content = Base64.decode(header.getContent(),Base64.DEFAULT);
-			} else {
-				throw new IllegalArgumentException("Argument not a <header> Element!");
-			}
+		public XmppAxolotlPlaintextMessage(String plaintext, String fingerprint) {
+			this.plaintext = plaintext;
+			this.fingerprint = fingerprint;
 		}
 
-		public int getRecipientDeviceId() {
-			return recipientDeviceId;
+		public String getPlaintext() {
+			return plaintext;
 		}
 
-		public byte[] getContents() {
-			return content;
-		}
 
-		public Element toXml() {
-			Element headerElement = new Element("header");
-			// TODO: generate XML
-			headerElement.setAttribute("rid", getRecipientDeviceId());
-			headerElement.setContent(Base64.encodeToString(getContents(), Base64.DEFAULT));
-			return headerElement;
+		public String getFingerprint() {
+			return fingerprint;
 		}
 	}
 
-	public static class XmppAxolotlPlaintextMessage {
-		private final AxolotlService.XmppAxolotlSession session;
-		private final String plaintext;
+	public static class XmppAxolotlKeyTransportMessage {
 		private final String fingerprint;
+		private final byte[] key;
+		private final byte[] iv;
 
-		public XmppAxolotlPlaintextMessage(AxolotlService.XmppAxolotlSession session, String plaintext, String fingerprint) {
-			this.session = session;
-			this.plaintext = plaintext;
+		public XmppAxolotlKeyTransportMessage(String fingerprint, byte[] key, byte[] iv) {
 			this.fingerprint = fingerprint;
+			this.key = key;
+			this.iv = iv;
 		}
 
-		public String getPlaintext() {
-			return plaintext;
+		public String getFingerprint() {
+			return fingerprint;
 		}
 
-		public AxolotlService.XmppAxolotlSession getSession() {
-			return session;
+		public byte[] getKey() {
+			return key;
 		}
 
-		public String getFingerprint() {
-			return fingerprint;
+		public byte[] getIv() {
+			return iv;
 		}
 	}
 
-	public XmppAxolotlMessage(Jid from, Element axolotlMessage) {
+	private XmppAxolotlMessage(final Element axolotlMessage, final Jid from) throws IllegalArgumentException {
 		this.from = from;
-		this.sourceDeviceId = Integer.parseInt(axolotlMessage.getAttribute("id"));
-		this.headers = new HashSet<>();
-		for(Element child:axolotlMessage.getChildren()) {
-			switch(child.getName()) {
-				case "header":
-					headers.add(new XmppAxolotlMessageHeader(child));
+		Element header = axolotlMessage.findChild(HEADER);
+		this.sourceDeviceId = Integer.parseInt(header.getAttribute(SOURCEID));
+		List<Element> keyElements = header.getChildren();
+		this.keys = new HashMap<>(keyElements.size());
+		for (Element keyElement : keyElements) {
+			switch (keyElement.getName()) {
+				case KEYTAG:
+					try {
+						Integer recipientId = Integer.parseInt(keyElement.getAttribute(REMOTEID));
+						byte[] key = Base64.decode(keyElement.getContent(), Base64.DEFAULT);
+						this.keys.put(recipientId, key);
+					} catch (NumberFormatException e) {
+						throw new IllegalArgumentException(e);
+					}
 					break;
-				case "message":
-					iv = Base64.decode(child.getAttribute("iv"),Base64.DEFAULT);
-					ciphertext = Base64.decode(child.getContent(),Base64.DEFAULT);
+				case IVTAG:
+					if (this.iv != null) {
+						throw new IllegalArgumentException("Duplicate iv entry");
+					}
+					iv = Base64.decode(keyElement.getContent(), Base64.DEFAULT);
 					break;
 				default:
+					Log.w(Config.LOGTAG, "Unexpected element in header: " + keyElement.toString());
 					break;
 			}
 		}
+		Element payloadElement = axolotlMessage.findChild(PAYLOAD);
+		if (payloadElement != null) {
+			ciphertext = Base64.decode(payloadElement.getContent(), Base64.DEFAULT);
+		}
 	}
 
-	public XmppAxolotlMessage(Jid from, int sourceDeviceId, String plaintext) throws CryptoFailedException{
+	public XmppAxolotlMessage(Jid from, int sourceDeviceId) {
 		this.from = from;
 		this.sourceDeviceId = sourceDeviceId;
-		this.headers = new HashSet<>();
-		this.encrypt(plaintext);
+		this.keys = new HashMap<>();
+		this.iv = generateIv();
+		this.innerKey = generateKey();
 	}
 
-	private void encrypt(String plaintext) throws CryptoFailedException {
+	public static XmppAxolotlMessage fromElement(Element element, Jid from) {
+		return new XmppAxolotlMessage(element, from);
+	}
+
+	private static byte[] generateKey() {
 		try {
-			KeyGenerator generator = KeyGenerator.getInstance("AES");
+			KeyGenerator generator = KeyGenerator.getInstance(KEYTYPE);
 			generator.init(128);
-			SecretKey secretKey = generator.generateKey();
-			SecureRandom random = new SecureRandom();
-			this.iv = new byte[16];
-			random.nextBytes(iv);
+			return generator.generateKey().getEncoded();
+		} catch (NoSuchAlgorithmException e) {
+			Log.e(Config.LOGTAG, e.getMessage());
+			return null;
+		}
+	}
+
+	private static byte[] generateIv() {
+		SecureRandom random = new SecureRandom();
+		byte[] iv = new byte[16];
+		random.nextBytes(iv);
+		return iv;
+	}
+
+	public void encrypt(String plaintext) throws CryptoFailedException {
+		try {
+			SecretKey secretKey = new SecretKeySpec(innerKey, KEYTYPE);
 			IvParameterSpec ivSpec = new IvParameterSpec(iv);
-			Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding", "BC");
+			Cipher cipher = Cipher.getInstance(CIPHERMODE, PROVIDER);
 			cipher.init(Cipher.ENCRYPT_MODE, secretKey, ivSpec);
 			this.innerKey = secretKey.getEncoded();
 			this.ciphertext = cipher.doFinal(plaintext.getBytes());
@@ -148,17 +179,14 @@ public class XmppAxolotlMessage {
 		return ciphertext;
 	}
 
-	public Set<XmppAxolotlMessageHeader> getHeaders() {
-		return headers;
-	}
-
-	public void addHeader(@Nullable XmppAxolotlMessageHeader header) {
-		if (header != null) {
-			headers.add(header);
+	public void addDevice(XmppAxolotlSession session) {
+		byte[] key = session.processSending(innerKey);
+		if (key != null) {
+			keys.put(session.getRemoteAddress().getDeviceId(), key);
 		}
 	}
 
-	public byte[] getInnerKey(){
+	public byte[] getInnerKey() {
 		return innerKey;
 	}
 
@@ -166,37 +194,55 @@ public class XmppAxolotlMessage {
 		return this.iv;
 	}
 
-	public Element toXml() {
-		// TODO: generate outer XML, add in header XML
-		Element message= new Element("axolotl_message", AxolotlService.PEP_PREFIX);
-		message.setAttribute("id", sourceDeviceId);
-		for(XmppAxolotlMessageHeader header: headers) {
-			message.addChild(header.toXml());
+	public Element toElement() {
+		Element encryptionElement = new Element(CONTAINERTAG, AxolotlService.PEP_PREFIX);
+		Element headerElement = encryptionElement.addChild(HEADER);
+		headerElement.setAttribute(SOURCEID, sourceDeviceId);
+		for (Map.Entry<Integer, byte[]> keyEntry : keys.entrySet()) {
+			Element keyElement = new Element(KEYTAG);
+			keyElement.setAttribute(REMOTEID, keyEntry.getKey());
+			keyElement.setContent(Base64.encodeToString(keyEntry.getValue(), Base64.DEFAULT));
+			headerElement.addChild(keyElement);
+		}
+		headerElement.addChild(IVTAG).setContent(Base64.encodeToString(iv, Base64.DEFAULT));
+		if (ciphertext != null) {
+			Element payload = encryptionElement.addChild(PAYLOAD);
+			payload.setContent(Base64.encodeToString(ciphertext, Base64.DEFAULT));
 		}
-		Element payload = message.addChild("message");
-		payload.setAttribute("iv",Base64.encodeToString(iv, Base64.DEFAULT));
-		payload.setContent(Base64.encodeToString(ciphertext,Base64.DEFAULT));
-		return message;
+		return encryptionElement;
 	}
 
+	private byte[] unpackKey(XmppAxolotlSession session, Integer sourceDeviceId) {
+		byte[] encryptedKey = keys.get(sourceDeviceId);
+		return (encryptedKey != null) ? session.processReceiving(encryptedKey) : null;
+	}
 
-	public XmppAxolotlPlaintextMessage decrypt(AxolotlService.XmppAxolotlSession session, byte[] key, String fingerprint) throws CryptoFailedException {
-		XmppAxolotlPlaintextMessage plaintextMessage = null;
-		try {
-
-			Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding", "BC");
-			SecretKeySpec keySpec = new SecretKeySpec(key, "AES");
-			IvParameterSpec ivSpec = new IvParameterSpec(iv);
-
-			cipher.init(Cipher.DECRYPT_MODE, keySpec, ivSpec);
-
-			String plaintext = new String(cipher.doFinal(ciphertext));
-			plaintextMessage = new XmppAxolotlPlaintextMessage(session, plaintext, fingerprint);
+	public XmppAxolotlKeyTransportMessage getParameters(XmppAxolotlSession session, Integer sourceDeviceId) {
+		byte[] key = unpackKey(session, sourceDeviceId);
+		return (key != null)
+				? new XmppAxolotlKeyTransportMessage(session.getFingerprint(), key, getIV())
+				: null;
+	}
 
-		} catch (NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException
-				| InvalidAlgorithmParameterException | IllegalBlockSizeException
-				| BadPaddingException | NoSuchProviderException e) {
-			throw new CryptoFailedException(e);
+	public XmppAxolotlPlaintextMessage decrypt(XmppAxolotlSession session, Integer sourceDeviceId) throws CryptoFailedException {
+		XmppAxolotlPlaintextMessage plaintextMessage = null;
+		byte[] key = unpackKey(session, sourceDeviceId);
+		if (key != null) {
+			try {
+				Cipher cipher = Cipher.getInstance(CIPHERMODE, PROVIDER);
+				SecretKeySpec keySpec = new SecretKeySpec(key, KEYTYPE);
+				IvParameterSpec ivSpec = new IvParameterSpec(iv);
+
+				cipher.init(Cipher.DECRYPT_MODE, keySpec, ivSpec);
+
+				String plaintext = new String(cipher.doFinal(ciphertext));
+				plaintextMessage = new XmppAxolotlPlaintextMessage(plaintext, session.getFingerprint());
+
+			} catch (NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException
+					| InvalidAlgorithmParameterException | IllegalBlockSizeException
+					| BadPaddingException | NoSuchProviderException e) {
+				throw new CryptoFailedException(e);
+			}
 		}
 		return plaintextMessage;
 	}