private byte[] createMultiDeviceSentTranscriptContent(byte[] content, May <SignalServiceAddress> recipient, ulong timestamp) { try { Content.Builder container = Content.CreateBuilder(); SyncMessage.Builder syncMessage = SyncMessage.CreateBuilder(); SyncMessage.Types.Sent.Builder sentMessage = SyncMessage.Types.Sent.CreateBuilder(); DataMessage dataMessage = DataMessage.ParseFrom(content); sentMessage.SetTimestamp(timestamp); sentMessage.SetMessage(dataMessage); if (recipient.HasValue) { sentMessage.SetDestination(recipient.ForceGetValue().getNumber()); } if (dataMessage.ExpireTimer > 0) { sentMessage.SetExpirationStartTimestamp((ulong)Util.CurrentTimeMillis()); } return(container.SetSyncMessage(syncMessage.SetSent(sentMessage)).Build().ToByteArray()); } catch (InvalidProtocolBufferException e) { throw new Exception(e.Message); } }
private SenderKeyState(uint id, uint iteration, byte[] chainKey, IEcPublicKey signatureKeyPublic, May <IEcPrivateKey> signatureKeyPrivate) { SenderKeyStateStructure.Types.SenderChainKey senderChainKeyStructure = new SenderKeyStateStructure.Types.SenderChainKey { Iteration = iteration, Seed = ByteString.CopyFrom(chainKey) }; SenderKeyStateStructure.Types.SenderSigningKey signingKeyStructure = new SenderKeyStateStructure.Types.SenderSigningKey { Public = ByteString.CopyFrom(signatureKeyPublic.Serialize()) }; if (signatureKeyPrivate.HasValue) { signingKeyStructure.Private = ByteString.CopyFrom(signatureKeyPrivate.ForceGetValue().Serialize()); } _senderKeyStateStructure = new SenderKeyStateStructure { SenderKeyId = id, SenderChainKey = senderChainKeyStructure, SenderSigningKey = signingKeyStructure }; }
private byte[] CreateSentTranscriptMessage(byte[] rawContent, May <SignalServiceAddress> recipient, ulong timestamp) { { try { Content content = new Content { }; SyncMessage syncMessage = new SyncMessage { }; SyncMessage.Types.Sent sentMessage = new SyncMessage.Types.Sent { }; sentMessage.Timestamp = timestamp; sentMessage.Message = DataMessage.Parser.ParseFrom(rawContent); if (recipient.HasValue) { sentMessage.Destination = recipient.ForceGetValue().E164number; } syncMessage.Sent = sentMessage; content.SyncMessage = syncMessage; return(content.ToByteArray()); } catch (InvalidProtocolBufferException e) { throw new Exception(e.Message); } } }
private void handleEndSessionMessage(SignalServiceEnvelope envelope, SignalServiceDataMessage message, May <long> smsMessageId) { var smsDatabase = DatabaseFactory.getTextMessageDatabase();//getEncryptingSmsDatabase(context); var incomingTextMessage = new IncomingTextMessage(envelope.getSource(), envelope.getSourceDevice(), message.getTimestamp(), "", May <SignalServiceGroup> .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 byte[] createSentTranscriptMessage(byte[] content, May <SignalServiceAddress> recipient, ulong timestamp) { { try { Content.Builder container = Content.CreateBuilder(); SyncMessage.Builder syncMessage = SyncMessage.CreateBuilder(); SyncMessage.Types.Sent.Builder sentMessage = SyncMessage.Types.Sent.CreateBuilder(); sentMessage.SetTimestamp(timestamp); sentMessage.SetMessage(DataMessage.ParseFrom(content)); if (recipient.HasValue) { sentMessage.SetDestination(recipient.ForceGetValue().getNumber()); } return(container.SetSyncMessage(syncMessage.SetSent(sentMessage)).Build().ToByteArray());; } catch (InvalidProtocolBufferException e) { throw new Exception(e.Message); } } }
public PreKeySignalMessage(uint messageVersion, uint registrationId, May <uint> preKeyId, uint signedPreKeyId, ECPublicKey baseKey, IdentityKey identityKey, SignalMessage message) { this.version = messageVersion; this.registrationId = registrationId; this.preKeyId = preKeyId; this.signedPreKeyId = signedPreKeyId; this.baseKey = baseKey; this.identityKey = identityKey; this.message = message; PreKeySignalMessage preKeySignalMessage = new PreKeySignalMessage { SignedPreKeyId = signedPreKeyId, BaseKey = ByteString.CopyFrom(baseKey.serialize()), IdentityKey = ByteString.CopyFrom(identityKey.serialize()), Message = ByteString.CopyFrom(message.serialize()), RegistrationId = registrationId }; if (preKeyId.HasValue) // .isPresent() { preKeySignalMessage.PreKeyId = preKeyId.ForceGetValue(); // get() } byte[] versionBytes = { ByteUtil.intsToByteHighAndLow((int)this.version, (int)CURRENT_VERSION) }; byte[] messageBytes = preKeySignalMessage.ToByteArray(); this.serialized = ByteUtil.combine(versionBytes, messageBytes); }
private SenderKeyState(uint id, uint iteration, byte[] chainKey, ECPublicKey signatureKeyPublic, May <ECPrivateKey> signatureKeyPrivate) { SenderKeyStateStructure.Types.SenderChainKey senderChainKeyStructure = SenderKeyStateStructure.Types.SenderChainKey.CreateBuilder() .SetIteration(iteration) .SetSeed(ByteString.CopyFrom(chainKey)) .Build(); SenderKeyStateStructure.Types.SenderSigningKey.Builder signingKeyStructure = SenderKeyStateStructure.Types.SenderSigningKey.CreateBuilder() .SetPublic(ByteString.CopyFrom(signatureKeyPublic.Serialize())); if (signatureKeyPrivate.HasValue) { signingKeyStructure.SetPrivate(ByteString.CopyFrom(signatureKeyPrivate.ForceGetValue().Serialize())); } this.senderKeyStateStructure = SenderKeyStateStructure.CreateBuilder() .SetSenderKeyId(id) .SetSenderChainKey(senderChainKeyStructure) .SetSenderSigningKey(signingKeyStructure) .Build(); }
public PreKeySignalMessage(uint messageVersion, uint registrationId, May <uint> preKeyId, uint signedPreKeyId, ECPublicKey baseKey, IdentityKey identityKey, SignalMessage message) { this.version = messageVersion; this.registrationId = registrationId; this.preKeyId = preKeyId; this.signedPreKeyId = signedPreKeyId; this.baseKey = baseKey; this.identityKey = identityKey; this.message = message; WhisperProtos.PreKeySignalMessage.Builder builder = WhisperProtos.PreKeySignalMessage.CreateBuilder() .SetSignedPreKeyId(signedPreKeyId) .SetBaseKey(ByteString.CopyFrom(baseKey.serialize())) .SetIdentityKey(ByteString.CopyFrom(identityKey.serialize())) .SetMessage(ByteString.CopyFrom(message.serialize())) .SetRegistrationId(registrationId); if (preKeyId.HasValue) // .isPresent() { builder.SetPreKeyId(preKeyId.ForceGetValue()); // get() } byte[] versionBytes = { ByteUtil.intsToByteHighAndLow((int)this.version, (int)CURRENT_VERSION) }; byte[] messageBytes = builder.Build().ToByteArray(); this.serialized = ByteUtil.combine(versionBytes, messageBytes); }
private byte[] CreateMultiDeviceSentTranscriptContent(byte[] rawContent, May <SignalServiceAddress> recipient, ulong timestamp) { try { Content content = new Content { }; SyncMessage syncMessage = CreateSyncMessage(); SyncMessage.Types.Sent sentMessage = new SyncMessage.Types.Sent { }; DataMessage dataMessage = Content.Parser.ParseFrom(rawContent).DataMessage; sentMessage.Timestamp = timestamp; sentMessage.Message = dataMessage; if (recipient.HasValue) { sentMessage.Destination = recipient.ForceGetValue().E164number; } if (dataMessage.ExpireTimer > 0) { sentMessage.ExpirationStartTimestamp = (ulong)Util.CurrentTimeMillis(); } syncMessage.Sent = sentMessage; content.SyncMessage = syncMessage; return(content.ToByteArray()); } catch (InvalidProtocolBufferException e) { throw new Exception(e.Message); } }
public PreKeySignalMessage(uint messageVersion, uint registrationId, May <uint> preKeyId, uint signedPreKeyId, IEcPublicKey baseKey, IdentityKey identityKey, SignalMessage message) { _version = messageVersion; _registrationId = registrationId; _preKeyId = preKeyId; _signedPreKeyId = signedPreKeyId; _baseKey = baseKey; _identityKey = identityKey; _message = message; PreKeySignalMessage preKeySignalMessage = new PreKeySignalMessage { SignedPreKeyId = signedPreKeyId, BaseKey = ByteString.CopyFrom(baseKey.Serialize()), IdentityKey = ByteString.CopyFrom(identityKey.Serialize()), Message = ByteString.CopyFrom(message.Serialize()), RegistrationId = registrationId }; if (preKeyId.HasValue) // .isPresent() { preKeySignalMessage.PreKeyId = preKeyId.ForceGetValue(); // get() } byte[] versionBytes = { ByteUtil.IntsToByteHighAndLow((int)_version, (int)CurrentVersion) }; byte[] messageBytes = preKeySignalMessage.ToByteArray(); _serialized = ByteUtil.Combine(versionBytes, messageBytes); }
private SenderKeyState(uint id, uint iteration, byte[] chainKey, ECPublicKey signatureKeyPublic, May<ECPrivateKey> signatureKeyPrivate) { SenderKeyStateStructure.Types.SenderChainKey senderChainKeyStructure = SenderKeyStateStructure.Types.SenderChainKey.CreateBuilder() .SetIteration(iteration) .SetSeed(ByteString.CopyFrom(chainKey)) .Build(); SenderKeyStateStructure.Types.SenderSigningKey.Builder signingKeyStructure = SenderKeyStateStructure.Types.SenderSigningKey.CreateBuilder() .SetPublic(ByteString.CopyFrom(signatureKeyPublic.serialize())); if (signatureKeyPrivate.HasValue) { signingKeyStructure.SetPrivate(ByteString.CopyFrom(signatureKeyPrivate.ForceGetValue().serialize())); } this.senderKeyStateStructure = SenderKeyStateStructure.CreateBuilder() .SetSenderKeyId(id) .SetSenderChainKey(senderChainKeyStructure) .SetSenderSigningKey(signingKeyStructure) .Build(); }
public PreKeySignalMessage(uint messageVersion, uint registrationId, May <uint> preKeyId, uint signedPreKeyId, IEcPublicKey baseKey, IdentityKey identityKey, SignalMessage message) { _version = messageVersion; _registrationId = registrationId; _preKeyId = preKeyId; _signedPreKeyId = signedPreKeyId; _baseKey = baseKey; _identityKey = identityKey; _message = message; WhisperProtos.PreKeySignalMessage.Builder builder = WhisperProtos.PreKeySignalMessage.CreateBuilder() .SetSignedPreKeyId(signedPreKeyId) .SetBaseKey(ByteString.CopyFrom(baseKey.Serialize())) .SetIdentityKey(ByteString.CopyFrom(identityKey.Serialize())) .SetMessage(ByteString.CopyFrom(message.Serialize())) .SetRegistrationId(registrationId); if (preKeyId.HasValue) // .isPresent() { builder.SetPreKeyId(preKeyId.ForceGetValue()); // get() } byte[] versionBytes = { ByteUtil.IntsToByteHighAndLow((int)_version, (int)CurrentVersion) }; byte[] messageBytes = builder.Build().ToByteArray(); _serialized = ByteUtil.Combine(versionBytes, messageBytes); }
private void handleGroupMessage(SignalServiceEnvelope envelope, SignalServiceDataMessage 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()); } }
/** * Register/Unregister a Google Cloud Messaging registration ID. * * @param gcmRegistrationId The GCM id to register. A call with an absent value will unregister. * @throws IOException */ public async Task<bool> setWnsId(May<String> wnsRegistrationId)// throws IOException { if (wnsRegistrationId.HasValue) { return await this.pushServiceSocket.registerWnsId(wnsRegistrationId.ForceGetValue()); } else { return await this.pushServiceSocket.unregisterWnsId(); } }
/// <summary> /// Register/Unregister a Google Cloud Messaging registration ID. /// </summary> /// <param name="gcmRegistrationId">The GCM id to register. A call with an absent value will unregister.</param> /// <returns></returns> public void setGcmId(May <string> gcmRegistrationId)// throws IOException { if (gcmRegistrationId.HasValue) { this.pushServiceSocket.registerGcmId(gcmRegistrationId.ForceGetValue()); } else { this.pushServiceSocket.unregisterGcmId(); } }
private bool equals(May <String> one, May <String> two) { if (one.HasValue) { return(two.HasValue && one.ForceGetValue().Equals(two.ForceGetValue())); } else { return(!two.HasValue); } }
/// <summary> /// Register/Unregister a Google Cloud Messaging registration ID. /// </summary> /// <param name="wnsRegistrationId">The GCM id to register. A call with an absent value will unregister.</param> /// <returns></returns> public async Task <bool> setWnsId(May <string> wnsRegistrationId)// throws IOException { if (wnsRegistrationId.HasValue) { return(await this.pushServiceSocket.registerWnsId(wnsRegistrationId.ForceGetValue())); } else { return(await this.pushServiceSocket.unregisterWnsId()); } }
public bool sendReceipt(string destination, ulong messageId, May <string> relay)// throws IOException { string path = string.Format(RECEIPT_PATH, destination, messageId); if (relay.HasValue) { path += "?relay=" + relay.ForceGetValue(); } makeRequest(path, "PUT", null); return(true); }
private async Task <IList <AttachmentPointer> > createAttachmentPointers(May <List <SignalServiceAttachment> > attachments) { IList <AttachmentPointer> pointers = new List <AttachmentPointer>(); if (!attachments.HasValue || attachments.ForceGetValue().Count == 0) { Debug.WriteLine("No attachments present...", TAG); return(pointers); } foreach (SignalServiceAttachment attachment in attachments.ForceGetValue()) { if (attachment.isStream()) { Debug.WriteLine("Found attachment, creating pointer...", TAG); pointers.Add(await createAttachmentPointer(attachment.asStream())); } } return(pointers); }
private void handleLegacyMessage(SignalServiceEnvelope 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 SetUnacknowledgedPreKeyMessage(May <uint> preKeyId, uint signedPreKeyId, IEcPublicKey baseKey) { SessionStructure.Types.PendingPreKey pending = new SessionStructure.Types.PendingPreKey { SignedPreKeyId = (int)signedPreKeyId, BaseKey = ByteString.CopyFrom(baseKey.Serialize()) }; if (preKeyId.HasValue) { pending.PreKeyId = preKeyId.ForceGetValue(); } _sessionStructure.PendingPreKey = pending; }
private async static Task <bool> isPushDestination(String destination) { TextSecureDirectory directory = DatabaseFactory.getDirectoryDatabase(); try { return(directory.isActiveNumber(destination)); } catch (/*NotInDirectory*/ Exception e) { try { TextSecureAccountManager accountManager = TextSecureCommunicationFactory.createManager(); May <ContactTokenDetails> registeredUser = await App.Current.accountManager.getContact(destination); if (!registeredUser.HasValue) { registeredUser = new May <ContactTokenDetails>(new ContactTokenDetails()); registeredUser.ForceGetValue().setNumber(destination); directory.setNumber(registeredUser.ForceGetValue(), false); return(false); } else { registeredUser.ForceGetValue().setNumber(destination); directory.setNumber(registeredUser.ForceGetValue(), true); return(true); } } catch (Exception e1) { //Log.w(TAG, e1); return(false); } } }
public void SetUnacknowledgedPreKeyMessage(May <uint> preKeyId, uint signedPreKeyId, IEcPublicKey baseKey) { StorageProtos.SessionStructure.Types.PendingPreKey.Builder pending = StorageProtos.SessionStructure.Types.PendingPreKey.CreateBuilder() .SetSignedPreKeyId((int)signedPreKeyId) .SetBaseKey(ByteString.CopyFrom(baseKey.Serialize())); if (preKeyId.HasValue) { pending.SetPreKeyId(preKeyId.ForceGetValue()); } _sessionStructure = _sessionStructure.ToBuilder() .SetPendingPreKey(pending.Build()) .Build(); }
public void setUnacknowledgedPreKeyMessage(May <uint> preKeyId, uint signedPreKeyId, ECPublicKey baseKey) { PendingPreKey.Builder pending = PendingPreKey.CreateBuilder() .SetSignedPreKeyId(signedPreKeyId) .SetBaseKey(ByteString.CopyFrom(baseKey.serialize())); if (preKeyId.HasValue) { pending.SetPreKeyId(preKeyId.ForceGetValue()); } this.sessionStructure = this.sessionStructure.ToBuilder() .SetPendingPreKey(pending.Build()) .Build(); }
public static Recipients getRecipientsFromString(String rawText, bool asynchronous) { var tokens = rawText.Split(','); List <String> ids = new List <string>(); foreach (var token in tokens) { May <long> id = getRecipientIdFromNumber(token); if (id.HasValue) { ids.Add(Convert.ToString(id.ForceGetValue())); } } return(getRecipientsForIds(ids, asynchronous)); }
/** * Decrypt a message. * * @param ciphertext The {@link PreKeyWhisperMessage} to decrypt. * @param callback A callback that is triggered after decryption is complete, * but before the updated session state has been committed to the session * DB. This allows some implementations to store the committed plaintext * to a DB first, in case they are concerned with a crash happening between * the time the session state is updated but before they're able to store * the plaintext to disk. * * @return The plaintext. * @throws InvalidMessageException if the input is not valid ciphertext. * @throws DuplicateMessageException if the input is a message that has already been received. * @throws LegacyMessageException if the input is a message formatted by a protocol version that * is no longer supported. * @throws InvalidKeyIdException when there is no local {@link org.whispersystems.libaxolotl.state.PreKeyRecord} * that corresponds to the PreKey ID in the message. * @throws InvalidKeyException when the message is formatted incorrectly. * @throws UntrustedIdentityException when the {@link IdentityKey} of the sender is untrusted. */ public byte[] decrypt(PreKeyWhisperMessage ciphertext, DecryptionCallback callback) { lock (SESSION_LOCK) { SessionRecord sessionRecord = sessionStore.loadSession(remoteAddress); May <uint> unsignedPreKeyId = sessionBuilder.process(sessionRecord, ciphertext); byte[] plaintext = decrypt(sessionRecord, ciphertext.getWhisperMessage()); callback.handlePlaintext(plaintext); sessionStore.storeSession(remoteAddress, sessionRecord); if (unsignedPreKeyId.HasValue) { preKeyStore.removePreKey(unsignedPreKeyId.ForceGetValue()); } return(plaintext); } }
/** * Decrypt a message. * * @param ciphertext The {@link PreKeySignalMessage} to decrypt. * @param callback A callback that is triggered after decryption is complete, * but before the updated session state has been committed to the session * DB. This allows some implementations to store the committed plaintext * to a DB first, in case they are concerned with a crash happening between * the time the session state is updated but before they're able to store * the plaintext to disk. * * @return The plaintext. * @throws InvalidMessageException if the input is not valid ciphertext. * @throws DuplicateMessageException if the input is a message that has already been received. * @throws LegacyMessageException if the input is a message formatted by a protocol version that * is no longer supported. * @throws InvalidKeyIdException when there is no local {@link org.whispersystems.libsignal.state.PreKeyRecord} * that corresponds to the PreKey ID in the message. * @throws InvalidKeyException when the message is formatted incorrectly. * @throws UntrustedIdentityException when the {@link IdentityKey} of the sender is untrusted. */ public byte[] Decrypt(PreKeySignalMessage ciphertext, IDecryptionCallback callback) { lock (SessionLock) { SessionRecord sessionRecord = _sessionStore.LoadSession(_remoteAddress); May <uint> unsignedPreKeyId = _sessionBuilder.Process(sessionRecord, ciphertext); byte[] plaintext = Decrypt(sessionRecord, ciphertext.GetSignalMessage()); callback.HandlePlaintext(plaintext); _sessionStore.StoreSession(_remoteAddress, sessionRecord); if (unsignedPreKeyId.HasValue) { _preKeyStore.RemovePreKey(unsignedPreKeyId.ForceGetValue()); } return(plaintext); } }
private long handleSynchronizeSentTextMessage(SentTranscriptMessage message, May <long> smsMessageId) { var textMessageDatabase = DatabaseFactory.getTextMessageDatabase();//getEncryptingSmsDatabase(context); Recipients recipients = getSyncMessageDestination(message); String body = message.getMessage().getBody().HasValue ? message.getMessage().getBody().ForceGetValue() : ""; OutgoingTextMessage outgoingTextMessage = new OutgoingTextMessage(recipients, body); long threadId = DatabaseFactory.getThreadDatabase().GetThreadIdForRecipients(recipients); long messageId = textMessageDatabase.InsertMessageOutbox(threadId, outgoingTextMessage, TimeUtil.GetDateTime(message.getTimestamp())); textMessageDatabase.MarkAsSent(messageId); textMessageDatabase.MarkAsPush(messageId); textMessageDatabase.MarkAsSecure(messageId); if (smsMessageId.HasValue) { textMessageDatabase.Delete(smsMessageId.ForceGetValue()); } return(threadId); }
/** * Decrypt a message. * * @param ciphertext The {@link PreKeySignalMessage} to decrypt. * @param callback A callback that is triggered after decryption is complete, * but before the updated session state has been committed to the session * DB. This allows some implementations to store the committed plaintext * to a DB first, in case they are concerned with a crash happening between * the time the session state is updated but before they're able to store * the plaintext to disk. * * @return The plaintext. * @throws InvalidMessageException if the input is not valid ciphertext. * @throws DuplicateMessageException if the input is a message that has already been received. * @throws LegacyMessageException if the input is a message formatted by a protocol version that * is no longer supported. * @throws InvalidKeyIdException when there is no local {@link org.whispersystems.libsignal.state.PreKeyRecord} * that corresponds to the PreKey ID in the message. * @throws InvalidKeyException when the message is formatted incorrectly. * @throws UntrustedIdentityException when the {@link IdentityKey} of the sender is untrusted. */ public byte[] decrypt(PreKeySignalMessage ciphertext, DecryptionCallback callback) { lock (SESSION_LOCK) { SessionRecord sessionRecord = sessionStore.LoadSession(remoteAddress); May <uint> unsignedPreKeyId = sessionBuilder.process(sessionRecord, ciphertext); byte[] plaintext = decrypt(sessionRecord, ciphertext.getSignalMessage()); identityKeyStore.SaveIdentity(remoteAddress, sessionRecord.getSessionState().getRemoteIdentityKey()); callback.handlePlaintext(plaintext); sessionStore.StoreSession(remoteAddress, sessionRecord); if (unsignedPreKeyId.HasValue) { preKeyStore.RemovePreKey(unsignedPreKeyId.ForceGetValue()); } return(plaintext); } }
private void handleUntrustedIdentityMessage(SignalServiceEnvelope envelope, May <long> smsMessageId) { try { var database = DatabaseFactory.getTextMessageDatabase(); //getEncryptingSmsDatabase(context); Recipients recipients = RecipientFactory.getRecipientsFromString(envelope.getSource(), false); long recipientId = recipients.getPrimaryRecipient().getRecipientId(); PreKeySignalMessage whisperMessage = new PreKeySignalMessage(envelope.getLegacyMessage()); IdentityKey identityKey = whisperMessage.getIdentityKey(); String encoded = Base64.encodeBytes(envelope.getLegacyMessage()); IncomingTextMessage textMessage = new IncomingTextMessage(envelope.getSource(), envelope.getSourceDevice(), envelope.getTimestamp(), encoded, May <SignalServiceGroup> .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); } }
/*public IncomingTextMessage(SmsMessage message) * { * this.message = message.getDisplayMessageBody(); * this.sender = message.getDisplayOriginatingAddress(); * this.senderDeviceId = TextSecureAddress.DEFAULT_DEVICE_ID; * this.protocol = message.getProtocolIdentifier(); * this.serviceCenterAddress = message.getServiceCenterAddress(); * this.replyPathPresent = message.isReplyPathPresent(); * this.pseudoSubject = message.getPseudoSubject(); * this.sentTimestampMillis = message.getTimestampMillis(); * this.groupId = null; * this.push = false; * }*/ public IncomingTextMessage(String sender, int senderDeviceId, long sentTimestampMillis, String encodedBody, May <SignalServiceGroup> group) { this.Message = encodedBody; this.Sender = sender; this.SenderDeviceId = senderDeviceId; this.Protocol = 31337; this.ServiceCenterAddress = "GCM"; this.ReplyPathPresent = true; this.PseudoSubject = ""; this.SentTimestampMillis = sentTimestampMillis; this.Push = true; if (group.HasValue) { this.GroupId = GroupUtil.getEncodedId(group.ForceGetValue().getGroupId()); } else { this.GroupId = null; } }
public async Task<bool> sendReceipt(String destination, ulong messageId, May<string> relay)// throws IOException { String path = string.Format(RECEIPT_PATH, destination, messageId); if (relay.HasValue) { path += "?relay=" + relay.ForceGetValue(); } await makeRequest(path, "PUT", null); return true; }
/*public IncomingTextMessage(SmsMessage message) { this.message = message.getDisplayMessageBody(); this.sender = message.getDisplayOriginatingAddress(); this.senderDeviceId = TextSecureAddress.DEFAULT_DEVICE_ID; this.protocol = message.getProtocolIdentifier(); this.serviceCenterAddress = message.getServiceCenterAddress(); this.replyPathPresent = message.isReplyPathPresent(); this.pseudoSubject = message.getPseudoSubject(); this.sentTimestampMillis = message.getTimestampMillis(); this.groupId = null; this.push = false; }*/ public IncomingTextMessage(String sender, uint senderDeviceId, ulong sentTimestampMillis, String encodedBody, May<TextSecureGroup> group) { this.Message = encodedBody; this.Sender = sender; this.SenderDeviceId = senderDeviceId; this.Protocol = 31337; this.ServiceCenterAddress = "GCM"; this.ReplyPathPresent = true; this.PseudoSubject = ""; this.SentTimestampMillis = sentTimestampMillis; this.Push = true; if (group.HasValue) { this.GroupId = GroupUtil.getEncodedId(group.ForceGetValue().getGroupId()); } else { this.GroupId = null; } }
private long handleSynchronizeSentTextMessage(SentTranscriptMessage message, May<long> smsMessageId) { var textMessageDatabase = DatabaseFactory.getTextMessageDatabase();//getEncryptingSmsDatabase(context); Recipients recipients = getSyncMessageDestination(message); String body = message.getMessage().getBody().HasValue ? message.getMessage().getBody().ForceGetValue() : ""; OutgoingTextMessage outgoingTextMessage = new OutgoingTextMessage(recipients, body); long threadId = DatabaseFactory.getThreadDatabase().GetThreadIdForRecipients(recipients); long messageId = textMessageDatabase.InsertMessageOutbox(threadId, outgoingTextMessage, TimeUtil.GetDateTime(message.getTimestamp())); textMessageDatabase.MarkAsSent(messageId); textMessageDatabase.MarkAsPush(messageId); textMessageDatabase.MarkAsSecure(messageId); if (smsMessageId.HasValue) { textMessageDatabase.Delete(smsMessageId.ForceGetValue()); } return threadId; }
private bool equals(May<String> one, May<String> two) { if (one.HasValue) { return two.HasValue && one.ForceGetValue().Equals(two.ForceGetValue()); } else return !two.HasValue; }
private HttpResponseMessage getConnection(string urlFragment, string method, string body) { try { SignalConnectionInformation connectionInformation = getRandom(signalConnectionInformation); string url = connectionInformation.getUrl(); May <string> hostHeader = connectionInformation.getHostHeader(); Uri uri = new Uri(string.Format("{0}{1}", url, urlFragment)); Debug.WriteLine("{0}: Uri {1}", TAG, uri); HttpClient connection = new HttpClient(); var headers = connection.DefaultRequestHeaders; if (credentialsProvider.GetPassword() != null) { string authHeader = getAuthorizationHeader(); Debug.WriteLine(String.Format("Authorization: {0}", authHeader), TAG); headers.Add("Authorization", authHeader); } if (userAgent != null) { headers.Add("X-Signal-Agent", userAgent); } if (hostHeader.HasValue) { headers.Host = hostHeader.ForceGetValue(); } StringContent content; if (body != null) { content = new StringContent(body, Encoding.UTF8, "application/json"); Debug.WriteLine(body); } else { content = new StringContent(""); } switch (method) { case "POST": return(connection.PostAsync(uri, content).Result); case "PUT": return(connection.PutAsync(uri, content).Result); case "DELETE": return(connection.DeleteAsync(uri).Result); case "GET": return(connection.GetAsync(uri).Result); default: throw new Exception("Unknown method: " + method); } } catch (Exception e) { Debug.WriteLine("getConnection() failed:", TAG); Debug.WriteLine(e.Message); Debug.WriteLine(e.StackTrace); throw new PushNetworkException(e); } }
public PreKeyWhisperMessage(uint messageVersion, uint registrationId, May<uint> preKeyId, uint signedPreKeyId, ECPublicKey baseKey, IdentityKey identityKey, WhisperMessage message) { this.version = messageVersion; this.registrationId = registrationId; this.preKeyId = preKeyId; this.signedPreKeyId = signedPreKeyId; this.baseKey = baseKey; this.identityKey = identityKey; this.message = message; WhisperProtos.PreKeyWhisperMessage.Builder builder = WhisperProtos.PreKeyWhisperMessage.CreateBuilder() .SetSignedPreKeyId(signedPreKeyId) .SetBaseKey(ByteString.CopyFrom(baseKey.serialize())) .SetIdentityKey(ByteString.CopyFrom(identityKey.serialize())) .SetMessage(ByteString.CopyFrom(message.serialize())) .SetRegistrationId(registrationId); if (preKeyId.HasValue) // .isPresent() { builder.SetPreKeyId(preKeyId.ForceGetValue()); // get() } byte[] versionBytes = { ByteUtil.intsToByteHighAndLow((int)this.version, (int)CURRENT_VERSION) }; byte[] messageBytes = builder.Build().ToByteArray(); this.serialized = ByteUtil.combine(versionBytes, messageBytes); }
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 IList<AttachmentPointer> createAttachmentPointers(May<LinkedList<TextSecureAttachment>> attachments) { IList<AttachmentPointer> pointers = new List<AttachmentPointer>(); if (!attachments.HasValue || attachments.ForceGetValue().Count == 0) { Debug.WriteLine("No attachments present...", TAG); return pointers; } foreach (TextSecureAttachment attachment in attachments.ForceGetValue()) { if (attachment.isStream()) { Debug.WriteLine("Found attachment, creating pointer...", TAG); pointers.Add(createAttachmentPointer(attachment.asStream())); } } return pointers; }
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 async static Task<bool> isPushDestination(String destination) { TextSecureDirectory directory = DatabaseFactory.getDirectoryDatabase(); try { return directory.isActiveNumber(destination); } catch (/*NotInDirectory*/Exception e) { try { TextSecureAccountManager accountManager = TextSecureCommunicationFactory.createManager(); May<ContactTokenDetails> registeredUser = await App.Current.accountManager.getContact(destination); if (!registeredUser.HasValue) { registeredUser = new May<ContactTokenDetails>(new ContactTokenDetails()); registeredUser.ForceGetValue().setNumber(destination); directory.setNumber(registeredUser.ForceGetValue(), false); return false; } else { registeredUser.ForceGetValue().setNumber(destination); directory.setNumber(registeredUser.ForceGetValue(), true); return true; } } catch (Exception e1) { //Log.w(TAG, e1); return false; } } }
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 setUnacknowledgedPreKeyMessage(May<uint> preKeyId, uint signedPreKeyId, ECPublicKey baseKey) { PendingPreKey.Builder pending = PendingPreKey.CreateBuilder() .SetSignedPreKeyId(signedPreKeyId) .SetBaseKey(ByteString.CopyFrom(baseKey.serialize())); if (preKeyId.HasValue) { pending.SetPreKeyId(preKeyId.ForceGetValue()); } this.sessionStructure = this.sessionStructure.ToBuilder() .SetPendingPreKey(pending.Build()) .Build(); }
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 byte[] createSentTranscriptMessage(byte[] content, May<TextSecureAddress> recipient, ulong timestamp) { { try { Content.Builder container = Content.CreateBuilder(); SyncMessage.Builder syncMessage = SyncMessage.CreateBuilder(); SyncMessage.Types.Sent.Builder sentMessage = SyncMessage.Types.Sent.CreateBuilder(); sentMessage.SetTimestamp(timestamp); sentMessage.SetMessage(DataMessage.ParseFrom(content)); if (recipient.HasValue) { sentMessage.SetDestination(recipient.ForceGetValue().getNumber()); } return container.SetSyncMessage(syncMessage.SetSent(sentMessage)).Build().ToByteArray(); ; } catch (InvalidProtocolBufferException e) { throw new Exception(e.Message); } } }