public static void RefreshPreKeys(SignalServiceAccountManager accountManager) //TODO wrap in extra lock? enforce reload?
{
List <PreKeyRecord> oneTimePreKeys = GeneratePreKeys();
SignedPreKeyRecord signedPreKeyRecord = generateSignedPreKey(GetIdentityKeyPair());
accountManager.setPreKeys(GetIdentityKeyPair().getPublicKey(), signedPreKeyRecord, oneTimePreKeys);
}
protected override async void OnNormalLaunch(LaunchActivatedEventArgs e)
{
Frame rootFrame = Window.Current.Content as Frame;
DispatcherHelper.Initialize();
accountManager = TextSecureCommunicationFactory.createManager();
RunWebsocket();
//await DirectoryHelper.refreshDirectory();
// var task = new EchoActivity("ASDFFDSA");
//Worker.AddTaskActivities(websocketTask);
//App.Current.Worker.AddTaskActivities(new RefreshPreKeysTask());
if (rootFrame != null && rootFrame.Content == null)
{
// When the navigation stack isn't restored navigate to the first page,
// configuring the new page by passing required information as a navigation
// parameter
rootFrame.Navigate(typeof(MainPage), e.Arguments);
}
Window.Current.Activate();
}
public async Task OnNavigatedTo()
{
ContactName = string.Empty;
ContactNumber = string.Empty;
accountManager = App.Handle.AccountManager;
await RefreshContacts();
}
public async Task TestConnection()
{
var cancelSource = new CancellationTokenSource();
var pushServiceSocket = new SignalServiceAccountManager(ServiceConfiguration, "A", "B", 1, UserAgent);
try
{
var turn = await pushServiceSocket.GetTurnServerInfo(cancelSource.Token);
}
catch (AuthorizationFailedException) { }
}
private SignalServiceAccountManager InitRegistration(bool voice)
{
App.Handle.PurgeAccountData();
SignalServiceAccountManager accountManager = new SignalServiceAccountManager(App.ServiceUrls, App.CurrentSignalWindowsFrontend(App.MainViewId).Locator.RegisterPageInstance.FinalNumber, Password, 1 /*device id isn't actually used*/, App.USER_AGENT);
if (voice)
{
accountManager.requestVoiceVerificationCode();
}
else
{
accountManager.requestSmsVerificationCode();
}
return(accountManager);
}
private SignalServiceAccountManager InitRegistration(bool voice)
{
LibsignalDBContext.PurgeAccountData();
SignalServiceAccountManager accountManager = new SignalServiceAccountManager(App.ServiceUrls, App.ViewModels.RegisterPageInstance.FinalNumber, Password, 1 /*device id isn't actually used*/, App.USER_AGENT);
if (voice)
{
accountManager.requestVoiceVerificationCode();
}
else
{
accountManager.requestSmsVerificationCode();
}
return(accountManager);
}
private async Task <SignalServiceAccountManager> InitRegistration(bool voice)
{
App.Handle.PurgeAccountData();
SignalServiceAccountManager accountManager = new SignalServiceAccountManager(LibUtils.ServiceConfiguration,
null,
App.CurrentSignalWindowsFrontend(App.MainViewId).Locator.RegisterPageInstance.FinalNumber,
Password, 1 /*device id isn't actually used*/, LibUtils.USER_AGENT, LibUtils.HttpClient);
string captcha = null;
if (!string.IsNullOrWhiteSpace(App.CurrentSignalWindowsFrontend(App.MainViewId).Locator.RegisterPageInstance.CaptchaCode))
{
captcha = App.CurrentSignalWindowsFrontend(App.MainViewId).Locator.RegisterPageInstance.CaptchaCode;
}
try
{
if (voice)
{
await accountManager.RequestVoiceVerificationCodeAsync(captcha, CancelSource.Token);
}
else
{
await accountManager.RequestSmsVerificationCodeAsync(captcha, CancelSource.Token);
}
}
catch (CaptchaRequiredException)
{
App.CurrentSignalWindowsFrontend(App.MainViewId).Locator.RegisterPageInstance.CaptchaWebViewEnabled = true;
throw;
}
catch (Exception ex)
{
await Utils.CallOnMainViewUIThreadAsync(async() =>
{
var title = ex.Message;
var content = "Please ensure your phone number is correct and your device is connected to the internet.";
MessageDialog dialog = new MessageDialog(content, title);
await dialog.ShowAsync();
});
throw;
}
return(accountManager);
}
public static async Task <bool> refreshDirectory(SignalServiceAccountManager accountManager, String localNumber)
{
TextSecureDirectory directory = DatabaseFactory.getDirectoryDatabase();
List <string> eligibleContactNumbers = await directory.GetNumbersAsync(localNumber);
List <ContactTokenDetails> activeTokens = await accountManager.getContacts(eligibleContactNumbers);
if (activeTokens != null)
{
foreach (ContactTokenDetails activeToken in activeTokens)
{
Debug.WriteLine($"Token {activeToken.getNumber()}, {activeToken.getToken()}");
eligibleContactNumbers.Remove(activeToken.getNumber());
activeToken.setNumber(activeToken.getNumber());
}
directory.setNumbers(activeTokens, eligibleContactNumbers);
}
return(true);
}
private async static Task <bool> isPushDestination(String destination)
{
TextSecureDirectory directory = DatabaseFactory.getDirectoryDatabase();
try
{
return(directory.isActiveNumber(destination));
}
catch (/*NotInDirectory*/ Exception e)
{
try
{
SignalServiceAccountManager 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 static async Task <bool> refreshDirectory(SignalServiceAccountManager accountManager)
{
return(await refreshDirectory(accountManager, TextSecurePreferences.getLocalNumber()));
}
public static async Task RefreshPreKeysAsync(SignalServiceAccountManager accountManager, CancellationToken token) //TODO wrap in extra lock? enforce reload?
{
List <PreKeyRecord> oneTimePreKeys = GeneratePreKeys();
SignedPreKeyRecord signedPreKeyRecord = GenerateSignedPreKey(GetIdentityKeyPair());
await accountManager.SetPreKeysAsync(GetIdentityKeyPair().getPublicKey(), signedPreKeyRecord, oneTimePreKeys, token);
}
public async Task BeginLinking()
{
try
{
CancelSource = new CancellationTokenSource();
string deviceName = DeviceName;
LinkingTask = Task.Run(() =>
{
/* clean the database from stale values */
LibsignalDBContext.PurgeAccountData();
/* prepare qrcode */
string password = Base64.encodeBytes(Util.getSecretBytes(18));
IdentityKeyPair tmpIdentity = KeyHelper.generateIdentityKeyPair();
SignalServiceAccountManager accountManager = new SignalServiceAccountManager(App.ServiceUrls, CancelSource.Token, "Signal-Windows");
string uuid = accountManager.GetNewDeviceUuid(CancelSource.Token);
string tsdevice = "tsdevice:/?uuid=" + Uri.EscapeDataString(uuid) + "&pub_key=" + Uri.EscapeDataString(Base64.encodeBytesWithoutPadding(tmpIdentity.getPublicKey().serialize()));
Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
View.SetQR(tsdevice);
QRVisible = Visibility.Visible;
QRCodeString = tsdevice;
}).AsTask().Wait();
string tmpSignalingKey = Base64.encodeBytes(Util.getSecretBytes(52));
int registrationId = (int)KeyHelper.generateRegistrationId(false);
NewDeviceLinkResult result = accountManager.FinishNewDeviceRegistration(tmpIdentity, tmpSignalingKey, password, false, true, registrationId, deviceName);
SignalStore store = new SignalStore()
{
DeviceId = (uint)result.DeviceId,
IdentityKeyPair = Base64.encodeBytes(result.Identity.serialize()),
NextSignedPreKeyId = 1,
Password = password,
PreKeyIdOffset = 1,
Registered = true,
RegistrationId = (uint)registrationId,
SignalingKey = tmpSignalingKey,
Username = result.Number
};
LibsignalDBContext.SaveOrUpdateSignalStore(store);
/* reload registered state */
Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
UIEnabled = false;
App.Store = store;
}).AsTask().Wait();
/* create prekeys */
LibsignalDBContext.RefreshPreKeys(new SignalServiceAccountManager(App.ServiceUrls, store.Username, store.Password, (int)store.DeviceId, App.USER_AGENT));
/* reload again with prekeys and their offsets */
store = LibsignalDBContext.GetSignalStore();
Debug.WriteLine("success!");
Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
App.Store = store;
View.Finish(true);
}).AsTask().Wait();
});
await LinkingTask;
}
catch (Exception e)
{
Debug.WriteLine(e.Message);
Debug.WriteLine(e.StackTrace);
}
}
public async Task BeginLinking()
{
try
{
CancelSource = new CancellationTokenSource();
// clean the database from stale values
await Task.Run(() =>
{
LibsignalDBContext.PurgeAccountData();
});
(string password, IdentityKeyPair tmpIdentity) = await Task.Run(() =>
{
string newPassword = Base64.EncodeBytes(Util.GetSecretBytes(18));
IdentityKeyPair newTmpIdentity = KeyHelper.generateIdentityKeyPair();
return(newPassword, newTmpIdentity);
});
// fetch new device uuid
SignalServiceAccountManager accountManager = new SignalServiceAccountManager(App.ServiceConfiguration, "Signal-Windows", new SignalWebSocketFactory());
string uuid = await accountManager.GetNewDeviceUuid(CancelSource.Token, new SignalWebSocketFactory());
string tsdevice = "tsdevice:/?uuid=" + Uri.EscapeDataString(uuid) + "&pub_key=" + Uri.EscapeDataString(Base64.EncodeBytesWithoutPadding(tmpIdentity.getPublicKey().serialize()));
View.SetQR(tsdevice); //TODO generate qrcode in worker task
QRVisible = Visibility.Visible;
QRCodeString = tsdevice;
string tmpSignalingKey = Base64.EncodeBytes(Util.GetSecretBytes(52));
int registrationId = (int)KeyHelper.generateRegistrationId(false);
var provisionMessage = await accountManager.GetProvisioningMessage(CancelSource.Token, tmpIdentity);
int deviceId = await accountManager.FinishNewDeviceRegistration(CancelSource.Token, provisionMessage, tmpSignalingKey, password, false, true, registrationId, View.GetDeviceName());
SignalStore store = new SignalStore()
{
DeviceId = (uint)deviceId,
IdentityKeyPair = Base64.EncodeBytes(provisionMessage.Identity.serialize()),
NextSignedPreKeyId = 1,
Password = password,
PreKeyIdOffset = 1,
Registered = true,
RegistrationId = (uint)registrationId,
SignalingKey = tmpSignalingKey,
Username = provisionMessage.Number
};
await Task.Run(() =>
{
LibsignalDBContext.SaveOrUpdateSignalStore(store);
});
// reload registered state
UIEnabled = false;
App.Handle.Store = store;
// create prekeys
await LibsignalDBContext.RefreshPreKeys(CancelSource.Token, new SignalServiceAccountManager(App.ServiceConfiguration, store.Username, store.Password, (int)store.DeviceId, App.USER_AGENT));
// reload again with prekeys and their offsets
App.Handle.Store = LibsignalDBContext.GetSignalStore();
await View.Finish(true);
}
catch (Exception e)
{
var line = new StackTrace(e, true).GetFrames()[0].GetFileLineNumber();
Logger.LogError("BeginLinking() failed in line {0}: {1}\n{2}", line, e.Message, e.StackTrace);
}
}
public async Task RefreshContacts(CancellationToken?cancellationToken = null)
{
RefreshingContacts = true;
Contacts.Clear();
signalContacts.Clear();
SignalServiceAccountManager accountManager = new SignalServiceAccountManager(App.ServiceUrls, App.Store.Username, App.Store.Password, (int)App.Store.DeviceId, App.USER_AGENT);
ContactStore contactStore = await ContactManager.RequestStoreAsync(ContactStoreAccessType.AllContactsReadOnly);
List <PhoneContact> intermediateContacts = new List <PhoneContact>();
if (contactStore != null)
{
HashSet <string> seenNumbers = new HashSet <string>();
var contacts = await contactStore.FindContactsAsync();
ContactAnnotationStore contactAnnotationStore = await ContactManager.RequestAnnotationStoreAsync(ContactAnnotationStoreAccessType.AppAnnotationsReadWrite);
ContactAnnotationList contactAnnotationList;
var contactAnnotationLists = await contactAnnotationStore.FindAnnotationListsAsync();
if (contactAnnotationLists.Count == 0)
{
contactAnnotationList = await contactAnnotationStore.CreateAnnotationListAsync();
}
else
{
contactAnnotationList = contactAnnotationLists[0];
}
foreach (var contact in contacts)
{
var phones = contact.Phones;
foreach (var phone in contact.Phones)
{
if (phone.Kind == ContactPhoneKind.Mobile)
{
string formattedNumber = null;
try
{
formattedNumber = ParsePhoneNumber(phone.Number);
}
catch (NumberParseException)
{
Debug.WriteLine($"Couldn't parse {phone.Number}");
continue;
}
if (!seenNumbers.Contains(formattedNumber))
{
seenNumbers.Add(formattedNumber);
PhoneContact phoneContact = new PhoneContact
{
Id = contact.Id,
Name = contact.FullName,
PhoneNumber = formattedNumber,
OnSignal = false
};
if (contact.SourceDisplayPicture != null)
{
using (var stream = await contact.SourceDisplayPicture.OpenReadAsync())
{
BitmapImage bitmapImage = new BitmapImage();
await bitmapImage.SetSourceAsync(stream);
phoneContact.Photo = bitmapImage;
}
}
intermediateContacts.Add(phoneContact);
}
}
}
}
// check if we've annotated a contact as a Signal contact already, if we have we don't need to ask Signal about them
for (int i = 0; i < intermediateContacts.Count; i++)
{
var annotatedContact = await contactAnnotationList.FindAnnotationsByRemoteIdAsync(intermediateContacts[i].PhoneNumber);
if (annotatedContact.Count > 0)
{
intermediateContacts[i].OnSignal = true;
signalContacts.Add(intermediateContacts[i]);
intermediateContacts.RemoveAt(i);
i--;
}
}
var signalContactDetails = accountManager.getContacts(intermediateContacts.Select(c => c.PhoneNumber).ToList());
foreach (var contact in intermediateContacts)
{
var foundContact = signalContactDetails.FirstOrDefault(c => c.getNumber() == contact.PhoneNumber);
if (foundContact != null)
{
contact.OnSignal = true;
ContactAnnotation contactAnnotation = new ContactAnnotation();
contactAnnotation.ContactId = contact.Id;
contactAnnotation.RemoteId = contact.PhoneNumber;
contactAnnotation.SupportedOperations = ContactAnnotationOperations.Message | ContactAnnotationOperations.ContactProfile;
await contactAnnotationList.TrySaveAnnotationAsync(contactAnnotation);
signalContacts.Add(contact);
}
}
Contacts.AddRange(signalContacts);
}
else
{
ContactsVisible = false;
}
RefreshingContacts = false;
}
internal async Task OnNavigatedTo()
{
try
{
CancellationTokenSource cancelSource = new CancellationTokenSource();
await Task.Run(async() =>
{
string SignalingKey = Base64.EncodeBytes(Util.GetSecretBytes(52));
SignalServiceAccountManager accountManager = App.CurrentSignalWindowsFrontend(App.MainViewId).Locator.RegisterFinalizationPageInstance.AccountManager;
Guid ownGuid = await accountManager.VerifyAccountWithCodeAsync(
App.CurrentSignalWindowsFrontend(App.MainViewId).Locator.RegisterFinalizationPageInstance.VerificationCode.Replace("-", ""),
SignalingKey,
App.CurrentSignalWindowsFrontend(App.MainViewId).Locator.RegisterFinalizationPageInstance.SignalRegistrationId,
true,
null,
null,
false,
cancelSource.Token);
SignalStore store = new SignalStore()
{
DeviceId = 1,
IdentityKeyPair = Base64.EncodeBytes(App.CurrentSignalWindowsFrontend(App.MainViewId).Locator.RegisterFinalizationPageInstance.IdentityKeyPair.serialize()),
NextSignedPreKeyId = 1,
Password = App.CurrentSignalWindowsFrontend(App.MainViewId).Locator.RegisterFinalizationPageInstance.Password,
PreKeyIdOffset = 1,
Registered = true,
RegistrationId = App.CurrentSignalWindowsFrontend(App.MainViewId).Locator.RegisterFinalizationPageInstance.SignalRegistrationId,
SignalingKey = SignalingKey,
Username = App.CurrentSignalWindowsFrontend(App.MainViewId).Locator.RegisterPageInstance.FinalNumber,
OwnGuid = ownGuid
};
LibsignalDBContext.SaveOrUpdateSignalStore(store);
Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
App.Handle.Store = store;
}).AsTask().Wait();
/* create prekeys */
await LibsignalDBContext.RefreshPreKeysAsync(new SignalServiceAccountManager(
LibUtils.ServiceConfiguration, store.OwnGuid, store.Username, store.Password, (int)store.DeviceId,
LibUtils.USER_AGENT, LibUtils.HttpClient),
cancelSource.Token);
/* reload again with prekeys and their offsets */
store = LibsignalDBContext.GetSignalStore();
Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
App.Handle.Store = store;
}).AsTask().Wait();
});
var frontend = App.CurrentSignalWindowsFrontend(App.MainViewId);
await App.Handle.Reacquire();
View.Frame.Navigate(typeof(MainPage));
}
catch (Exception e)
{
Logger.LogError("OnNavigatedTo() failed: {0}\n{1}", e.Message, e.StackTrace);
var title = "Verification failed";
var content = "Please enter the correct verification code.";
MessageDialog dialog = new MessageDialog(content, title);
var result = dialog.ShowAsync();
View.Frame.Navigate(typeof(RegisterPage));
}
}
