protected override async Task<string> ExecuteAsync() { try { String sessionKey = TextSecurePreferences.getSignalingKey(); TextSecureEnvelope envelope = new TextSecureEnvelope(data, sessionKey); handle(envelope, true); } catch (/*IOException | InvalidVersion*/Exception e) { Debug.WriteLine($"{this.GetType().Name}: Error: {e.Message}"); } return ""; }
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 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; }
private void OnMessageReceived(WebSocketConnection sender, WebSocketRequestMessage request) { WebSocketResponseMessage response = createWebSocketResponse(request); Debug.WriteLine($"Verb: {request.Verb}, Path {request.Path}, Body({request.Body.Length}): {request.Body}, Id: {request.Id}"); try { if (isTextSecureEnvelope(request)) { TextSecureEnvelope envelope = new TextSecureEnvelope(request.Body.ToByteArray(), credentialsProvider.GetSignalingKey()); MessageReceived(this, envelope); } } //catch (Exception e) { } // ignore for now finally { websocket.sendResponse(response); } }
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()}"); } }
private void handleDuplicateMessage(TextSecureEnvelope envelope, May<long> smsMessageId) { // Let's start ignoring these now // SmsDatabase smsDatabase = DatabaseFactory.getEncryptingSmsDatabase(context); // // if (smsMessageId <= 0) { // Pair<Long, Long> messageAndThreadId = insertPlaceholder(masterSecret, envelope); // smsDatabase.markAsDecryptDuplicate(messageAndThreadId.first); // MessageNotifier.updateNotification(context, masterSecret, messageAndThreadId.second); // } else { // smsDatabase.markAsDecryptDuplicate(smsMessageId); // } }
private void handleLegacyMessage(TextSecureEnvelope envelope, May<long> smsMessageId) { var smsDatabase = DatabaseFactory.getTextMessageDatabase(); //getEncryptingSmsDatabase(context); if (!smsMessageId.HasValue) { Pair<long, long> messageAndThreadId = insertPlaceholder(envelope); smsDatabase.MarkAsLegacyVersion(messageAndThreadId.first()); //MessageNotifier.updateNotification(context, masterSecret.getMasterSecret().orNull(), messageAndThreadId.second); } else { smsDatabase.MarkAsLegacyVersion(smsMessageId.ForceGetValue()); } }
public void onMessage(TextSecureEnvelope envelope) { }
private TextSecureGroup createGroupInfo(TextSecureEnvelope envelope, DataMessage content) { if (!content.HasGroup) return null; TextSecureGroup.Type type; switch (content.Group.Type) { case GroupContext.Types.Type.DELIVER: type = TextSecureGroup.Type.DELIVER; break; case GroupContext.Types.Type.UPDATE: type = TextSecureGroup.Type.UPDATE; break; case GroupContext.Types.Type.QUIT: type = TextSecureGroup.Type.QUIT; break; default: type = TextSecureGroup.Type.UNKNOWN; break; } if (content.Group.Type != GroupContext.Types.Type.DELIVER) { String name = null; IList<String> members = null; TextSecureAttachmentPointer avatar = null; if (content.Group.HasName) { name = content.Group.Name; } if (content.Group.MembersCount > 0) { members = content.Group.MembersList; } if (content.Group.HasAvatar) { avatar = new TextSecureAttachmentPointer(content.Group.Avatar.Id, content.Group.Avatar.ContentType, content.Group.Avatar.Key.ToByteArray(), envelope.getRelay()); } return new TextSecureGroup(type, content.Group.Id.ToByteArray(), name, members, avatar); } return new TextSecureGroup(content.Group.Id.ToByteArray()); }
private TextSecureDataMessage createTextSecureMessage(TextSecureEnvelope envelope, DataMessage content) { TextSecureGroup groupInfo = createGroupInfo(envelope, content); LinkedList<TextSecureAttachment> attachments = new LinkedList<TextSecureAttachment>(); bool endSession = ((content.Flags & (uint)DataMessage.Types.Flags.END_SESSION) != 0); foreach (AttachmentPointer pointer in content.AttachmentsList) { attachments.AddLast(new TextSecureAttachmentPointer(pointer.Id, pointer.ContentType, pointer.Key.ToByteArray(), envelope.getRelay(), pointer.HasSize ? new May<uint>(pointer.Size) : May<uint>.NoValue, pointer.HasThumbnail ? new May<byte[]>(pointer.Thumbnail.ToByteArray()) : May<byte[]>.NoValue)); } return new TextSecureDataMessage(envelope.getTimestamp(), groupInfo, attachments, content.Body, endSession); }
private void handleMessage(TextSecureEnvelope envelope, May<long> smsMessageId) { try { AxolotlStore axolotlStore = new TextSecureAxolotlStore(); TextSecureAddress localAddress = new TextSecureAddress(TextSecurePreferences.getLocalNumber()); TextSecureCipher cipher = new TextSecureCipher(localAddress, axolotlStore); TextSecureContent content = cipher.decrypt(envelope); if (content.getDataMessage().HasValue) { TextSecureDataMessage message = content.getDataMessage().ForceGetValue(); if (message.isEndSession()) handleEndSessionMessage(envelope, message, smsMessageId); else if (message.isGroupUpdate()) handleGroupMessage(envelope, message, smsMessageId); else if (message.getAttachments().HasValue) handleMediaMessage(envelope, message, smsMessageId); else handleTextMessage(envelope, message, smsMessageId); } /*else if (content.getSyncMessage().HasValue) TODO: SYNC enable { TextSecureSyncMessage syncMessage = content.getSyncMessage().ForceGetValue(); if (syncMessage.getSent().HasValue) handleSynchronizeSentMessage(masterSecret, syncMessage.getSent().ForceGetValue(), smsMessageId); else if (syncMessage.getRequest().HasValue) handleSynchronizeRequestMessage(masterSecret, syncMessage.getRequest().ForceGetValue()); }*/ if (envelope.isPreKeyWhisperMessage()) { App.Current.Worker.AddTaskActivities(new RefreshPreKeysTask()); //ApplicationContext.getInstance(context).getJobManager().add(new RefreshPreKeysJob(context)); } } catch (InvalidVersionException e) { Log.Warn(e); handleInvalidVersionMessage(envelope, smsMessageId); } catch (InvalidMessageException e) { Log.Warn(e); handleCorruptMessage(envelope, smsMessageId); } catch (InvalidKeyIdException e) { Log.Warn(e); handleCorruptMessage(envelope, smsMessageId); } catch (InvalidKeyException e) { Log.Warn(e); handleCorruptMessage(envelope, smsMessageId); } catch (NoSessionException e) { Log.Warn(e); handleNoSessionMessage(envelope, smsMessageId); } catch (LegacyMessageException e) { Log.Warn(e); handleLegacyMessage(envelope, smsMessageId); } catch (DuplicateMessageException e) { Log.Warn(e); handleDuplicateMessage(envelope, smsMessageId); } catch (libaxolotl.exceptions.UntrustedIdentityException e) { Log.Warn(e); handleUntrustedIdentityMessage(envelope, smsMessageId); } catch (Exception e) { Log.Warn($"Unexpected Exception"); } }
private void handleReceipt(TextSecureEnvelope envelope) { Log.Debug($"Received receipt: (XXXXX, {envelope.getTimestamp()})"); DatabaseFactory.getMessageDatabase().incrementDeliveryReceiptCount(envelope.getSource(), (long)envelope.getTimestamp()); }
private void OnMessageRecevied(TextSecureMessagePipe sender, TextSecureEnvelope envelope) { Log.Debug("Push message recieved"); var task = new PushContentReceiveTask(); task.handle(envelope, false); //throw new NotImplementedException("OnMessageReceived"); }
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 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 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 handleGroupMessage(TextSecureEnvelope envelope, TextSecureDataMessage message, May<long> smsMessageId) { //GroupMessageProcessor.process(envelope, message, false); // TODO: GROUP enable if (smsMessageId.HasValue) { DatabaseFactory.getTextMessageDatabase().DeleteThread(smsMessageId.ForceGetValue()); //getSmsDatabase(context).deleteMessage(smsMessageId.get()); } }
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 void handleSynchronizeSentMessage(TextSecureEnvelope envelope, SentTranscriptMessage message, May<long> smsMessageId) // throws MmsException { long threadId; if (message.getMessage().isGroupUpdate()) { throw new NotImplementedException("GROUP handleSynchronizeSentMessage"); //threadId = GroupMessageProcessor.process(context, masterSecret, envelope, message.getMessage(), true); // TODO: Group enable } else if (message.getMessage().getAttachments().HasValue) { threadId = handleSynchronizeSentMediaMessage(message, smsMessageId); } else { threadId = handleSynchronizeSentTextMessage(message, smsMessageId); } if (threadId == 0L) return; DatabaseFactory.getThreadDatabase().SetRead(threadId); //MessageNotifier.updateNotification(getContext(), masterSecret.getMasterSecret().orNull()); }
private TextSecureSyncMessage createSynchronizeMessage(TextSecureEnvelope envelope, SyncMessage content) { if (content.HasSent) { SyncMessage.Types.Sent sentContent = content.Sent; return TextSecureSyncMessage.forSentTranscript(new SentTranscriptMessage(sentContent.Destination, sentContent.Timestamp, createTextSecureMessage(envelope, sentContent.Message))); } if (content.HasRequest) { return TextSecureSyncMessage.forRequest(new RequestMessage(content.Request)); } return TextSecureSyncMessage.empty(); }
private void handleMediaMessage(TextSecureEnvelope envelope, TextSecureDataMessage message, May<long> smsMessageId) // throws MmsException { throw new NotImplementedException("handleMediaMessage"); /* var database = DatabaseFactory.getMediaMessageDatabase(); //getMmsDatabase(context); String localNumber = TextSecurePreferences.getLocalNumber(context); IncomingMediaMessage mediaMessage = new IncomingMediaMessage(masterSecret, envelope.getSource(), localNumber, message.getTimestamp(), Optional.fromNullable(envelope.getRelay()), message.getBody(), message.getGroupInfo(), message.getAttachments()); Pair<long, long> messageAndThreadId = database.insertSecureDecryptedMessageInbox(mediaMessage, -1); List<DatabaseAttachment> attachments = DatabaseFactory.getAttachmentDatabase(context).getAttachmentsForMessage(messageAndThreadId.first); for (DatabaseAttachment attachment : attachments) { ApplicationContext.getInstance(context) .getJobManager() .add(new AttachmentDownloadJob(context, messageAndThreadId.first, attachment.getAttachmentId())); } if (smsMessageId.isPresent()) { DatabaseFactory.getSmsDatabase(context).deleteMessage(smsMessageId.get()); } MessageNotifier.updateNotification(context, masterSecret.getMasterSecret().orNull(), messageAndThreadId.second);*/ }
/** * 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 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 processIncomingMessageRecord(MessageRecord record) { try { PushDatabase pushDatabase = DatabaseFactory.getPushDatabase(); var messageDatabase = DatabaseFactory.getMessageDatabase(); messageDatabase.RemoveMismatchedIdentity(record.MessageId, mismatch.RecipientId, mismatch.IdentityKey); TextSecureEnvelope envelope = new TextSecureEnvelope((uint)TextSecureProtos.Envelope.Types.Type.PREKEY_BUNDLE, record.IndividualRecipient.getNumber(), (uint)record.RecipientDeviceId, "", (ulong)TimeUtil.GetUnixTimestamp(record.DateSent), Base64.decode(record.Body.Body), null); long pushId = pushDatabase.Insert(envelope); var task = new PushDecryptTask(pushId, record.MessageId, record.IndividualRecipient.getNumber()); App.Current.Worker.AddTaskActivities(task); } catch (IOException e) { throw new Exception(); } }
public async Task<List<TextSecureEnvelope>> retrieveMessages(MessageReceivedCallback callback) { List<TextSecureEnvelope> results = new List<TextSecureEnvelope>(); List<TextSecureEnvelopeEntity> entities = await socket.getMessages(); foreach (TextSecureEnvelopeEntity entity in entities) { TextSecureEnvelope envelope = new TextSecureEnvelope(entity.getType(), entity.getSource(), entity.getSourceDevice(), entity.getRelay(), entity.getTimestamp(), entity.getMessage(), entity.getContent()); callback.onMessage(envelope); results.Add(envelope); socket.acknowledgeMessage(entity.getSource(), entity.getTimestamp()); } return results; }