private async Task <OutgoingPushMessage> GetEncryptedMessage(CancellationToken token,
PushServiceSocket socket,
SignalServiceAddress recipient,
UnidentifiedAccess?unidentifiedAccess,
uint deviceId,
byte[] plaintext)
{
SignalProtocolAddress signalProtocolAddress = new SignalProtocolAddress(recipient.E164number, deviceId);
SignalServiceCipher cipher = new SignalServiceCipher(LocalAddress, Store, null);
if (!Store.ContainsSession(signalProtocolAddress))
{
try
{
List <PreKeyBundle> preKeys = await socket.GetPreKeys(token, recipient, unidentifiedAccess, deviceId);
foreach (PreKeyBundle preKey in preKeys)
{
if (CredentialsProvider.User.Equals(recipient.E164number) && CredentialsProvider.DeviceId == preKey.getDeviceId())
{
continue;
}
try
{
SignalProtocolAddress preKeyAddress = new SignalProtocolAddress(recipient.E164number, preKey.getDeviceId());
SessionBuilder sessionBuilder = new SessionBuilder(Store, preKeyAddress);
sessionBuilder.process(preKey);
}
catch (libsignal.exceptions.UntrustedIdentityException)
{
throw new UntrustedIdentityException("Untrusted identity key!", recipient.E164number, preKey.getIdentityKey());
}
}
if (EventListener != null)
{
EventListener.OnSecurityEvent(recipient);
}
}
catch (InvalidKeyException e)
{
throw new Exception(e.Message);
}
}
try
{
return(cipher.Encrypt(signalProtocolAddress, unidentifiedAccess, plaintext));
}
catch (libsignal.exceptions.UntrustedIdentityException e)
{
throw new UntrustedIdentityException("Untrusted on send", e.getName(), e.getUntrustedIdentity());
}
}
private OutgoingPushMessage getEncryptedMessage(PushServiceSocket socket, SignalServiceAddress recipient, uint deviceId, byte[] plaintext, bool legacy, bool silent)
{
SignalProtocolAddress signalProtocolAddress = new SignalProtocolAddress(recipient.getNumber(), deviceId);
SignalServiceCipher cipher = new SignalServiceCipher(localAddress, store);
if (!store.ContainsSession(signalProtocolAddress))
{
try
{
List <PreKeyBundle> preKeys = socket.getPreKeys(recipient, deviceId);
foreach (PreKeyBundle preKey in preKeys)
{
if (CredentialsProvider.GetUser().Equals(recipient.getNumber()) && CredentialsProvider.GetDeviceId() == preKey.getDeviceId())
{
continue;
}
try
{
SignalProtocolAddress preKeyAddress = new SignalProtocolAddress(recipient.getNumber(), preKey.getDeviceId());
SessionBuilder sessionBuilder = new SessionBuilder(store, preKeyAddress);
sessionBuilder.process(preKey);
}
catch (libsignal.exceptions.UntrustedIdentityException e)
{
throw new UntrustedIdentityException("Untrusted identity key!", recipient.getNumber(), preKey.getIdentityKey());
}
}
if (eventListener != null)
{
eventListener.onSecurityEvent(recipient);
}
}
catch (InvalidKeyException e)
{
throw new Exception(e.Message);
}
}
return(cipher.encrypt(signalProtocolAddress, plaintext, legacy, silent));
}
private void HandleMessage(SignalServiceEnvelope envelope)
{
var cipher = new SignalServiceCipher(new SignalServiceAddress(App.Store.Username), new Store());
var content = cipher.decrypt(envelope);
long timestamp = Util.CurrentTimeMillis();
if (content.Message != null)
{
SignalServiceDataMessage message = content.Message;
if (message.EndSession)
{
HandleSessionResetMessage(envelope, content, message, false, timestamp);
}
else if (message.IsGroupUpdate())
{
if (message.Group.Type == SignalServiceGroup.GroupType.UPDATE)
{
HandleGroupUpdateMessage(envelope, content, message, false, timestamp);
}
}
else if (message.ExpirationUpdate)
{
HandleExpirationUpdateMessage(envelope, content, message, false, timestamp);
}
else
{
HandleSignalMessage(envelope, content, message, false, timestamp);
}
}
else if (content.SynchronizeMessage != null)
{
if (content.SynchronizeMessage.getSent().HasValue)
{
var syncMessage = content.SynchronizeMessage.getSent().ForceGetValue();
var dataMessage = syncMessage.getMessage();
if (dataMessage.EndSession)
{
HandleSessionResetMessage(envelope, content, dataMessage, true, timestamp);
}
else if (dataMessage.IsGroupUpdate())
{
if (dataMessage.Group.Type == SignalServiceGroup.GroupType.UPDATE)
{
HandleGroupUpdateMessage(envelope, content, dataMessage, true, timestamp);
}
}
else if (dataMessage.ExpirationUpdate)
{
HandleExpirationUpdateMessage(envelope, content, dataMessage, true, timestamp);
}
else
{
HandleSignalMessage(envelope, content, dataMessage, true, timestamp);
}
}
else if (content.SynchronizeMessage.getRead().HasValue)
{
var readMessages = content.SynchronizeMessage.getRead().ForceGetValue();
foreach (var readMessage in readMessages)
{
//TODO
}
}
} //TODO callmessages
else
{
Debug.WriteLine("HandleMessage got unrecognized message from " + envelope.getSource());
}
}
private async Task HandleMessage(SignalServiceEnvelope envelope)
{
var cipher = new SignalServiceCipher(new SignalServiceAddress(SignalLibHandle.Instance.Store.Username), new Store());
var content = cipher.Decrypt(envelope);
long timestamp = Util.CurrentTimeMillis();
if (content.Message != null)
{
SignalServiceDataMessage message = content.Message;
if (message.EndSession)
{
await HandleSessionResetMessage(envelope, content, message, false, timestamp);
}
else if (message.IsGroupUpdate())
{
if (message.Group.Type == SignalServiceGroup.GroupType.UPDATE)
{
await HandleGroupUpdateMessage(envelope, content, message, false, timestamp);
}
else if (message.Group.Type == SignalServiceGroup.GroupType.QUIT)
{
await HandleGroupLeaveMessage(envelope, content, message, false, timestamp);
}
else if (message.Group.Type == SignalServiceGroup.GroupType.REQUEST_INFO)
{
Logger.LogWarning("Received REQUEST_INFO request");
}
}
else if (message.ExpirationUpdate)
{
await HandleExpirationUpdateMessage(envelope, content, message, false, timestamp);
}
else
{
await HandleSignalMessage(envelope, content, message, false, timestamp);
}
}
else if (content.SynchronizeMessage != null)
{
if (content.SynchronizeMessage.Sent != null)
{
var syncMessage = content.SynchronizeMessage.Sent;
var dataMessage = syncMessage.Message;
if (dataMessage.EndSession)
{
await HandleSessionResetMessage(envelope, content, dataMessage, true, timestamp);
}
else if (dataMessage.IsGroupUpdate())
{
if (dataMessage.Group.Type == SignalServiceGroup.GroupType.UPDATE)
{
await HandleGroupUpdateMessage(envelope, content, dataMessage, true, timestamp);
}
else if (dataMessage.Group.Type == SignalServiceGroup.GroupType.QUIT)
{
await HandleGroupLeaveMessage(envelope, content, dataMessage, true, timestamp);
}
else if (dataMessage.Group.Type == SignalServiceGroup.GroupType.REQUEST_INFO)
{
Logger.LogWarning("Received synced REQUEST_INFO request");
}
}
else if (dataMessage.ExpirationUpdate)
{
await HandleExpirationUpdateMessage(envelope, content, dataMessage, true, timestamp);
}
else
{
await HandleSignalMessage(envelope, content, dataMessage, true, timestamp);
}
}
else if (content.SynchronizeMessage.Reads != null)
{
var readMessages = content.SynchronizeMessage.Reads;
foreach (var readMessage in readMessages)
{
try
{
await HandleSyncedReadMessage(readMessage);
}
catch (Exception e)
{
Logger.LogError("HandleReadMessage failed: {0}\n{1}", e.Message, e.StackTrace);
}
}
}
else if (content.SynchronizeMessage.BlockedList != null)
{
List <string> blockedNumbers = content.SynchronizeMessage.BlockedList.Numbers;
await HandleBlockedNumbers(blockedNumbers);
}
else if (content.SynchronizeMessage.Groups != null)
{
Logger.LogInformation("HandleMessage() handling groups sync message from device {0}", envelope.GetSourceDevice());
int read;
var avatarBuffer = new byte[4096];
var groups = content.SynchronizeMessage.Groups;
using (var tmpFile = LibUtils.CreateTmpFile("groups_sync"))
{
var plaintextStream = await MessageReceiver.RetrieveAttachment(Token, groups.AsPointer(), tmpFile, 10000, null);
var deviceGroupsStream = new DeviceGroupsInputStream(plaintextStream);
var groupsList = new List <(SignalGroup, IList <string>)>();
DeviceGroup g;
while ((g = deviceGroupsStream.Read()) != null)
{
if (g.Avatar != null)
{
SignalServiceAttachmentStream ssas = g.Avatar.AsStream();
while ((read = ssas.InputStream.Read(avatarBuffer, 0, avatarBuffer.Length)) > 0)
{
}
}
var group = new SignalGroup()
{
ThreadDisplayName = g.Name,
ThreadId = Base64.EncodeBytes(g.Id),
GroupMemberships = new List <GroupMembership>(),
CanReceive = true,
ExpiresInSeconds = g.ExpirationTimer != null ? g.ExpirationTimer.Value : 0
};
groupsList.Add((group, g.Members));
}
List <SignalConversation> dbGroups = await SignalDBContext.InsertOrUpdateGroups(groupsList);
await SignalLibHandle.Instance.DispatchAddOrUpdateConversations(dbGroups);
}
}
else if (content.SynchronizeMessage.Contacts != null && content.SynchronizeMessage.Contacts.Complete) //TODO incomplete updates
{
Logger.LogInformation("HandleMessage() handling contacts sync message from device {0}", envelope.GetSourceDevice());
int read;
var avatarBuffer = new byte[4096];
ContactsMessage contacts = content.SynchronizeMessage.Contacts;
using (var tmpFile = LibUtils.CreateTmpFile("contacts_sync"))
{
var plaintextStream = await MessageReceiver.RetrieveAttachment(Token, contacts.Contacts.AsPointer(), tmpFile, 10000, null);
var deviceContactsStream = new DeviceContactsInputStream(plaintextStream);
List <SignalContact> contactsList = new List <SignalContact>();
DeviceContact c;
while ((c = deviceContactsStream.Read()) != null)
{
if (c.Avatar != null)
{
SignalServiceAttachmentStream ssas = c.Avatar.AsStream();
while ((read = ssas.InputStream.Read(avatarBuffer, 0, avatarBuffer.Length)) > 0)
{
}
}
SignalContact contact = new SignalContact()
{
ThreadDisplayName = c.Name,
ThreadId = c.Number,
Color = c.Color,
CanReceive = true,
ExpiresInSeconds = c.ExpirationTimer != null ? c.ExpirationTimer.Value : 0
};
contactsList.Add(contact);
}
var dbContacts = SignalDBContext.InsertOrUpdateContacts(contactsList);
await SignalLibHandle.Instance.DispatchAddOrUpdateConversations(dbContacts);
}
}
}
else if (content.ReadMessage != null)
{
SignalServiceReceiptMessage receiptMessage = content.ReadMessage;
Logger.LogTrace("HandleMessage() received ReceiptMessage (type={0}, when={1})", receiptMessage.ReceiptType, receiptMessage.When);
}
else
{
//TODO callmessages
Logger.LogWarning("HandleMessage() received unrecognized message");
}
}
private void handleMessage(SignalServiceEnvelope envelope, May <long> smsMessageId)
{
try
{
SignalProtocolStore axolotlStore = new TextSecureAxolotlStore();
SignalServiceAddress localAddress = new SignalServiceAddress(TextSecurePreferences.getLocalNumber());
SignalServiceCipher cipher = new SignalServiceCipher(localAddress, axolotlStore);
SignalServiceContent content = cipher.decrypt(envelope);
if (content.getDataMessage().HasValue)
{
SignalServiceDataMessage 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.isPreKeySignalMessage())
{
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 (libsignal.exceptions.UntrustedIdentityException e)
{
Log.Warn(e);
handleUntrustedIdentityMessage(envelope, smsMessageId);
}
catch (Exception e)
{
Log.Warn($"Unexpected Exception");
}
}
