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);
}
public DeviceGroup(byte[] id, May<String> name, IList<String> members, May<TextSecureAttachmentStream> avatar)
{
this.id = id;
this.name = name;
this.members = members;
this.avatar = avatar;
}
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 TextSecureAttachmentPointer(ulong id, String contentType, byte[] key, String relay, May<uint> size, May<byte[]> preview)
: base(contentType)
{
this.id = id;
this.key = key;
this.relay = new May<String>(relay);
this.size = size;
this.preview = preview;
}
private TextSecureSyncMessage(May<SentTranscriptMessage> sent,
May<TextSecureAttachment> contacts,
May<TextSecureAttachment> groups,
May<RequestMessage> request)
{
this.sent = sent;
this.contacts = contacts;
this.groups = groups;
this.request = request;
}
/**
* Construct a group context.
* @param type The group message type (update, deliver, quit).
* @param groupId The group ID.
* @param name The group title.
* @param members The group membership list.
* @param avatar The group avatar icon.
*/
public TextSecureGroup(Type type, byte[] groupId, String name,
IList<String> members,
TextSecureAttachment avatar)
{
this.type = type;
this.groupId = groupId;
this.name = new May<String>(name);
this.members = new May<IList<String>>(members);
this.avatar = new May<TextSecureAttachment>(avatar);
}
/**
* Construct a TextSecureMessageSender.
*
* @param url The URL of the TextSecure server.
* @param trustStore The trust store containing the TextSecure server's signing TLS certificate.
* @param user The TextSecure username (eg phone number).
* @param password The TextSecure user's password.
* @param store The AxolotlStore.
* @param eventListener An optional event listener, which fires whenever sessions are
* setup or torn down for a recipient.
*/
public TextSecureMessageSender(String url, TrustStore trustStore,
String user, String password,
AxolotlStore store,
May<EventListener> eventListener, String userAgent)
{
this.socket = new PushServiceSocket(url, trustStore, new StaticCredentialsProvider(user, password, null), userAgent);
this.store = store;
this.localAddress = new TextSecureAddress(user);
this.eventListener = eventListener;
}
/**
* 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();
}
}
BobAxolotlParameters(IdentityKeyPair ourIdentityKey, ECKeyPair ourSignedPreKey,
ECKeyPair ourRatchetKey, May<ECKeyPair> ourOneTimePreKey,
IdentityKey theirIdentityKey, ECPublicKey theirBaseKey)
{
this.ourIdentityKey = ourIdentityKey;
this.ourSignedPreKey = ourSignedPreKey;
this.ourRatchetKey = ourRatchetKey;
this.ourOneTimePreKey = ourOneTimePreKey;
this.theirIdentityKey = theirIdentityKey;
this.theirBaseKey = theirBaseKey;
if (ourIdentityKey == null || ourSignedPreKey == null || ourRatchetKey == null ||
ourOneTimePreKey == null || theirIdentityKey == null || theirBaseKey == null)
{
throw new Exception("Null value!");
}
}
public void MayElse()
{
var n = May<int>.NoValue;
var y = new May<int>(1);
Func<May<int>> throwsM = () => { throw new ArgumentException(); };
Func<int> throwsT = () => { throw new ArgumentException(); };
// else T
Assert.IsTrue(n.Else(2) == 2);
Assert.IsTrue(y.Else(2) == 1);
// else Func<T>
Assert.IsTrue(n.Else(() => 2) == 2);
Assert.IsTrue(y.Else(() => 2) == 1);
Assert.IsTrue(y.Else(throwsT) == y);
TestUtil.AssertThrows<ArgumentException>(() => n.Else(throwsT));
// else May<T>
Assert.IsTrue(n.Else(y) == y);
Assert.IsTrue(y.Else(n) == y);
Assert.IsTrue(n.Else(2.Maybe()) == 2.Maybe());
Assert.IsTrue(y.Else(2.Maybe()) == y);
Assert.IsTrue(n.Else(May.NoValue) == May.NoValue);
Assert.IsTrue(y.Else(May.NoValue) == y);
// else Func<May<T>>
Assert.IsTrue(n.Else(() => y) == y);
Assert.IsTrue(y.Else(() => n) == y);
Assert.IsTrue(n.Else(() => 2.Maybe()) == 2.Maybe());
Assert.IsTrue(y.Else(() => 2.Maybe()) == y);
Assert.IsTrue(n.Else(() => new May<int>()) == May.NoValue);
Assert.IsTrue(y.Else(() => new May<int>()) == y);
Assert.IsTrue(y.Else(throwsM) == y);
TestUtil.AssertThrows<ArgumentException>(() => n.Else(throwsM));
// else default
Assert.IsTrue(n.ElseDefault() == 0);
Assert.IsTrue(y.ElseDefault() == 1);
// else action
var x = 0;
y.ElseDo(() => { x += 1; });
Assert.IsTrue(x == 0);
n.ElseDo(() => { x += 1; });
Assert.IsTrue(x == 1);
}
/*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;
}
}
public PreKeyWhisperMessage(byte[] serialized)
{
try
{
this.version = (uint)ByteUtil.highBitsToInt(serialized[0]);
if (this.version > CiphertextMessage.CURRENT_VERSION)
{
throw new InvalidVersionException("Unknown version: " + this.version);
}
WhisperProtos.PreKeyWhisperMessage preKeyWhisperMessage
= WhisperProtos.PreKeyWhisperMessage.ParseFrom(ByteString.CopyFrom(serialized, 1,
serialized.Length - 1));
if ((version == 2 && !preKeyWhisperMessage.HasPreKeyId) ||
(version == 3 && !preKeyWhisperMessage.HasSignedPreKeyId) ||
!preKeyWhisperMessage.HasBaseKey ||
!preKeyWhisperMessage.HasIdentityKey ||
!preKeyWhisperMessage.HasMessage)
{
throw new InvalidMessageException("Incomplete message.");
}
this.serialized = serialized;
this.registrationId = preKeyWhisperMessage.RegistrationId;
this.preKeyId = preKeyWhisperMessage.HasPreKeyId ? new May<uint>(preKeyWhisperMessage.PreKeyId) : May<uint>.NoValue;
this.signedPreKeyId = preKeyWhisperMessage.HasSignedPreKeyId ? preKeyWhisperMessage.SignedPreKeyId : uint.MaxValue; // -1
this.baseKey = Curve.decodePoint(preKeyWhisperMessage.BaseKey.ToByteArray(), 0);
this.identityKey = new IdentityKey(Curve.decodePoint(preKeyWhisperMessage.IdentityKey.ToByteArray(), 0));
this.message = new WhisperMessage(preKeyWhisperMessage.Message.ToByteArray());
}
catch (Exception e)
{
//(InvalidProtocolBufferException | InvalidKeyException | LegacyMessage
throw new InvalidMessageException(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;
}
public UnacknowledgedPreKeyMessageItems getUnacknowledgedPreKeyMessageItems()
{
try
{
May<uint> preKeyId;
if (sessionStructure.PendingPreKey.HasPreKeyId)
{
preKeyId = new May<uint>(sessionStructure.PendingPreKey.PreKeyId);
}
else
{
preKeyId = May<uint>.NoValue;
}
return
new UnacknowledgedPreKeyMessageItems(preKeyId,
sessionStructure.PendingPreKey.SignedPreKeyId,
Curve.decodePoint(sessionStructure.PendingPreKey
.BaseKey
.ToByteArray(), 0));
}
catch (InvalidKeyException e)
{
throw new Exception(e.Message);
}
}
private async Task <HttpResponseMessage> getConnection(string urlFragment, string method, string body)
{
try
{
SignalConnectionInformation connectionInformation = getRandom(signalConnectionInformation);
string url = connectionInformation.getUrl();
May <string> hostHeader = connectionInformation.getHostHeader();
//TrustManger[] trustManagers = connectionInformation.getTrustManagers();
/*SSLContext context = SSLContext.getInstance("TLS");
* context.init(null, trustManagers, null);*/
Uri uri = new Uri(string.Format("{0}{1}", url, urlFragment));
//Log.w(TAG, "Push service URL: " + serviceUrl);
//Log.w(TAG, "Opening URL: " + url);
var filter = new HttpBaseProtocolFilter();
if (HttpClientCertificatePolicyState.Policy == HttpClientCertificatePolicy.DevelopmentMode)
{
filter.IgnorableServerCertificateErrors.Add(Windows.Security.Cryptography.Certificates.ChainValidationResult.Expired);
filter.IgnorableServerCertificateErrors.Add(Windows.Security.Cryptography.Certificates.ChainValidationResult.Untrusted);
filter.IgnorableServerCertificateErrors.Add(Windows.Security.Cryptography.Certificates.ChainValidationResult.InvalidName);
}
//HttpURLConnection connection = (HttpURLConnection)url.openConnection();
HttpClient connection = new HttpClient(filter);
/*if (ENFORCE_SSL)
* {
* ((HttpsURLConnection)connection).setSSLSocketFactory(context.getSocketFactory());
* ((HttpsURLConnection)connection).setHostnameVerifier(new StrictHostnameVerifier());
* }*/
var headers = connection.DefaultRequestHeaders;
//connection.setRequestMethod(method);
//headers.Add("Content-Type", "application/json");
if (credentialsProvider.GetPassword() != null)
{
headers.Add("Authorization", getAuthorizationHeader());
}
if (userAgent != null)
{
headers.Add("X-Signal-Agent", userAgent);
}
if (hostHeader.HasValue)
{
headers.Host = new HostName(hostHeader.ForceGetValue());
}
/*if (body != null)
* {
* connection.setDoOutput(true);
* }*/
//connection.connect();
HttpStringContent content;
if (body != null)
{
content = new HttpStringContent(body, Windows.Storage.Streams.UnicodeEncoding.Utf8, "application/json");
Debug.WriteLine(body);
}
else
{
content = new HttpStringContent("");
}
switch (method)
{
case "POST":
return(await connection.PostAsync(uri, content));
case "PUT":
return(await connection.PutAsync(uri, content));
case "DELETE":
return(await connection.DeleteAsync(uri));
case "GET":
return(await connection.GetAsync(uri));
default:
throw new Exception("Unknown method: " + method);
}
}
catch (UriFormatException e)
{
throw new Exception(string.Format("Uri {0} {1} is wrong", "", urlFragment));
}
catch (Exception e)
{
Debug.WriteLine(string.Format("Other exception {0}{1} is wrong", "", urlFragment));
throw new PushNetworkException(e);
}
}
private bool equals(May<String> one, May<String> two)
{
if (one.HasValue) {
return two.HasValue && one.ForceGetValue().Equals(two.ForceGetValue());
}
else return !two.HasValue;
}
public Builder setTheirOneTimePreKey(May<ECPublicKey> theirOneTimePreKey)
{
this.theirOneTimePreKey = theirOneTimePreKey;
return this;
}
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");
}
}
public TextSecureAttachmentStream(IInputStream inputStream, String contentType, ulong length, May <byte[]> preview)
: base(contentType)
{
this.inputStream = inputStream;
this.length = length;
}
/**
* Construct a PushAddress.
*
* @param e164number The TextSecure username of this destination (eg e164 representation of a phone number).
* @param relay The TextSecure federated server this user is registered with (if not your own server).
*/
public TextSecureAddress(String e164number, May <String> relay)
{
this.e164number = e164number;
this.relay = relay;
}
public SignalServiceContent()
{
message = May.NoValue;
synchronizeMessage = May.NoValue;
}
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 SignalServiceAttachmentStream(Stream inputStream, String contentType, long length, string fileName, bool voiceNote, May <byte[]> preview, ProgressListener listener)
: base(contentType)
{
this.inputStream = inputStream;
this.length = length;
FileName = fileName;
this.listener = listener;
VoiceNote = voiceNote;
this.preview = preview;
}
/// <summary>
/// Construct a PushAddress.
/// </summary>
/// <param name="e164number">The Signal Service username of this destination (eg e164 representation of a phone number).</param>
/// <param name="relay">The Signal Service federated server this user is registered with (if not your own server).</param>
public SignalServiceAddress(String e164number, May <String> relay)
{
this.e164number = e164number;
this.relay = relay;
}
public override int GetHashCode()
{
return(DetailsId.GetHashCode() ^ DetailsName.GetHashCode() ^ Jan.GetHashCode() ^ Feb.GetHashCode() ^ Apr.GetHashCode() ^ May.GetHashCode() ^ Jun.GetHashCode() ^ Jul.GetHashCode() ^ Aug.GetHashCode() ^ Sep.GetHashCode() ^ Oct.GetHashCode() ^ Nov.GetHashCode()
^ Dec.GetHashCode() ^ UOM.GetHashCode() ^ UOMID.GetHashCode());
}
public SignalServiceUrl(string url, string hostHeader, TrustStore trustStore)
{
this.url = url;
this.hostHeader = hostHeader == null ? May.NoValue : new May <string>(hostHeader);
this.trustStore = trustStore;
}
public Builder SetOurOneTimePreKey(May <EcKeyPair> ourOneTimePreKey)
{
_ourOneTimePreKey = ourOneTimePreKey;
return(this);
}
public SignalServiceContent(SignalServiceDataMessage message)
{
this.message = new May <SignalServiceDataMessage>(message);
synchronizeMessage = May.NoValue;
}
private void handleMediaMessage(SignalServiceEnvelope envelope, SignalServiceDataMessage 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);*/
}
public DeviceContact(String number, May<String> name, May<TextSecureAttachmentStream> avatar)
{
this.number = number;
this.name = name;
this.avatar = avatar;
}
public Builder setOurOneTimePreKey(May <ECKeyPair> ourOneTimePreKey)
{
this.ourOneTimePreKey = ourOneTimePreKey;
return(this);
}
public TextSecureContent(TextSecureSyncMessage synchronizeMessage)
{
this.message = May<TextSecureDataMessage>.NoValue;
this.synchronizeMessage = synchronizeMessage == null ? May<TextSecureSyncMessage>.NoValue : new May<TextSecureSyncMessage>(synchronizeMessage);
}
/**
* Construct a PushAddress.
*
* @param e164number The TextSecure username of this destination (eg e164 representation of a phone number).
* @param relay The TextSecure federated server this user is registered with (if not your own server).
*/
public TextSecureAddress(String e164number, May<String> relay)
{
this.e164number = e164number;
this.relay = relay;
}
public string this[int indexer]
{
get
{
switch (indexer)
{
case 0:
January jan = new January();
return jan.ToString();
case 1:
February f = new February();
return f.ToString();
case 2:
March m = new March();
return m.ToString();
case 3:
April a = new April();
return a.ToString();
case 4:
May may = new May();
return may.ToString();
case 5:
June j = new June();
return j.ToString();
case 6:
July july = new July();
return july.ToString();
case 7:
August august = new August();
return august.ToString();
case 8:
September s = new September();
return s.ToString();
case 9:
October o = new October();
return o.ToString();
case 10:
November n = new November();
return n.ToString();
case 11:
December d = new December();
return d.ToString();
default: throw new Exception("No such index");
}
}
}
//private readonly TrustManager[] trustManagers;
public SignalConnectionInformation(SignalServiceUrl signalServiceUrl)
{
this.url = signalServiceUrl.getUrl();
this.hostHeader = signalServiceUrl.getHostHeader();
//this.trustManagers = BlacklistingTrustManager.createFor(signalServiceUrl.getTrustStore());
}
public Builder setTheirOneTimePreKey(May <ECPublicKey> theirOneTimePreKey)
{
this.theirOneTimePreKey = theirOneTimePreKey;
return(this);
}
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 TextSecureAttachmentPointer(ulong id, String contentType, byte[] key, String relay, May <uint> size, May <byte[]> preview)
: base(contentType)
{
this.id = id;
this.key = key;
this.relay = new May <String>(relay);
this.size = size;
this.preview = preview;
}
public UnacknowledgedPreKeyMessageItems(May<uint> preKeyId,
uint signedPreKeyId,
ECPublicKey baseKey)
{
this.preKeyId = preKeyId;
this.signedPreKeyId = signedPreKeyId;
this.baseKey = baseKey;
}
public int CapNhatMay(May may)
{
return(mayData.CapNhatMay(may));
}
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);
}
}
}
private void handleSynchronizeSentMessage(SignalServiceEnvelope 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());
}
public SignalServiceContent(SignalServiceSyncMessage synchronizeMessage)
{
message = May.NoValue;
this.synchronizeMessage = new May <SignalServiceSyncMessage>(synchronizeMessage);
}
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");
}
}
public TextSecureContent()
{
this.message = May<TextSecureDataMessage>.NoValue;
this.synchronizeMessage = May<TextSecureSyncMessage>.NoValue;
}
/**
* Construct a TextSecureMessage.s
*
* @param timestamp The sent timestamp.
* @param group The group information (or null if none).
* @param attachments The attachments (or null if none).
* @param body The message contents.
* @param endSession Flag indicating whether this message should close a session.
*/
public TextSecureDataMessage(ulong timestamp, TextSecureGroup group, LinkedList<TextSecureAttachment> attachments, String body, bool endSession)
{
this.timestamp = timestamp;
this.body = new May<String>(body);
this.group = group == null ? May<TextSecureGroup>.NoValue : new May<TextSecureGroup>(group);
//this.syncContext = syncContext == null ? May<TextSecureSyncContext>.NoValue : new May<TextSecureSyncContext>(syncContext);
this.endSession = endSession;
if (attachments != null && !(attachments.Count == 0))
{
this.attachments = new May<LinkedList<TextSecureAttachment>>(attachments);
}
else
{
this.attachments = May<LinkedList<TextSecureAttachment>>.NoValue;
}
}
public string this[string indexer]
{
get
{
switch (indexer)
{
case "January":
January jan= new January();
return jan.ToString();
case "February":
February f = new February();
return f.ToString();
case "March":
March m = new March();
return m.ToString();
case "April":
April a = new April();
return a.ToString();
case "May":
May may = new May();
return may.ToString();
case "June":
June j = new June();
return j.ToString();
case "July":
July july = new July();
return july.ToString();
case "August":
August august = new August();
return august.ToString();
case "September":
September s = new September();
return s.ToString();
case "October":
October o = new October();
return o.ToString();
case "November":
November n = new November();
return n.ToString();
case "December":
December d = new December();
return d.ToString();
default: throw new Exception("No such index");
}
}
}
public ResponseContext()
{
Data = new May <T>();
}
public Builder setOurOneTimePreKey(May<ECKeyPair> ourOneTimePreKey)
{
this.ourOneTimePreKey = ourOneTimePreKey;
return this;
}
public RequestContext()
{
Data = new May <T>();
}
public DialogViewModel Bind(IApplicationBar applicationBar)
{
_applicationBar = applicationBar.Maybe();
return(this);
}
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());
}
}
private async void LoadListsFor(IUpdatableBoard board, May<string> selectedId)
{
_progress.Show("Loading lists...");
try
{
var lists = (await _api.Lists.ForBoard(new BoardId(board.Id))).ToList();
Lists.Clear();
Lists.AddRange(lists);
selectedId
.Else(lists.Take(1).Select(l => l.Id).MayFirst())
.IfHasValueThenDo(id => { SelectedList = lists.FirstOrDefault(l => l.Id == id); });
}
catch (Exception ex)
{
Analytics.LogException(ex);
MessageBox.Show("The lists for that board were unable to be loaded. Please " +
"ensure that you have an active internet connection.");
}
finally
{
_progress.Hide();
}
}
public int ThemMoi(May may)
{
return(mayData.ThemMoi(may));
}
