private void handleMessage(TextSecureEnvelope envelope, bool sendExplicitReceipt)
{
var worker = App.Current.Worker;
long messageId = DatabaseFactory.getPushDatabase().Insert(envelope);
if (sendExplicitReceipt)
{
worker.AddTaskActivities(new DeliveryReceiptTask(envelope.getSource(),
envelope.getTimestamp(),
envelope.getRelay()));
}
worker.AddTaskActivities(new PushDecryptTask(messageId, envelope.getSource()));
}
public void handle(TextSecureEnvelope envelope, bool sendExplicitReceipt)
{
if (!isActiveNumber(envelope.getSource()))
{
TextSecureDirectory directory = DatabaseFactory.getDirectoryDatabase();
ContactTokenDetails contactTokenDetails = new ContactTokenDetails();
contactTokenDetails.setNumber(envelope.getSource());
directory.setNumber(contactTokenDetails, true);
// TODO: evtl DirectoryRefresh
}
if (envelope.isReceipt()) handleReceipt(envelope);
else if (envelope.isPreKeyWhisperMessage() || envelope.isWhisperMessage())
{
handleMessage(envelope, sendExplicitReceipt);
}
else
{
Log.Warn($"Received envelope of unknown type: {envelope.GetType()}");
}
}
public long Insert(TextSecureEnvelope envelope)
{
// TODO check if exists
var push = new Push()
{
Type = envelope.getType(),
Source = envelope.getSource(),
DeviceId = envelope.getSourceDevice(),
LegacyMessage = envelope.hasLegacyMessage() ? Base64.encodeBytes(envelope.getLegacyMessage()) : "",
Content = envelope.hasContent() ? Base64.encodeBytes(envelope.getContent()) : "",
Timestamp = TimeUtil.GetDateTime(envelope.getTimestamp())
};
try
{
conn.Insert(push);
} catch(Exception e) { Debug.WriteLine(e.Message); }
return push.PushId;
}
/**
* Decrypt a received {@link org.whispersystems.textsecure.api.messages.TextSecureEnvelope}
*
* @param envelope The received TextSecureEnvelope
* @return a decrypted TextSecureMessage
* @throws InvalidVersionException
* @throws InvalidMessageException
* @throws InvalidKeyException
* @throws DuplicateMessageException
* @throws InvalidKeyIdException
* @throws UntrustedIdentityException
* @throws LegacyMessageException
* @throws NoSessionException
*/
public TextSecureContent decrypt(TextSecureEnvelope envelope)
{
try
{
TextSecureContent content = new TextSecureContent();
if (envelope.hasLegacyMessage())
{
DataMessage message = DataMessage.ParseFrom(decrypt(envelope, envelope.getLegacyMessage()));
content = new TextSecureContent(createTextSecureMessage(envelope, message));
}
else if (envelope.hasContent())
{
Content message = Content.ParseFrom(decrypt(envelope, envelope.getContent()));
if (message.HasDataMessage)
{
content = new TextSecureContent(createTextSecureMessage(envelope, message.DataMessage));
}
else if (message.HasSyncMessage && localAddress.getNumber().Equals(envelope.getSource()))
{
content = new TextSecureContent(createSynchronizeMessage(envelope, message.SyncMessage));
}
}
return content;
}
catch (InvalidProtocolBufferException e)
{
throw new InvalidMessageException(e);
}
}
private byte[] decrypt(TextSecureEnvelope envelope, byte[] ciphertext)
{
AxolotlAddress sourceAddress = new AxolotlAddress(envelope.getSource(), envelope.getSourceDevice());
SessionCipher sessionCipher = new SessionCipher(axolotlStore, sourceAddress);
byte[] paddedMessage;
if (envelope.isPreKeyWhisperMessage())
{
paddedMessage = sessionCipher.decrypt(new PreKeyWhisperMessage(ciphertext));
}
else if (envelope.isWhisperMessage())
{
paddedMessage = sessionCipher.decrypt(new WhisperMessage(ciphertext));
}
else
{
throw new InvalidMessageException("Unknown type: " + envelope.getType());
}
PushTransportDetails transportDetails = new PushTransportDetails(sessionCipher.getSessionVersion());
return transportDetails.getStrippedPaddingMessageBody(paddedMessage);
}
private Pair<long, long> insertPlaceholder(TextSecureEnvelope envelope)
{
var database = DatabaseFactory.getTextMessageDatabase(); //getEncryptingSmsDatabase(context);
IncomingTextMessage textMessage = new IncomingTextMessage(envelope.getSource(), envelope.getSourceDevice(),
envelope.getTimestamp(), "",
May<TextSecureGroup>.NoValue);
textMessage = new IncomingEncryptedMessage(textMessage, "");
return database.InsertMessageInbox(textMessage);
}
private void handleUntrustedIdentityMessage(TextSecureEnvelope envelope, May<long> smsMessageId)
{
try
{
var database = DatabaseFactory.getTextMessageDatabase(); //getEncryptingSmsDatabase(context);
Recipients recipients = RecipientFactory.getRecipientsFromString(envelope.getSource(), false);
long recipientId = recipients.getPrimaryRecipient().getRecipientId();
PreKeyWhisperMessage whisperMessage = new PreKeyWhisperMessage(envelope.getLegacyMessage());
IdentityKey identityKey = whisperMessage.getIdentityKey();
String encoded = Base64.encodeBytes(envelope.getLegacyMessage());
IncomingTextMessage textMessage = new IncomingTextMessage(envelope.getSource(), envelope.getSourceDevice(),
envelope.getTimestamp(), encoded,
May<TextSecureGroup>.NoValue);
if (!smsMessageId.HasValue)
{
IncomingPreKeyBundleMessage bundleMessage = new IncomingPreKeyBundleMessage(textMessage, encoded);
Pair<long, long> messageAndThreadId = database.InsertMessageInbox(bundleMessage);
database.SetMismatchedIdentity(messageAndThreadId.first(), recipientId, identityKey);
//MessageNotifier.updateNotification(context, masterSecret.getMasterSecret().orNull(), messageAndThreadId.second);
}
else
{
var messageId = smsMessageId.ForceGetValue();
database.UpdateMessageBody(messageId, encoded);
database.MarkAsPreKeyBundle(messageId);
database.SetMismatchedIdentity(messageId, recipientId, identityKey);
}
}
catch (InvalidMessageException e)
{
throw new InvalidOperationException(e.Message);
}
catch (InvalidVersionException e)
{
throw new InvalidOperationException(e.Message);
}
}
private void handleTextMessage(/*@NonNull MasterSecretUnion masterSecret,*/
TextSecureEnvelope envelope,
TextSecureDataMessage message,
May<long> smsMessageId)
{
var textMessageDatabase = DatabaseFactory.getTextMessageDatabase();
String body = message.getBody().HasValue ? message.getBody().ForceGetValue() : "";
IncomingTextMessage textMessage = new IncomingTextMessage(envelope.getSource(),
envelope.getSourceDevice(),
message.getTimestamp(), body,
message.getGroupInfo());
textMessage = new IncomingEncryptedMessage(textMessage, body);
var messageAndThreadId = textMessageDatabase.InsertMessageInbox(textMessage);
ToastHelper.NotifyNewMessage(messageAndThreadId.second());
}
private void handleEndSessionMessage(TextSecureEnvelope envelope,
TextSecureDataMessage message,
May<long> smsMessageId)
{
var smsDatabase = DatabaseFactory.getTextMessageDatabase();//getEncryptingSmsDatabase(context);
var incomingTextMessage = new IncomingTextMessage(envelope.getSource(),
envelope.getSourceDevice(),
message.getTimestamp(),
"", May<TextSecureGroup>.NoValue);
long threadId;
if (!smsMessageId.HasValue)
{
IncomingEndSessionMessage incomingEndSessionMessage = new IncomingEndSessionMessage(incomingTextMessage);
Pair<long, long> messageAndThreadId = smsDatabase.InsertMessageInbox(incomingEndSessionMessage);
threadId = messageAndThreadId.second();
}
else
{
var messageId = smsMessageId.ForceGetValue();
smsDatabase.MarkAsEndSession(messageId);
threadId = smsDatabase.GetThreadIdForMessage(messageId);
}
SessionStore sessionStore = new TextSecureAxolotlStore();
sessionStore.DeleteAllSessions(envelope.getSource());
//SecurityEvent.broadcastSecurityUpdateEvent(context, threadId);
//MessageNotifier.updateNotification(context, masterSecret.getMasterSecret().orNull(), threadId);
}
private void handleReceipt(TextSecureEnvelope envelope)
{
Log.Debug($"Received receipt: (XXXXX, {envelope.getTimestamp()})");
DatabaseFactory.getMessageDatabase().incrementDeliveryReceiptCount(envelope.getSource(),
(long)envelope.getTimestamp());
}