package de.pixart.messenger.crypto; import android.util.Log; import net.java.otr4j.OtrEngineHost; import net.java.otr4j.OtrException; import net.java.otr4j.OtrPolicy; import net.java.otr4j.OtrPolicyImpl; import net.java.otr4j.crypto.OtrCryptoEngineImpl; import net.java.otr4j.crypto.OtrCryptoException; import net.java.otr4j.session.FragmenterInstructions; import net.java.otr4j.session.InstanceTag; import net.java.otr4j.session.SessionID; import org.json.JSONException; import org.json.JSONObject; 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 de.pixart.messenger.Config; import de.pixart.messenger.entities.Account; import de.pixart.messenger.entities.Conversation; import de.pixart.messenger.generator.MessageGenerator; import de.pixart.messenger.services.XmppConnectionService; import de.pixart.messenger.xmpp.chatstate.ChatState; import de.pixart.messenger.xmpp.jid.OtrJidHelper; import de.pixart.messenger.xmpp.stanzas.MessagePacket; import rocks.xmpp.addr.Jid; public class OtrService extends OtrCryptoEngineImpl implements OtrEngineHost { private Account account; private OtrPolicy otrPolicy; private KeyPair keyPair; private XmppConnectionService mXmppConnectionService; public OtrService(XmppConnectionService service, 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()); this.mXmppConnectionService = service; } private KeyPair loadKey(final JSONObject keys) { if (keys == null) { return null; } synchronized (keys) { 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) { return null; } catch (NoSuchAlgorithmException e) { return null; } catch (InvalidKeySpecException e) { 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 (final NoSuchAlgorithmException e) { e.printStackTrace(); } catch (final InvalidKeySpecException e) { e.printStackTrace(); } } @Override public void askForSecret(SessionID id, InstanceTag instanceTag, String question) { try { final Jid jid = OtrJidHelper.fromSessionID(id); Conversation conversation = this.mXmppConnectionService.find(this.account, jid); if (conversation != null) { conversation.smp().hint = question; conversation.smp().status = Conversation.Smp.STATUS_CONTACT_REQUESTED; mXmppConnectionService.updateConversationUi(); } } catch (IllegalArgumentException e) { Log.d(Config.LOGTAG, account.getJid().asBareJid() + ": smp in invalid session " + id.toString()); } } @Override public void finishedSessionMessage(SessionID arg0, String arg1) throws OtrException { } @Override public String getFallbackMessage(SessionID arg0) { return MessageGenerator.OTR_FALLBACK_MESSAGE; } @Override public byte[] getLocalFingerprintRaw(SessionID arg0) { try { return getFingerprintRaw(getPublicKey()); } catch (OtrCryptoException e) { return null; } } public PublicKey getPublicKey() { if (this.keyPair == null) { return null; } 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(); mXmppConnectionService.databaseBackend.updateAccount(account); } catch (NoSuchAlgorithmException e) { Log.d(Config.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.getJid()); if (session.getUserID().isEmpty()) { packet.setAttribute("to", session.getAccountID()); } else { packet.setAttribute("to", session.getAccountID() + "/" + session.getUserID()); } packet.setBody(body); MessageGenerator.addMessageHints(packet); try { Jid jid = OtrJidHelper.fromSessionID(session); Conversation conversation = mXmppConnectionService.find(account, jid); if (conversation != null && conversation.setOutgoingChatState(Config.DEFAULT_CHAT_STATE)) { if (mXmppConnectionService.sendChatStates()) { packet.addChild(ChatState.toElement(conversation.getOutgoingChatState())); } } } catch (final IllegalArgumentException ignored) { } packet.setType(MessagePacket.TYPE_CHAT); packet.addChild("encryption", "urn:xmpp:eme:0").setAttribute("namespace", "urn:xmpp:otr:0"); account.getXmppConnection().sendMessagePacket(packet); } @Override public void messageFromAnotherInstanceReceived(SessionID session) { sendOtrErrorMessage(session, "Message from another OTR-instance received"); } @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 { Log.d(Config.LOGTAG, "show error"); } @Override public void smpAborted(SessionID id) throws OtrException { setSmpStatus(id, Conversation.Smp.STATUS_NONE); } private void setSmpStatus(SessionID id, int status) { try { final Jid jid = OtrJidHelper.fromSessionID(id); Conversation conversation = this.mXmppConnectionService.find(this.account, jid); if (conversation != null) { conversation.smp().status = status; mXmppConnectionService.updateConversationUi(); } } catch (final IllegalArgumentException ignored) { } } @Override public void smpError(SessionID id, int arg1, boolean arg2) throws OtrException { setSmpStatus(id, Conversation.Smp.STATUS_NONE); } @Override public void unencryptedMessageReceived(SessionID arg0, String arg1) throws OtrException { throw new OtrException(new Exception("unencrypted message received")); } @Override public void unreadableMessageReceived(SessionID session) throws OtrException { Log.d(Config.LOGTAG, "unreadable message received"); sendOtrErrorMessage(session, "You sent me an unreadable OTR-encrypted message"); } public void sendOtrErrorMessage(SessionID session, String errorText) { try { Jid jid = OtrJidHelper.fromSessionID(session); Conversation conversation = mXmppConnectionService.find(account, jid); String id = conversation == null ? null : conversation.getLastReceivedOtrMessageId(); if (id != null) { MessagePacket packet = mXmppConnectionService.getMessageGenerator() .generateOtrError(jid, id, errorText); packet.setFrom(account.getJid()); mXmppConnectionService.sendMessagePacket(account, packet); Log.d(Config.LOGTAG, packet.toString()); Log.d(Config.LOGTAG, account.getJid().asBareJid().toString() + ": unreadable OTR message in " + conversation.getName()); } } catch (IllegalArgumentException e) { return; } } @Override public void unverify(SessionID id, String arg1) { setSmpStatus(id, Conversation.Smp.STATUS_FAILED); } @Override public void verify(SessionID id, String fingerprint, boolean approved) { Log.d(Config.LOGTAG, "OtrService.verify(" + id.toString() + "," + fingerprint + "," + String.valueOf(approved) + ")"); try { final Jid jid = OtrJidHelper.fromSessionID(id); Conversation conversation = this.mXmppConnectionService.find(this.account, jid); if (conversation != null) { if (approved) { conversation.getContact().addOtrFingerprint(fingerprint); } conversation.smp().hint = null; conversation.smp().status = Conversation.Smp.STATUS_VERIFIED; mXmppConnectionService.updateConversationUi(); mXmppConnectionService.syncRosterToDisk(conversation.getAccount()); } } catch (final IllegalArgumentException ignored) { } } @Override public FragmenterInstructions getFragmenterInstructions(SessionID sessionID) { return null; } }