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 	class TLV {

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

    49 			this.setType(type);

    50 			this.setValue(value);

    51 		}

    52 

    53 		public void setType(int type) {

    54 			this.type = type;

    55 		}

    56 

    57 		public int getType() {

    58 			return type;

    59 		}

    60 

    61 		public void setValue(byte[] value) {

    62 			this.value = value;

    63 		}

    64 

    65 		public byte[] getValue() {

    66 			return value;

    67 		}

    68 

    69 		private int type;

    70 		private byte[] value;

    71 	}

    72 

    73 	private SessionID sessionID;

    74 	private OtrEngineHost host;

    75 	private SessionStatus sessionStatus;

    76 	private AuthContext authContext;

    77 	private SessionKeys[][] sessionKeys;

    78 	private Vector<byte[]> oldMacKeys;

    79 	private static Logger logger = Logger

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

    81 

    82 	public SessionImpl(SessionID sessionID, OtrEngineHost listener) {

    83 

    84 		this.setSessionID(sessionID);

    85 		this.setHost(listener);

    86 

    87 		// client application calls OtrEngine.getSessionStatus()

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

    89 		// -> setSessionStatus() fires statusChangedEvent

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

    91 		this.sessionStatus = SessionStatus.PLAINTEXT;

    92 	}

    93 

    94 	private SessionKeys getEncryptionSessionKeys() {

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

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

    97 	}

    98 

    99 	private SessionKeys getMostRecentSessionKeys() {

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

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

   102 	}

   103 

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

   105 		logger

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

   107 						+ localKeyID + "," + remoteKeyID + ")");

   108 

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

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

   111 				SessionKeys current = getSessionKeysByIndex(i, j);

   112 				if (current.getLocalKeyID() == localKeyID

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

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

   115 					return current;

   116 				}

   117 			}

   118 		}

   119 

   120 		return null;

   121 	}

   122 

   123 	private SessionKeys getSessionKeysByIndex(int localKeyIndex,

   124 			int remoteKeyIndex) {

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

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

   127 					localKeyIndex, remoteKeyIndex);

   128 

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

   130 	}

   131 

   132 	private void rotateRemoteSessionKeys(DHPublicKey pubKey)

   133 			throws OtrException {

   134 

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

   136 		SessionKeys sess1 = getSessionKeysByIndex(SessionKeys.Current,

   137 				SessionKeys.Previous);

   138 		if (sess1.getIsUsedReceivingMACKey()) {

   139 			logger

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

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

   142 		}

   143 

   144 		SessionKeys sess2 = getSessionKeysByIndex(SessionKeys.Previous,

   145 				SessionKeys.Previous);

   146 		if (sess2.getIsUsedReceivingMACKey()) {

   147 			logger

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

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

   150 		}

   151 

   152 		SessionKeys sess3 = getSessionKeysByIndex(SessionKeys.Current,

   153 				SessionKeys.Current);

   154 		sess1

   155 				.setRemoteDHPublicKey(sess3.getRemoteKey(), sess3

   156 						.getRemoteKeyID());

   157 

   158 		SessionKeys sess4 = getSessionKeysByIndex(SessionKeys.Previous,

   159 				SessionKeys.Current);

   160 		sess2

   161 				.setRemoteDHPublicKey(sess4.getRemoteKey(), sess4

   162 						.getRemoteKeyID());

   163 

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

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

   166 	}

   167 

   168 	private void rotateLocalSessionKeys() throws OtrException {

   169 

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

   171 		SessionKeys sess1 = getSessionKeysByIndex(SessionKeys.Previous,

   172 				SessionKeys.Current);

   173 		if (sess1.getIsUsedReceivingMACKey()) {

   174 			logger

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

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

   177 		}

   178 

   179 		SessionKeys sess2 = getSessionKeysByIndex(SessionKeys.Previous,

   180 				SessionKeys.Previous);

   181 		if (sess2.getIsUsedReceivingMACKey()) {

   182 			logger

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

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

   185 		}

   186 

   187 		SessionKeys sess3 = getSessionKeysByIndex(SessionKeys.Current,

   188 				SessionKeys.Current);

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

   190 		SessionKeys sess4 = getSessionKeysByIndex(SessionKeys.Current,

   191 				SessionKeys.Previous);

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

   193 

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

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

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

   197 	}

   198 

   199 	private byte[] collectOldMacKeys() {

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

   201 		int len = 0;

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

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

   204 

   205 		ByteBuffer buff = ByteBuffer.allocate(len);

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

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

   208 

   209 		getOldMacKeys().clear();

   210 		return buff.array();

   211 	}

   212 

   213 	private void setSessionStatus(SessionStatus sessionStatus)

   214 			throws OtrException {

   215 

   216 		if (sessionStatus == this.sessionStatus)

   217 			return;

   218 

   219 		switch (sessionStatus) {

   220 		case ENCRYPTED:

   221 			AuthContext auth = this.getAuthContext();

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

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

   224 				SessionKeys current = getSessionKeysByIndex(0, i);

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

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

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

   228 			}

   229 

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

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

   232 				SessionKeys current = getSessionKeysByIndex(1, i);

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

   234 				current.setLocalPair(nextDH, 2);

   235 			}

   236 

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

   238 

   239 			auth.reset();

   240 			break;

   241 		}

   242 

   243 		this.sessionStatus = sessionStatus;

   244 

   245 		for (OtrEngineListener l : this.listeners)

   246 			l.sessionStatusChanged(getSessionID());

   247 	}

   248 

   249 	/*

   250 	 * (non-Javadoc)

   251 	 * 

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

   253 	 */

   254 

   255 	public SessionStatus getSessionStatus() {

   256 		return sessionStatus;

   257 	}

   258 

   259 	private void setSessionID(SessionID sessionID) {

   260 		this.sessionID = sessionID;

   261 	}

   262 

   263 	/*

   264 	 * (non-Javadoc)

   265 	 * 

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

   267 	 */

   268 	public SessionID getSessionID() {

   269 		return sessionID;

   270 	}

   271 

   272 	private void setHost(OtrEngineHost host) {

   273 		this.host = host;

   274 	}

   275 

   276 	private OtrEngineHost getHost() {

   277 		return host;

   278 	}

   279 

   280 	private SessionKeys[][] getSessionKeys() {

   281 		if (sessionKeys == null)

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

   283 		return sessionKeys;

   284 	}

   285 

   286 	private AuthContext getAuthContext() {

   287 		if (authContext == null)

   288 			authContext = new AuthContextImpl(this);

   289 		return authContext;

   290 	}

   291 

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

   293 		if (oldMacKeys == null)

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

   295 		return oldMacKeys;

   296 	}

   297 

   298 	/*

   299 	 * (non-Javadoc)

   300 	 * 

   301 	 * @see

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

   303 	 */

   304 	public String transformReceiving(String msgText) throws OtrException {

   305 		OtrPolicy policy = getSessionPolicy();

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

   307 			logger

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

   309 			return msgText;

   310 		}

   311 

   312 		AbstractMessage m;

   313 		try {

   314 			m = SerializationUtils.toMessage(msgText);

   315 		} catch (IOException e) {

   316 			throw new OtrException(e);

   317 		}

   318 		

   319 		if (m == null)

   320 			return msgText; // Propably null or empty.

   321 

   322 		switch (m.messageType) {

   323 		case AbstractEncodedMessage.MESSAGE_DATA:

   324 			return handleDataMessage((DataMessage) m);

   325 		case AbstractMessage.MESSAGE_ERROR:

   326 			handleErrorMessage((ErrorMessage) m);

   327 			return null;

   328 		case AbstractMessage.MESSAGE_PLAINTEXT:

   329 			return handlePlainTextMessage((PlainTextMessage) m);

   330 		case AbstractMessage.MESSAGE_QUERY:

   331 			handleQueryMessage((QueryMessage) m);

   332 			return null;

   333 		case AbstractEncodedMessage.MESSAGE_DH_COMMIT:

   334 		case AbstractEncodedMessage.MESSAGE_DHKEY:

   335 		case AbstractEncodedMessage.MESSAGE_REVEALSIG:

   336 		case AbstractEncodedMessage.MESSAGE_SIGNATURE:

   337 			AuthContext auth = this.getAuthContext();

   338 			auth.handleReceivingMessage(m);

   339 

   340 			if (auth.getIsSecure()) {

   341 				this.setSessionStatus(SessionStatus.ENCRYPTED);

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

   343 			}

   344 			return null;

   345 		default:

   346 			throw new UnsupportedOperationException(

   347 					"Received an uknown message type.");

   348 		}

   349 	}

   350 

   351 	private void handleQueryMessage(QueryMessage queryMessage)

   352 			throws OtrException {

   353 		logger.finest(getSessionID().getAccountID()

   354 				+ " received a query message from "

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

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

   357 

   358 		setSessionStatus(SessionStatus.PLAINTEXT);

   359 

   360 		OtrPolicy policy = getSessionPolicy();

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

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

   363 			getAuthContext().respondV2Auth();

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

   365 			throw new UnsupportedOperationException();

   366 		}

   367 	}

   368 

   369 	private void handleErrorMessage(ErrorMessage errorMessage)

   370 			throws OtrException {

   371 		logger.finest(getSessionID().getAccountID()

   372 				+ " received an error message from "

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

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

   375 

   376 		getHost().showError(this.getSessionID(), errorMessage.error);

   377 

   378 		OtrPolicy policy = getSessionPolicy();

   379 		if (policy.getErrorStartAKE()) {

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

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

   382 			if (policy.getAllowV1())

   383 				versions.add(1);

   384 

   385 			if (policy.getAllowV2())

   386 				versions.add(2);

   387 

   388 			logger.finest("Sending Query");

   389 			injectMessage(new QueryMessage(versions));

   390 		}

   391 	}

   392 

   393 	private String handleDataMessage(DataMessage data) throws OtrException {

   394 		logger.finest(getSessionID().getAccountID()

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

   396 				+ ".");

   397 

   398 		switch (this.getSessionStatus()) {

   399 		case ENCRYPTED:

   400 			logger

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

   402 

   403 			// Find matching session keys.

   404 			int senderKeyID = data.senderKeyID;

   405 			int receipientKeyID = data.recipientKeyID;

   406 			SessionKeys matchingKeys = this.getSessionKeysByID(receipientKeyID,

   407 					senderKeyID);

   408 

   409 			if (matchingKeys == null) {

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

   411 				return null;

   412 			}

   413 

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

   415 			logger

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

   417 

   418 			byte[] serializedT;

   419 			try {

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

   421 			} catch (IOException e) {

   422 				throw new OtrException(e);

   423 			}

   424 

   425 			OtrCryptoEngine otrCryptoEngine = new OtrCryptoEngineImpl();

   426 

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

   428 					matchingKeys.getReceivingMACKey(),

   429 					SerializationConstants.TYPE_LEN_MAC);

   430 

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

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

   433 				return null;

   434 			}

   435 

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

   437 

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

   439 			matchingKeys.setIsUsedReceivingMACKey(true);

   440 

   441 			matchingKeys.setReceivingCtr(data.ctr);

   442 

   443 			byte[] dmc = otrCryptoEngine.aesDecrypt(matchingKeys

   444 					.getReceivingAESKey(), matchingKeys.getReceivingCtr(),

   445 					data.encryptedMessage);

   446 			String decryptedMsgContent;

   447 			try {

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

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

   450 			} catch (UnsupportedEncodingException e) {

   451 				throw new OtrException(e);

   452 			}

   453 

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

   455 

   456 			// Rotate keys if necessary.

   457 			SessionKeys mostRecent = this.getMostRecentSessionKeys();

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

   459 				this.rotateLocalSessionKeys();

   460 

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

   462 				this.rotateRemoteSessionKeys(data.nextDH);

   463 

   464 			// Handle TLVs

   465 			List<TLV> tlvs = null;

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

   467 			if (tlvIndex > -1) {

   468 				decryptedMsgContent = decryptedMsgContent

   469 						.substring(0, tlvIndex);

   470 				tlvIndex++;

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

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

   473 

   474 				tlvs = new Vector<TLV>();

   475 				ByteArrayInputStream tin = new ByteArrayInputStream(tlvsb);

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

   477 					int type;

   478 					byte[] tdata;

   479 					OtrInputStream eois = new OtrInputStream(tin);

   480 					try {

   481 						type = eois.readShort();

   482 						tdata = eois.readTlvData();

   483 						eois.close();

   484 					} catch (IOException e) {

   485 						throw new OtrException(e);

   486 					}

   487 

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

   489 				}

   490 			}

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

   492 				for (TLV tlv : tlvs) {

   493 					switch (tlv.getType()) {

   494 					case 1:

   495 						this.setSessionStatus(SessionStatus.FINISHED);

   496 						return null;

   497 					default:

   498 						return decryptedMsgContent;

   499 					}

   500 				}

   501 			}

   502 

   503 			return decryptedMsgContent;

   504 

   505 		case FINISHED:

   506 		case PLAINTEXT:

   507 			getHost().showWarning(this.getSessionID(),

   508 					"Unreadable encrypted message was received.");

   509 

   510 			injectMessage(new ErrorMessage(AbstractMessage.MESSAGE_ERROR,

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

   512 			break;

   513 		}

   514 

   515 		return null;

   516 	}

   517 

   518 	public void injectMessage(AbstractMessage m) throws OtrException {

   519 		String msg;

   520 		try {

   521 			msg = SerializationUtils.toString(m);

   522 		} catch (IOException e) {

   523 			throw new OtrException(e);

   524 		}

   525 		getHost().injectMessage(getSessionID(), msg);

   526 	}

   527 

   528 	private String handlePlainTextMessage(PlainTextMessage plainTextMessage)

   529 			throws OtrException {

   530 		logger.finest(getSessionID().getAccountID()

   531 				+ " received a plaintext message from "

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

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

   534 

   535 		OtrPolicy policy = getSessionPolicy();

   536 		List<Integer> versions = plainTextMessage.versions;

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

   538 			logger

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

   540 			switch (this.getSessionStatus()) {

   541 			case ENCRYPTED:

   542 			case FINISHED:

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

   544 				// message was received unencrypted.

   545 				getHost().showWarning(this.getSessionID(),

   546 						"The message was received unencrypted.");

   547 				return plainTextMessage.cleanText;

   548 			case PLAINTEXT:

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

   550 				// REQUIRE_ENCRYPTION

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

   552 				// unencrypted.

   553 				if (policy.getRequireEncryption()) {

   554 					getHost().showWarning(this.getSessionID(),

   555 							"The message was received unencrypted.");

   556 				}

   557 				return plainTextMessage.cleanText;

   558 			}

   559 		} else {

   560 			logger

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

   562 			switch (this.getSessionStatus()) {

   563 			case ENCRYPTED:

   564 			case FINISHED:

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

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

   567 				// unencrypted.

   568 				getHost().showWarning(this.getSessionID(),

   569 						"The message was received unencrypted.");

   570 			case PLAINTEXT:

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

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

   573 				// message

   574 				// was received unencrypted.

   575 				if (policy.getRequireEncryption())

   576 					getHost().showWarning(this.getSessionID(),

   577 							"The message was received unencrypted.");

   578 			}

   579 

   580 			if (policy.getWhitespaceStartAKE()) {

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

   582 

   583 				if (plainTextMessage.versions.contains(2)

   584 						&& policy.getAllowV2()) {

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

   586 					getAuthContext().respondV2Auth();

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

   588 						&& policy.getAllowV1()) {

   589 					throw new UnsupportedOperationException();

   590 				}

   591 			}

   592 		}

   593 

   594 		return plainTextMessage.cleanText;

   595 	}

   596 

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

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

   599 	private String lastSentMessage;

   600 

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

   602 			throws OtrException {

   603 

   604 		switch (this.getSessionStatus()) {

   605 		case PLAINTEXT:

   606 			if (getSessionPolicy().getRequireEncryption()) {

   607 				this.lastSentMessage = msgText;

   608 				this.startSession();

   609 			} else

   610 				// TODO this does not precisly behave according to

   611 				// specification.

   612 				return msgText;

   613 		case ENCRYPTED:

   614 			this.lastSentMessage = msgText;

   615 			logger.finest(getSessionID().getAccountID()

   616 					+ " sends an encrypted message to "

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

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

   619 

   620 			// Get encryption keys.

   621 			SessionKeys encryptionKeys = this.getEncryptionSessionKeys();

   622 			int senderKeyID = encryptionKeys.getLocalKeyID();

   623 			int receipientKeyID = encryptionKeys.getRemoteKeyID();

   624 

   625 			// Increment CTR.

   626 			encryptionKeys.incrementSendingCtr();

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

   628 

   629 			ByteArrayOutputStream out = new ByteArrayOutputStream();

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

   631 				try {

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

   633 				} catch (IOException e) {

   634 					throw new OtrException(e);

   635 				}

   636 

   637 			// Append tlvs

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

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

   640 

   641 				OtrOutputStream eoos = new OtrOutputStream(out);

   642 				for (TLV tlv : tlvs) {

   643 					try {

   644 						eoos.writeShort(tlv.type);

   645 						eoos.writeTlvData(tlv.value);

   646 					} catch (IOException e) {

   647 						throw new OtrException(e);

   648 					}

   649 				}

   650 			}

   651 

   652 			OtrCryptoEngine otrCryptoEngine = new OtrCryptoEngineImpl();

   653 

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

   655 			// Encrypt message.

   656 			logger

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

   658 							+ senderKeyID + ", " + receipientKeyID + ")");

   659 			byte[] encryptedMsg = otrCryptoEngine.aesEncrypt(encryptionKeys

   660 					.getSendingAESKey(), ctr, data);

   661 

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

   663 			SessionKeys mostRecentKeys = this.getMostRecentSessionKeys();

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

   665 					.getPublic();

   666 

   667 			// Calculate T.

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

   669 					nextDH, ctr, encryptedMsg);

   670 

   671 			// Calculate T hash.

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

   673 

   674 			logger

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

   676 			byte[] serializedT;

   677 			try {

   678 				serializedT = SerializationUtils.toByteArray(t);

   679 			} catch (IOException e) {

   680 				throw new OtrException(e);

   681 			}

   682 

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

   684 					SerializationConstants.TYPE_LEN_MAC);

   685 

   686 			// Get old MAC keys to be revealed.

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

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

   689 

   690 			try {

   691 				return SerializationUtils.toString(m);

   692 			} catch (IOException e) {

   693 				throw new OtrException(e);

   694 			}

   695 		case FINISHED:

   696 			this.lastSentMessage = msgText;

   697 			getHost()

   698 					.showError(

   699 							sessionID,

   700 							"Your message to "

   701 									+ sessionID.getUserID()

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

   703 			return null;

   704 		default:

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

   706 			return msgText;

   707 		}

   708 	}

   709 

   710 	/*

   711 	 * (non-Javadoc)

   712 	 * 

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

   714 	 */

   715 	public void startSession() throws OtrException {

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

   717 			return;

   718 

   719 		if (!getSessionPolicy().getAllowV2())

   720 			throw new UnsupportedOperationException();

   721 

   722 		this.getAuthContext().startV2Auth();

   723 	}

   724 

   725 	/*

   726 	 * (non-Javadoc)

   727 	 * 

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

   729 	 */

   730 	public void endSession() throws OtrException {

   731 		SessionStatus status = this.getSessionStatus();

   732 		switch (status) {

   733 		case ENCRYPTED:

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

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

   736 

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

   738 			getHost().injectMessage(getSessionID(), msg);

   739 			this.setSessionStatus(SessionStatus.PLAINTEXT);

   740 			break;

   741 		case FINISHED:

   742 			this.setSessionStatus(SessionStatus.PLAINTEXT);

   743 			break;

   744 		case PLAINTEXT:

   745 			return;

   746 		}

   747 

   748 	}

   749 

   750 	/*

   751 	 * (non-Javadoc)

   752 	 * 

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

   754 	 */

   755 	public void refreshSession() throws OtrException {

   756 		this.endSession();

   757 		this.startSession();

   758 	}

   759 

   760 	private PublicKey remotePublicKey;

   761 

   762 	private void setRemotePublicKey(PublicKey pubKey) {

   763 		this.remotePublicKey = pubKey;

   764 	}

   765 

   766 	public PublicKey getRemotePublicKey() {

   767 		return remotePublicKey;

   768 	}

   769 

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

   771 

   772 	public void addOtrEngineListener(OtrEngineListener l) {

   773 		synchronized (listeners) {

   774 			if (!listeners.contains(l))

   775 				listeners.add(l);

   776 		}

   777 	}

   778 

   779 	public void removeOtrEngineListener(OtrEngineListener l) {

   780 		synchronized (listeners) {

   781 			listeners.remove(l);

   782 		}

   783 	}

   784 

   785 	public OtrPolicy getSessionPolicy() {

   786 		return getHost().getSessionPolicy(getSessionID());

   787 	}

   788 

   789 	public KeyPair getLocalKeyPair() {

   790 		return getHost().getKeyPair(this.getSessionID());

   791 	}

   792 }