1 /*

     2  * otr4j, the open source java otr library.

     3  *

     4  * Distributable under LGPL license.

     5  * See terms of license at gnu.org.

     6  */

     7 

     8 package net.java.otr4j.session;

     9 

    10 import java.io.ByteArrayInputStream;

    11 import java.io.ByteArrayOutputStream;

    12 import java.io.IOException;

    13 import java.io.UnsupportedEncodingException;

    14 import java.nio.ByteBuffer;

    15 import java.security.KeyPair;

    16 import java.security.PublicKey;

    17 import java.util.Arrays;

    18 import java.util.List;

    19 import java.util.Vector;

    20 import java.util.logging.Logger;

    21 import javax.crypto.interfaces.DHPublicKey;

    22 

    23 import net.java.otr4j.OtrEngineHost;

    24 import net.java.otr4j.OtrEngineListener;

    25 import net.java.otr4j.OtrException;

    26 import net.java.otr4j.OtrPolicy;

    27 import net.java.otr4j.crypto.OtrCryptoEngine;

    28 import net.java.otr4j.crypto.OtrCryptoEngineImpl;

    29 import net.java.otr4j.io.OtrInputStream;

    30 import net.java.otr4j.io.OtrOutputStream;

    31 import net.java.otr4j.io.SerializationConstants;

    32 import net.java.otr4j.io.SerializationUtils;

    33 import net.java.otr4j.io.messages.DataMessage;

    34 import net.java.otr4j.io.messages.AbstractEncodedMessage;

    35 import net.java.otr4j.io.messages.ErrorMessage;

    36 import net.java.otr4j.io.messages.AbstractMessage;

    37 import net.java.otr4j.io.messages.MysteriousT;

    38 import net.java.otr4j.io.messages.PlainTextMessage;

    39 import net.java.otr4j.io.messages.QueryMessage;

    40 

    41 /**

    42  * 

    43  * @author George Politis

    44  */

    45 public class SessionImpl implements Session {

    46 

    47 	/**

    48 	 * 

    49 	 * @author George Politis

    50 	 * 

    51 	 */

    52 	class TLV {

    53 		public TLV(int type, byte[] value) {

    54 			this.setType(type);

    55 			this.setValue(value);

    56 		}

    57 

    58 		public void setType(int type) {

    59 			this.type = type;

    60 		}

    61 

    62 		public int getType() {

    63 			return type;

    64 		}

    65 

    66 		public void setValue(byte[] value) {

    67 			this.value = value;

    68 		}

    69 

    70 		public byte[] getValue() {

    71 			return value;

    72 		}

    73 

    74 		private int type;

    75 		private byte[] value;

    76 	}

    77 

    78 	private SessionID sessionID;

    79 	private OtrEngineHost listener;

    80 	private SessionStatus sessionStatus;

    81 	private AuthContext authContext;

    82 	private SessionKeys[][] sessionKeys;

    83 	private Vector<byte[]> oldMacKeys;

    84 	private static Logger logger = Logger

    85 			.getLogger(SessionImpl.class.getName());

    86 

    87 	public SessionImpl(SessionID sessionID, OtrEngineHost listener) {

    88 

    89 		this.setSessionID(sessionID);

    90 		this.setListener(listener);

    91 

    92 		// client application calls OtrEngine.getSessionStatus()

    93 		// -> create new session if it does not exist, end up here

    94 		// -> setSessionStatus() fires statusChangedEvent

    95 		// -> client application calls OtrEngine.getSessionStatus()

    96 		this.sessionStatus = SessionStatus.PLAINTEXT;

    97 	}

    98 

    99 	private SessionKeys getEncryptionSessionKeys() {

   100 		logger.finest("Getting encryption keys");

   101 		return getSessionKeysByIndex(SessionKeys.Previous, SessionKeys.Current);

   102 	}

   103 

   104 	private SessionKeys getMostRecentSessionKeys() {

   105 		logger.finest("Getting most recent keys.");

   106 		return getSessionKeysByIndex(SessionKeys.Current, SessionKeys.Current);

   107 	}

   108 

   109 	private SessionKeys getSessionKeysByID(int localKeyID, int remoteKeyID) {

   110 		logger

   111 				.finest("Searching for session keys with (localKeyID, remoteKeyID) = ("

   112 						+ localKeyID + "," + remoteKeyID + ")");

   113 

   114 		for (int i = 0; i < getSessionKeys().length; i++) {

   115 			for (int j = 0; j < getSessionKeys()[i].length; j++) {

   116 				SessionKeys current = getSessionKeysByIndex(i, j);

   117 				if (current.getLocalKeyID() == localKeyID

   118 						&& current.getRemoteKeyID() == remoteKeyID) {

   119 					logger.finest("Matching keys found.");

   120 					return current;

   121 				}

   122 			}

   123 		}

   124 

   125 		return null;

   126 	}

   127 

   128 	private SessionKeys getSessionKeysByIndex(int localKeyIndex,

   129 			int remoteKeyIndex) {

   130 		if (getSessionKeys()[localKeyIndex][remoteKeyIndex] == null)

   131 			getSessionKeys()[localKeyIndex][remoteKeyIndex] = new SessionKeysImpl(

   132 					localKeyIndex, remoteKeyIndex);

   133 

   134 		return getSessionKeys()[localKeyIndex][remoteKeyIndex];

   135 	}

   136 

   137 	private void rotateRemoteSessionKeys(DHPublicKey pubKey)

   138 			throws OtrException {

   139 

   140 		logger.finest("Rotating remote keys.");

   141 		SessionKeys sess1 = getSessionKeysByIndex(SessionKeys.Current,

   142 				SessionKeys.Previous);

   143 		if (sess1.getIsUsedReceivingMACKey()) {

   144 			logger

   145 					.finest("Detected used Receiving MAC key. Adding to old MAC keys to reveal it.");

   146 			getOldMacKeys().add(sess1.getReceivingMACKey());

   147 		}

   148 

   149 		SessionKeys sess2 = getSessionKeysByIndex(SessionKeys.Previous,

   150 				SessionKeys.Previous);

   151 		if (sess2.getIsUsedReceivingMACKey()) {

   152 			logger

   153 					.finest("Detected used Receiving MAC key. Adding to old MAC keys to reveal it.");

   154 			getOldMacKeys().add(sess2.getReceivingMACKey());

   155 		}

   156 

   157 		SessionKeys sess3 = getSessionKeysByIndex(SessionKeys.Current,

   158 				SessionKeys.Current);

   159 		sess1

   160 				.setRemoteDHPublicKey(sess3.getRemoteKey(), sess3

   161 						.getRemoteKeyID());

   162 

   163 		SessionKeys sess4 = getSessionKeysByIndex(SessionKeys.Previous,

   164 				SessionKeys.Current);

   165 		sess2

   166 				.setRemoteDHPublicKey(sess4.getRemoteKey(), sess4

   167 						.getRemoteKeyID());

   168 

   169 		sess3.setRemoteDHPublicKey(pubKey, sess3.getRemoteKeyID() + 1);

   170 		sess4.setRemoteDHPublicKey(pubKey, sess4.getRemoteKeyID() + 1);

   171 	}

   172 

   173 	private void rotateLocalSessionKeys() throws OtrException {

   174 

   175 		logger.finest("Rotating local keys.");

   176 		SessionKeys sess1 = getSessionKeysByIndex(SessionKeys.Previous,

   177 				SessionKeys.Current);

   178 		if (sess1.getIsUsedReceivingMACKey()) {

   179 			logger

   180 					.finest("Detected used Receiving MAC key. Adding to old MAC keys to reveal it.");

   181 			getOldMacKeys().add(sess1.getReceivingMACKey());

   182 		}

   183 

   184 		SessionKeys sess2 = getSessionKeysByIndex(SessionKeys.Previous,

   185 				SessionKeys.Previous);

   186 		if (sess2.getIsUsedReceivingMACKey()) {

   187 			logger

   188 					.finest("Detected used Receiving MAC key. Adding to old MAC keys to reveal it.");

   189 			getOldMacKeys().add(sess2.getReceivingMACKey());

   190 		}

   191 

   192 		SessionKeys sess3 = getSessionKeysByIndex(SessionKeys.Current,

   193 				SessionKeys.Current);

   194 		sess1.setLocalPair(sess3.getLocalPair(), sess3.getLocalKeyID());

   195 		SessionKeys sess4 = getSessionKeysByIndex(SessionKeys.Current,

   196 				SessionKeys.Previous);

   197 		sess2.setLocalPair(sess4.getLocalPair(), sess4.getLocalKeyID());

   198 

   199 		KeyPair newPair = new OtrCryptoEngineImpl().generateDHKeyPair();

   200 		sess3.setLocalPair(newPair, sess3.getLocalKeyID() + 1);

   201 		sess4.setLocalPair(newPair, sess4.getLocalKeyID() + 1);

   202 	}

   203 

   204 	private byte[] collectOldMacKeys() {

   205 		logger.finest("Collecting old MAC keys to be revealed.");

   206 		int len = 0;

   207 		for (int i = 0; i < getOldMacKeys().size(); i++)

   208 			len += getOldMacKeys().get(i).length;

   209 

   210 		ByteBuffer buff = ByteBuffer.allocate(len);

   211 		for (int i = 0; i < getOldMacKeys().size(); i++)

   212 			buff.put(getOldMacKeys().get(i));

   213 

   214 		getOldMacKeys().clear();

   215 		return buff.array();

   216 	}

   217 

   218 	private void setSessionStatus(SessionStatus sessionStatus)

   219 			throws OtrException {

   220 

   221 		if (sessionStatus == this.sessionStatus)

   222 			return;

   223 

   224 		switch (sessionStatus) {

   225 		case ENCRYPTED:

   226 			AuthContext auth = this.getAuthContext();

   227 			logger.finest("Setting most recent session keys from auth.");

   228 			for (int i = 0; i < this.getSessionKeys()[0].length; i++) {

   229 				SessionKeys current = getSessionKeysByIndex(0, i);

   230 				current.setLocalPair(auth.getLocalDHKeyPair(), 1);

   231 				current.setRemoteDHPublicKey(auth.getRemoteDHPublicKey(), 1);

   232 				current.setS(auth.getS());

   233 			}

   234 

   235 			KeyPair nextDH = new OtrCryptoEngineImpl().generateDHKeyPair();

   236 			for (int i = 0; i < this.getSessionKeys()[1].length; i++) {

   237 				SessionKeys current = getSessionKeysByIndex(1, i);

   238 				current.setRemoteDHPublicKey(auth.getRemoteDHPublicKey(), 1);

   239 				current.setLocalPair(nextDH, 2);

   240 			}

   241 

   242 			this.setRemotePublicKey(auth.getRemoteLongTermPublicKey());

   243 

   244 			auth.reset();

   245 			break;

   246 		}

   247 

   248 		this.sessionStatus = sessionStatus;

   249 

   250 		for (OtrEngineListener l : this.listeners)

   251 			l.sessionStatusChanged(getSessionID());

   252 	}

   253 

   254 	/*

   255 	 * (non-Javadoc)

   256 	 * 

   257 	 * @see net.java.otr4j.session.ISession#getSessionStatus()

   258 	 */

   259 

   260 	public SessionStatus getSessionStatus() {

   261 		return sessionStatus;

   262 	}

   263 

   264 	private void setSessionID(SessionID sessionID) {

   265 		this.sessionID = sessionID;

   266 	}

   267 

   268 	/*

   269 	 * (non-Javadoc)

   270 	 * 

   271 	 * @see net.java.otr4j.session.ISession#getSessionID()

   272 	 */

   273 	public SessionID getSessionID() {

   274 		return sessionID;

   275 	}

   276 

   277 	private void setListener(OtrEngineHost listener) {

   278 		this.listener = listener;

   279 	}

   280 

   281 	private OtrEngineHost getListener() {

   282 		return listener;

   283 	}

   284 

   285 	private SessionKeys[][] getSessionKeys() {

   286 		if (sessionKeys == null)

   287 			sessionKeys = new SessionKeys[2][2];

   288 		return sessionKeys;

   289 	}

   290 

   291 	private AuthContext getAuthContext() {

   292 		if (authContext == null)

   293 			authContext = new AuthContextImpl(this);

   294 		return authContext;

   295 	}

   296 

   297 	private Vector<byte[]> getOldMacKeys() {

   298 		if (oldMacKeys == null)

   299 			oldMacKeys = new Vector<byte[]>();

   300 		return oldMacKeys;

   301 	}

   302 

   303 	/*

   304 	 * (non-Javadoc)

   305 	 * 

   306 	 * @see

   307 	 * net.java.otr4j.session.ISession#handleReceivingMessage(java.lang.String)

   308 	 */

   309 	public String transformReceiving(String msgText) throws OtrException {

   310 		OtrPolicy policy = getSessionPolicy();

   311 		if (!policy.getAllowV1() && !policy.getAllowV2()) {

   312 			logger

   313 					.finest("Policy does not allow neither V1 not V2, ignoring message.");

   314 			return msgText;

   315 		}

   316 

   317 		AbstractMessage m;

   318 		try {

   319 			m = SerializationUtils.toMessage(msgText);

   320 		} catch (IOException e) {

   321 			throw new OtrException(e);

   322 		}

   323 

   324 		switch (m.messageType) {

   325 		case AbstractEncodedMessage.MESSAGE_DATA:

   326 			return handleDataMessage((DataMessage) m);

   327 		case AbstractMessage.MESSAGE_ERROR:

   328 			handleErrorMessage((ErrorMessage) m);

   329 			return null;

   330 		case AbstractMessage.MESSAGE_PLAINTEXT:

   331 			return handlePlainTextMessage((PlainTextMessage) m);

   332 		case AbstractMessage.MESSAGE_QUERY:

   333 			handleQueryMessage((QueryMessage) m);

   334 			return null;

   335 		case AbstractEncodedMessage.MESSAGE_DH_COMMIT:

   336 		case AbstractEncodedMessage.MESSAGE_DHKEY:

   337 		case AbstractEncodedMessage.MESSAGE_REVEALSIG:

   338 		case AbstractEncodedMessage.MESSAGE_SIGNATURE:

   339 			AuthContext auth = this.getAuthContext();

   340 			auth.handleReceivingMessage(m);

   341 

   342 			if (auth.getIsSecure()) {

   343 				this.setSessionStatus(SessionStatus.ENCRYPTED);

   344 				logger.finest("Gone Secure.");

   345 			}

   346 			return null;

   347 		default:

   348 			throw new UnsupportedOperationException(

   349 					"Received an uknown message type.");

   350 		}

   351 	}

   352 

   353 	private void handleQueryMessage(QueryMessage queryMessage)

   354 			throws OtrException {

   355 		logger.finest(getSessionID().getAccountID()

   356 				+ " received a query message from "

   357 				+ getSessionID().getUserID() + " throught "

   358 				+ getSessionID().getProtocolName() + ".");

   359 

   360 		setSessionStatus(SessionStatus.PLAINTEXT);

   361 

   362 		OtrPolicy policy = getSessionPolicy();

   363 		if (queryMessage.versions.contains(2) && policy.getAllowV2()) {

   364 			logger.finest("Query message with V2 support found.");

   365 			getAuthContext().respondV2Auth();

   366 		} else if (queryMessage.versions.contains(1) && policy.getAllowV1()) {

   367 			throw new UnsupportedOperationException();

   368 		}

   369 	}

   370 

   371 	private void handleErrorMessage(ErrorMessage errorMessage)

   372 			throws OtrException {

   373 		logger.finest(getSessionID().getAccountID()

   374 				+ " received an error message from "

   375 				+ getSessionID().getUserID() + " throught "

   376 				+ getSessionID().getUserID() + ".");

   377 

   378 		getListener().showError(this.getSessionID(), errorMessage.error);

   379 

   380 		OtrPolicy policy = getSessionPolicy();

   381 		if (policy.getErrorStartAKE()) {

   382 			logger.finest("Error message starts AKE.");

   383 			Vector<Integer> versions = new Vector<Integer>();

   384 			if (policy.getAllowV1())

   385 				versions.add(1);

   386 

   387 			if (policy.getAllowV2())

   388 				versions.add(2);

   389 

   390 			logger.finest("Sending Query");

   391 			injectMessage(new QueryMessage(versions));

   392 		}

   393 	}

   394 

   395 	private String handleDataMessage(DataMessage data) throws OtrException {

   396 		logger.finest(getSessionID().getAccountID()

   397 				+ " received a data message from " + getSessionID().getUserID()

   398 				+ ".");

   399 

   400 		switch (this.getSessionStatus()) {

   401 		case ENCRYPTED:

   402 			logger

   403 					.finest("Message state is ENCRYPTED. Trying to decrypt message.");

   404 

   405 			// Find matching session keys.

   406 			int senderKeyID = data.senderKeyID;

   407 			int receipientKeyID = data.recipientKeyID;

   408 			SessionKeys matchingKeys = this.getSessionKeysByID(receipientKeyID,

   409 					senderKeyID);

   410 

   411 			if (matchingKeys == null) {

   412 				logger.finest("No matching keys found.");

   413 				return null;

   414 			}

   415 

   416 			// Verify received MAC with a locally calculated MAC.

   417 			logger

   418 					.finest("Transforming T to byte[] to calculate it's HmacSHA1.");

   419 

   420 			byte[] serializedT;

   421 			try {

   422 				serializedT = SerializationUtils.toByteArray(data.getT());

   423 			} catch (IOException e) {

   424 				throw new OtrException(e);

   425 			}

   426 

   427 			OtrCryptoEngine otrCryptoEngine = new OtrCryptoEngineImpl();

   428 

   429 			byte[] computedMAC = otrCryptoEngine.sha1Hmac(serializedT,

   430 					matchingKeys.getReceivingMACKey(),

   431 					SerializationConstants.TYPE_LEN_MAC);

   432 

   433 			if (!Arrays.equals(computedMAC, data.mac)) {

   434 				logger.finest("MAC verification failed, ignoring message");

   435 				return null;

   436 			}

   437 

   438 			logger.finest("Computed HmacSHA1 value matches sent one.");

   439 

   440 			// Mark this MAC key as old to be revealed.

   441 			matchingKeys.setIsUsedReceivingMACKey(true);

   442 

   443 			matchingKeys.setReceivingCtr(data.ctr);

   444 

   445 			byte[] dmc = otrCryptoEngine.aesDecrypt(matchingKeys

   446 					.getReceivingAESKey(), matchingKeys.getReceivingCtr(),

   447 					data.encryptedMessage);

   448 			String decryptedMsgContent;

   449 			try {

   450 				// Expect bytes to be text encoded in UTF-8.

   451 				decryptedMsgContent = new String(dmc, "UTF-8");

   452 			} catch (UnsupportedEncodingException e) {

   453 				throw new OtrException(e);

   454 			}

   455 

   456 			logger.finest("Decrypted message: \"" + decryptedMsgContent + "\"");

   457 

   458 			// Rotate keys if necessary.

   459 			SessionKeys mostRecent = this.getMostRecentSessionKeys();

   460 			if (mostRecent.getLocalKeyID() == receipientKeyID)

   461 				this.rotateLocalSessionKeys();

   462 

   463 			if (mostRecent.getRemoteKeyID() == senderKeyID)

   464 				this.rotateRemoteSessionKeys(data.nextDH);

   465 

   466 			// Handle TLVs

   467 			List<TLV> tlvs = null;

   468 			int tlvIndex = decryptedMsgContent.indexOf((char) 0x0);

   469 			if (tlvIndex > -1) {

   470 				decryptedMsgContent = decryptedMsgContent

   471 						.substring(0, tlvIndex);

   472 				tlvIndex++;

   473 				byte[] tlvsb = new byte[dmc.length - tlvIndex];

   474 				System.arraycopy(dmc, tlvIndex, tlvsb, 0, tlvsb.length);

   475 

   476 				tlvs = new Vector<TLV>();

   477 				ByteArrayInputStream tin = new ByteArrayInputStream(tlvsb);

   478 				while (tin.available() > 0) {

   479 					int type;

   480 					byte[] tdata;

   481 					OtrInputStream eois = new OtrInputStream(tin);

   482 					try {

   483 						type = eois.readShort();

   484 						tdata = eois.readTlvData();

   485 						eois.close();

   486 					} catch (IOException e) {

   487 						throw new OtrException(e);

   488 					}

   489 

   490 					tlvs.add(new TLV(type, tdata));

   491 				}

   492 			}

   493 			if (tlvs != null && tlvs.size() > 0) {

   494 				for (TLV tlv : tlvs) {

   495 					switch (tlv.getType()) {

   496 					case 1:

   497 						this.setSessionStatus(SessionStatus.FINISHED);

   498 						return null;

   499 					default:

   500 						return decryptedMsgContent;

   501 					}

   502 				}

   503 			}

   504 

   505 			return decryptedMsgContent;

   506 

   507 		case FINISHED:

   508 		case PLAINTEXT:

   509 			getListener().showWarning(this.getSessionID(),

   510 					"Unreadable encrypted message was received.");

   511 

   512 			injectMessage(new ErrorMessage(AbstractMessage.MESSAGE_ERROR,

   513 					"You sent me an unreadable encrypted message.."));

   514 			break;

   515 		}

   516 

   517 		return null;

   518 	}

   519 

   520 	public void injectMessage(AbstractMessage m) throws OtrException {

   521 		String msg;

   522 		try {

   523 			msg = SerializationUtils.toString(m);

   524 		} catch (IOException e) {

   525 			throw new OtrException(e);

   526 		}

   527 		getListener().injectMessage(getSessionID(), msg);

   528 	}

   529 

   530 	private String handlePlainTextMessage(PlainTextMessage plainTextMessage)

   531 			throws OtrException {

   532 		logger.finest(getSessionID().getAccountID()

   533 				+ " received a plaintext message from "

   534 				+ getSessionID().getUserID() + " throught "

   535 				+ getSessionID().getProtocolName() + ".");

   536 

   537 		OtrPolicy policy = getSessionPolicy();

   538 		List<Integer> versions = plainTextMessage.versions;

   539 		if (versions == null || versions.size() < 1) {

   540 			logger

   541 					.finest("Received plaintext message without the whitespace tag.");

   542 			switch (this.getSessionStatus()) {

   543 			case ENCRYPTED:

   544 			case FINISHED:

   545 				// Display the message to the user, but warn him that the

   546 				// message was received unencrypted.

   547 				getListener().showWarning(this.getSessionID(),

   548 						"The message was received unencrypted.");

   549 				return plainTextMessage.cleanText;

   550 			case PLAINTEXT:

   551 				// Simply display the message to the user. If

   552 				// REQUIRE_ENCRYPTION

   553 				// is set, warn him that the message was received

   554 				// unencrypted.

   555 				if (policy.getRequireEncryption()) {

   556 					getListener().showWarning(this.getSessionID(),

   557 							"The message was received unencrypted.");

   558 				}

   559 				return plainTextMessage.cleanText;

   560 			}

   561 		} else {

   562 			logger

   563 					.finest("Received plaintext message with the whitespace tag.");

   564 			switch (this.getSessionStatus()) {

   565 			case ENCRYPTED:

   566 			case FINISHED:

   567 				// Remove the whitespace tag and display the message to the

   568 				// user, but warn him that the message was received

   569 				// unencrypted.

   570 				getListener().showWarning(this.getSessionID(),

   571 						"The message was received unencrypted.");

   572 			case PLAINTEXT:

   573 				// Remove the whitespace tag and display the message to the

   574 				// user. If REQUIRE_ENCRYPTION is set, warn him that the

   575 				// message

   576 				// was received unencrypted.

   577 				if (policy.getRequireEncryption())

   578 					getListener().showWarning(this.getSessionID(),

   579 							"The message was received unencrypted.");

   580 			}

   581 

   582 			if (policy.getWhitespaceStartAKE()) {

   583 				logger.finest("WHITESPACE_START_AKE is set");

   584 

   585 				if (plainTextMessage.versions.contains(2)

   586 						&& policy.getAllowV2()) {

   587 					logger.finest("V2 tag found.");

   588 					getAuthContext().respondV2Auth();

   589 				} else if (plainTextMessage.versions.contains(1)

   590 						&& policy.getAllowV1()) {

   591 					throw new UnsupportedOperationException();

   592 				}

   593 			}

   594 		}

   595 

   596 		return plainTextMessage.cleanText;

   597 	}

   598 

   599 	// Retransmit last sent message. Spec document does not mention where or

   600 	// when that should happen, must check libotr code.

   601 	private String lastSentMessage;

   602 

   603 	public String transformSending(String msgText, List<TLV> tlvs)

   604 			throws OtrException {

   605 

   606 		switch (this.getSessionStatus()) {

   607 		case PLAINTEXT:

   608 			if (getSessionPolicy().getRequireEncryption()) {

   609 				this.lastSentMessage = msgText;

   610 				this.startSession();

   611 			} else

   612 				// TODO this does not precisly behave according to

   613 				// specification.

   614 				return msgText;

   615 		case ENCRYPTED:

   616 			this.lastSentMessage = msgText;

   617 			logger.finest(getSessionID().getAccountID()

   618 					+ " sends an encrypted message to "

   619 					+ getSessionID().getUserID() + " throught "

   620 					+ getSessionID().getProtocolName() + ".");

   621 

   622 			// Get encryption keys.

   623 			SessionKeys encryptionKeys = this.getEncryptionSessionKeys();

   624 			int senderKeyID = encryptionKeys.getLocalKeyID();

   625 			int receipientKeyID = encryptionKeys.getRemoteKeyID();

   626 

   627 			// Increment CTR.

   628 			encryptionKeys.incrementSendingCtr();

   629 			byte[] ctr = encryptionKeys.getSendingCtr();

   630 

   631 			ByteArrayOutputStream out = new ByteArrayOutputStream();

   632 			if (msgText != null && msgText.length() > 0)

   633 				try {

   634 					out.write(msgText.getBytes("UTF8"));

   635 				} catch (IOException e) {

   636 					throw new OtrException(e);

   637 				}

   638 

   639 			// Append tlvs

   640 			if (tlvs != null && tlvs.size() > 0) {

   641 				out.write((byte) 0x00);

   642 

   643 				OtrOutputStream eoos = new OtrOutputStream(out);

   644 				for (TLV tlv : tlvs) {

   645 					try {

   646 						eoos.writeShort(tlv.type);

   647 						eoos.writeTlvData(tlv.value);

   648 					} catch (IOException e) {

   649 						throw new OtrException(e);

   650 					}

   651 				}

   652 			}

   653 

   654 			OtrCryptoEngine otrCryptoEngine = new OtrCryptoEngineImpl();

   655 

   656 			byte[] data = out.toByteArray();

   657 			// Encrypt message.

   658 			logger

   659 					.finest("Encrypting message with keyids (localKeyID, remoteKeyID) = ("

   660 							+ senderKeyID + ", " + receipientKeyID + ")");

   661 			byte[] encryptedMsg = otrCryptoEngine.aesEncrypt(encryptionKeys

   662 					.getSendingAESKey(), ctr, data);

   663 

   664 			// Get most recent keys to get the next D-H public key.

   665 			SessionKeys mostRecentKeys = this.getMostRecentSessionKeys();

   666 			DHPublicKey nextDH = (DHPublicKey) mostRecentKeys.getLocalPair()

   667 					.getPublic();

   668 

   669 			// Calculate T.

   670 			MysteriousT t = new MysteriousT(2, 0, senderKeyID, receipientKeyID,

   671 					nextDH, ctr, encryptedMsg);

   672 

   673 			// Calculate T hash.

   674 			byte[] sendingMACKey = encryptionKeys.getSendingMACKey();

   675 

   676 			logger

   677 					.finest("Transforming T to byte[] to calculate it's HmacSHA1.");

   678 			byte[] serializedT;

   679 			try {

   680 				serializedT = SerializationUtils.toByteArray(t);

   681 			} catch (IOException e) {

   682 				throw new OtrException(e);

   683 			}

   684 

   685 			byte[] mac = otrCryptoEngine.sha1Hmac(serializedT, sendingMACKey,

   686 					SerializationConstants.TYPE_LEN_MAC);

   687 

   688 			// Get old MAC keys to be revealed.

   689 			byte[] oldKeys = this.collectOldMacKeys();

   690 			DataMessage m = new DataMessage(t, mac, oldKeys);

   691 

   692 			try {

   693 				return SerializationUtils.toString(m);

   694 			} catch (IOException e) {

   695 				throw new OtrException(e);

   696 			}

   697 		case FINISHED:

   698 			this.lastSentMessage = msgText;

   699 			getListener()

   700 					.showError(

   701 							sessionID,

   702 							"Your message to "

   703 									+ sessionID.getUserID()

   704 									+ " was not sent.  Either end your private conversation, or restart it.");

   705 			return null;

   706 		default:

   707 			logger.finest("Uknown message state, not processing.");

   708 			return msgText;

   709 		}

   710 	}

   711 

   712 	/*

   713 	 * (non-Javadoc)

   714 	 * 

   715 	 * @see net.java.otr4j.session.ISession#startSession()

   716 	 */

   717 	public void startSession() throws OtrException {

   718 		if (this.getSessionStatus() == SessionStatus.ENCRYPTED)

   719 			return;

   720 

   721 		if (!getSessionPolicy().getAllowV2())

   722 			throw new UnsupportedOperationException();

   723 

   724 		this.getAuthContext().startV2Auth();

   725 	}

   726 

   727 	/*

   728 	 * (non-Javadoc)

   729 	 * 

   730 	 * @see net.java.otr4j.session.ISession#endSession()

   731 	 */

   732 	public void endSession() throws OtrException {

   733 		SessionStatus status = this.getSessionStatus();

   734 		switch (status) {

   735 		case ENCRYPTED:

   736 			Vector<TLV> tlvs = new Vector<TLV>();

   737 			tlvs.add(new TLV(1, null));

   738 

   739 			String msg = this.transformSending(null, tlvs);

   740 			getListener().injectMessage(getSessionID(), msg);

   741 			this.setSessionStatus(SessionStatus.PLAINTEXT);

   742 			break;

   743 		case FINISHED:

   744 			this.setSessionStatus(SessionStatus.PLAINTEXT);

   745 			break;

   746 		case PLAINTEXT:

   747 			return;

   748 		}

   749 

   750 	}

   751 

   752 	/*

   753 	 * (non-Javadoc)

   754 	 * 

   755 	 * @see net.java.otr4j.session.ISession#refreshSession()

   756 	 */

   757 	public void refreshSession() throws OtrException {

   758 		this.endSession();

   759 		this.startSession();

   760 	}

   761 

   762 	private PublicKey remotePublicKey;

   763 

   764 	private void setRemotePublicKey(PublicKey pubKey) {

   765 		this.remotePublicKey = pubKey;

   766 	}

   767 

   768 	public PublicKey getRemotePublicKey() {

   769 		return remotePublicKey;

   770 	}

   771 

   772 	private List<OtrEngineListener> listeners = new Vector<OtrEngineListener>();

   773 

   774 	public void addOtrEngineListener(OtrEngineListener l) {

   775 		synchronized (listeners) {

   776 			if (!listeners.contains(l))

   777 				listeners.add(l);

   778 		}

   779 

   780 	}

   781 

   782 	public void removeOtrEngineListener(OtrEngineListener l) {

   783 		synchronized (listeners) {

   784 			listeners.remove(l);

   785 		}

   786 	}

   787 

   788 	public OtrPolicy getSessionPolicy() {

   789 		return getListener().getSessionPolicy(getSessionID());

   790 	}

   791 

   792 	public KeyPair getLocalKeyPair() {

   793 		return getListener().getKeyPair(this.getSessionID());

   794 	}

   795 }