2 files changed, 380 insertions, 0 deletions
diff --git a/src/eu/siacs/conversations/crypto/OtrEngine.java b/src/eu/siacs/conversations/crypto/OtrEngine.java
new file mode 100644
index 00000000..eca01a73
--- /dev/null
+++ b/src/eu/siacs/conversations/crypto/OtrEngine.java
@@ -0,0 +1,232 @@
+package eu.siacs.conversations.crypto;
+
+import java.math.BigInteger;
+import java.security.KeyFactory;
+import java.security.KeyPair;
+import java.security.KeyPairGenerator;
+import java.security.NoSuchAlgorithmException;
+import java.security.PrivateKey;
+import java.security.PublicKey;
+import java.security.spec.DSAPrivateKeySpec;
+import java.security.spec.DSAPublicKeySpec;
+import java.security.spec.InvalidKeySpecException;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import android.content.Context;
+import android.util.Log;
+
+import eu.siacs.conversations.entities.Account;
+import eu.siacs.conversations.persistance.DatabaseBackend;
+import eu.siacs.conversations.xml.Element;
+import eu.siacs.conversations.xmpp.MessagePacket;
+
+import net.java.otr4j.OtrEngineHost;
+import net.java.otr4j.OtrException;
+import net.java.otr4j.OtrPolicy;
+import net.java.otr4j.OtrPolicyImpl;
+import net.java.otr4j.session.InstanceTag;
+import net.java.otr4j.session.SessionID;
+
+public class OtrEngine implements OtrEngineHost {
+	
+	private static final String LOGTAG = "xmppService";
+	
+	private Account account;
+	private OtrPolicy otrPolicy;
+	private KeyPair keyPair;
+	private Context context;
+
+	public OtrEngine(Context context, Account account) {
+		this.account = account;
+		this.otrPolicy = new OtrPolicyImpl();
+		this.otrPolicy.setAllowV1(false);
+		this.otrPolicy.setAllowV2(true);
+		this.otrPolicy.setAllowV3(true);
+		this.keyPair = loadKey(account.getKeys());
+	}
+	
+	private KeyPair loadKey(JSONObject keys) {
+		if (keys == null) {
+			return null;
+		}
+		try {
+			BigInteger x = new BigInteger(keys.getString("otr_x"),16);
+			BigInteger y = new BigInteger(keys.getString("otr_y"),16);
+			BigInteger p = new BigInteger(keys.getString("otr_p"),16);
+			BigInteger q = new BigInteger(keys.getString("otr_q"),16);
+			BigInteger g = new BigInteger(keys.getString("otr_g"),16);
+			KeyFactory keyFactory = KeyFactory.getInstance("DSA");
+			DSAPublicKeySpec pubKeySpec = new DSAPublicKeySpec(y, p, q, g);
+			DSAPrivateKeySpec privateKeySpec = new DSAPrivateKeySpec(x, p, q, g);
+			PublicKey publicKey = keyFactory.generatePublic(pubKeySpec);
+			PrivateKey privateKey = keyFactory.generatePrivate(privateKeySpec);
+			return new KeyPair(publicKey, privateKey);
+		} catch (JSONException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		} catch (NoSuchAlgorithmException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		} catch (InvalidKeySpecException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+		return null;
+	}
+	
+	private void saveKey() {
+		PublicKey publicKey = keyPair.getPublic();
+		PrivateKey privateKey = keyPair.getPrivate();
+		KeyFactory keyFactory;
+		try {
+			keyFactory = KeyFactory.getInstance("DSA");
+			DSAPrivateKeySpec privateKeySpec = keyFactory.getKeySpec(privateKey, DSAPrivateKeySpec.class);
+			DSAPublicKeySpec publicKeySpec = keyFactory.getKeySpec(publicKey, DSAPublicKeySpec.class);
+			this.account.setKey("otr_x",privateKeySpec.getX().toString(16));
+			this.account.setKey("otr_g",privateKeySpec.getG().toString(16));
+			this.account.setKey("otr_p",privateKeySpec.getP().toString(16));
+			this.account.setKey("otr_q",privateKeySpec.getQ().toString(16));
+			this.account.setKey("otr_y",publicKeySpec.getY().toString(16));
+		} catch (NoSuchAlgorithmException e) {
+			e.printStackTrace();
+		} catch (InvalidKeySpecException e) {
+			e.printStackTrace();
+		}
+		
+	}
+
+	@Override
+	public void askForSecret(SessionID arg0, InstanceTag arg1, String arg2) {
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void finishedSessionMessage(SessionID arg0, String arg1)
+			throws OtrException {
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public String getFallbackMessage(SessionID arg0) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public byte[] getLocalFingerprintRaw(SessionID arg0) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	public PublicKey getPublicKey() {
+		return this.keyPair.getPublic();
+	}
+	
+	@Override
+	public KeyPair getLocalKeyPair(SessionID arg0) throws OtrException {
+		if (this.keyPair==null) {
+			KeyPairGenerator kg;
+			try {
+			kg = KeyPairGenerator.getInstance("DSA");
+			this.keyPair = kg.genKeyPair();
+			this.saveKey();
+			DatabaseBackend.getInstance(context).updateAccount(account);
+			} catch (NoSuchAlgorithmException e) {
+				Log.d(LOGTAG,"error generating key pair "+e.getMessage());
+			}
+		}
+		return this.keyPair;
+	}
+
+	@Override
+	public String getReplyForUnreadableMessage(SessionID arg0) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public OtrPolicy getSessionPolicy(SessionID arg0) {
+		return otrPolicy;
+	}
+
+	@Override
+	public void injectMessage(SessionID session, String body) throws OtrException {
+		MessagePacket packet = new MessagePacket();
+		packet.setFrom(account.getFullJid()); //sender
+		packet.setTo(session.getAccountID()+"/"+session.getUserID()); //reciepient
+		packet.setBody(body);
+		Element privateTag = new Element("private");
+		privateTag.setAttribute("xmlns","urn:xmpp:carbons:2");
+		packet.addChild(privateTag);
+		packet.setType(MessagePacket.TYPE_CHAT);
+		account.getXmppConnection().sendMessagePacket(packet);
+	}
+
+	@Override
+	public void messageFromAnotherInstanceReceived(SessionID arg0) {
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void multipleInstancesDetected(SessionID arg0) {
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void requireEncryptedMessage(SessionID arg0, String arg1)
+			throws OtrException {
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void showError(SessionID arg0, String arg1) throws OtrException {
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void smpAborted(SessionID arg0) throws OtrException {
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void smpError(SessionID arg0, int arg1, boolean arg2)
+			throws OtrException {
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void unencryptedMessageReceived(SessionID arg0, String arg1)
+			throws OtrException {
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void unreadableMessageReceived(SessionID arg0) throws OtrException {
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void unverify(SessionID arg0, String arg1) {
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void verify(SessionID arg0, String arg1, boolean arg2) {
+		// TODO Auto-generated method stub
+
+	}
+
+}
diff --git a/src/eu/siacs/conversations/crypto/PgpEngine.java b/src/eu/siacs/conversations/crypto/PgpEngine.java
new file mode 100644
index 00000000..ba000c04
--- /dev/null
+++ b/src/eu/siacs/conversations/crypto/PgpEngine.java
@@ -0,0 +1,148 @@
+package eu.siacs.conversations.crypto;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.InputStream;
+
+import org.openintents.openpgp.OpenPgpError;
+import org.openintents.openpgp.OpenPgpSignatureResult;
+import org.openintents.openpgp.util.OpenPgpApi;
+import org.openintents.openpgp.util.OpenPgpConstants;
+
+import android.app.PendingIntent;
+import android.os.Bundle;
+import android.util.Log;
+
+public class PgpEngine {
+	private OpenPgpApi api;
+
+	public PgpEngine(OpenPgpApi api) {
+		this.api = api;
+	}
+
+	public String decrypt(String message) throws UserInputRequiredException,
+			OpenPgpException {
+		InputStream is = new ByteArrayInputStream(message.getBytes());
+		ByteArrayOutputStream os = new ByteArrayOutputStream();
+		Bundle result = api.decryptAndVerify(is, os);
+		switch (result.getInt(OpenPgpConstants.RESULT_CODE)) {
+		case OpenPgpConstants.RESULT_CODE_SUCCESS:
+			return os.toString();
+		case OpenPgpConstants.RESULT_CODE_USER_INTERACTION_REQUIRED:
+			throw new UserInputRequiredException(
+					(PendingIntent) result
+							.getParcelable(OpenPgpConstants.RESULT_INTENT));
+		case OpenPgpConstants.RESULT_CODE_ERROR:
+			throw new OpenPgpException(
+					(OpenPgpError) result
+							.getParcelable(OpenPgpConstants.RESULT_ERRORS));
+		default:
+			return null;
+		}
+	}
+
+	public String encrypt(long keyId, String message) {
+		Bundle params = new Bundle();
+		params.putBoolean(OpenPgpConstants.PARAMS_REQUEST_ASCII_ARMOR, true);
+		long[] keyIds = { keyId };
+		params.putLongArray(OpenPgpConstants.PARAMS_KEY_IDS, keyIds);
+
+		InputStream is = new ByteArrayInputStream(message.getBytes());
+		ByteArrayOutputStream os = new ByteArrayOutputStream();
+		Bundle result = api.encrypt(params, is, os);
+		StringBuilder encryptedMessageBody = new StringBuilder();
+		String[] lines = os.toString().split("\n");
+		for (int i = 3; i < lines.length - 1; ++i) {
+			encryptedMessageBody.append(lines[i].trim());
+		}
+		return encryptedMessageBody.toString();
+	}
+
+	public long fetchKeyId(String status, String signature)
+			throws OpenPgpException {
+		StringBuilder pgpSig = new StringBuilder();
+		pgpSig.append("-----BEGIN PGP SIGNED MESSAGE-----");
+		pgpSig.append('\n');
+		pgpSig.append("Hash: SHA1");
+		pgpSig.append('\n');
+		pgpSig.append('\n');
+		pgpSig.append(status);
+		pgpSig.append('\n');
+		pgpSig.append("-----BEGIN PGP SIGNATURE-----");
+		pgpSig.append('\n');
+		pgpSig.append('\n');
+		pgpSig.append(signature.replace("\n", "").trim());
+		pgpSig.append('\n');
+		pgpSig.append("-----END PGP SIGNATURE-----");
+		Bundle params = new Bundle();
+		params.putBoolean(OpenPgpConstants.PARAMS_REQUEST_ASCII_ARMOR, true);
+		InputStream is = new ByteArrayInputStream(pgpSig.toString().getBytes());
+		ByteArrayOutputStream os = new ByteArrayOutputStream();
+		Bundle result = api.decryptAndVerify(params, is, os);
+		switch (result.getInt(OpenPgpConstants.RESULT_CODE)) {
+		case OpenPgpConstants.RESULT_CODE_SUCCESS:
+			OpenPgpSignatureResult sigResult = result
+					.getParcelable(OpenPgpConstants.RESULT_SIGNATURE);
+			return sigResult.getKeyId();
+		case OpenPgpConstants.RESULT_CODE_USER_INTERACTION_REQUIRED:
+			break;
+		case OpenPgpConstants.RESULT_CODE_ERROR:
+			throw new OpenPgpException(
+					(OpenPgpError) result
+							.getParcelable(OpenPgpConstants.RESULT_ERRORS));
+		}
+		return 0;
+	}
+
+	public String generateSignature(String status)
+			throws UserInputRequiredException {
+		Bundle params = new Bundle();
+		params.putBoolean(OpenPgpConstants.PARAMS_REQUEST_ASCII_ARMOR, true);
+		InputStream is = new ByteArrayInputStream(status.getBytes());
+		ByteArrayOutputStream os = new ByteArrayOutputStream();
+		Bundle result = api.sign(params, is, os);
+		StringBuilder signatureBuilder = new StringBuilder();
+		switch (result.getInt(OpenPgpConstants.RESULT_CODE)) {
+		case OpenPgpConstants.RESULT_CODE_SUCCESS:
+			String[] lines = os.toString().split("\n");
+			for (int i = 7; i < lines.length - 1; ++i) {
+				signatureBuilder.append(lines[i].trim());
+			}
+			break;
+		case OpenPgpConstants.RESULT_CODE_USER_INTERACTION_REQUIRED:
+			UserInputRequiredException exception = new UserInputRequiredException(
+					(PendingIntent) result
+							.getParcelable(OpenPgpConstants.RESULT_INTENT));
+			throw exception;
+		case OpenPgpConstants.RESULT_CODE_ERROR:
+			break;
+		}
+		return signatureBuilder.toString();
+	}
+
+	public class UserInputRequiredException extends Exception {
+		private static final long serialVersionUID = -6913480043269132016L;
+		private PendingIntent pi;
+
+		public UserInputRequiredException(PendingIntent pi) {
+			this.pi = pi;
+		}
+
+		public PendingIntent getPendingIntent() {
+			return this.pi;
+		}
+	}
+
+	public class OpenPgpException extends Exception {
+		private static final long serialVersionUID = -7324789703473056077L;
+		private OpenPgpError error;
+
+		public OpenPgpException(OpenPgpError openPgpError) {
+			this.error = openPgpError;
+		}
+
+		public OpenPgpError getOpenPgpError() {
+			return this.error;
+		}
+	}
+}