public Tracker (TrackerType trackerType) { TrackerType = trackerType; // Details = new BugDetails (); Keychain = new Keychain<TrackerType> (trackerType); // TrackerDetails = new Dictionary<int, BugDetails.DetailType> (); }
public override void ViewDidLoad () { base.ViewDidLoad(); ScreenName = string.Format(GAIKeys.ScreenNames.TrackerAccounts, TrackerType); Keychain = new Keychain<TrackerType> (TrackerType); PopulatePlaceholderLabels(TraitCollection.Contains(UITraitCollection.FromVerticalSizeClass(UIUserInterfaceSizeClass.Compact))); }
public void ShouldConnectSetCredentialsTokenAndSave() { const string connectionsCachePath = @"c:\UserCachePath\"; const string connectionsCacheFile = @"c:\UserCachePath\connections.json"; const string username = "******"; const string password = "******"; const string token = "SomeToken"; var hostUri = new UriString("https://github.com/"); var fileSystem = SubstituteFactory.CreateFileSystem(); NPath.FileSystem = fileSystem; var environment = SubstituteFactory.CreateEnvironment(); environment.UserCachePath.Returns(info => connectionsCachePath.ToNPath()); environment.FileSystem.Returns(fileSystem); var credentialManager = Substitute.For <ICredentialManager>(); var keychain = new Keychain(environment, credentialManager); keychain.Initialize(); fileSystem.Received(1).FileExists(connectionsCacheFile); fileSystem.DidNotReceive().ReadAllText(Args.String); fileSystem.DidNotReceive().ReadAllLines(Args.String); fileSystem.DidNotReceive().WriteAllText(Args.String, Args.String); fileSystem.DidNotReceive().FileDelete(Args.String); fileSystem.ClearReceivedCalls(); credentialManager.DidNotReceive().Load(Args.UriString); credentialManager.DidNotReceive().HasCredentials(); credentialManager.DidNotReceive().Delete(Args.UriString); credentialManager.DidNotReceive().Save(Arg.Any <ICredential>()); keychain.HasKeys.Should().BeFalse(); keychain.Hosts.Should().BeEmpty(); var keychainAdapter = keychain.Connect(hostUri); keychainAdapter.Credential.Should().BeNull(); keychainAdapter.Set(new Credential(hostUri, username, password)); keychainAdapter.Credential.Should().NotBeNull(); keychainAdapter.Credential.Host.Should().Be(hostUri); keychainAdapter.Credential.Username.Should().Be(username); keychainAdapter.Credential.Token.Should().Be(password); keychainAdapter.Update(token, username); keychainAdapter.Credential.Should().NotBeNull(); keychainAdapter.Credential.Host.Should().Be(hostUri); keychainAdapter.Credential.Username.Should().Be(username); keychainAdapter.Credential.Token.Should().Be(token); keychain.SaveToSystem(hostUri); fileSystem.DidNotReceive().FileExists(Args.String); fileSystem.DidNotReceive().FileDelete(Args.String); fileSystem.DidNotReceive().ReadAllText(Args.String); fileSystem.DidNotReceive().ReadAllLines(Args.String); fileSystem.Received(1).WriteAllText(connectionsCacheFile, @"[{""Host"":""https://github.com"",""Username"":""SomeUser""}]"); credentialManager.DidNotReceive().Load(Args.UriString); credentialManager.DidNotReceive().HasCredentials(); credentialManager.Received(1).Delete(hostUri); credentialManager.Received(1).Save(Arg.Any <ICredential>()); }
public IPhoneSigningKeyPanelWidget(IPhoneProject project) { this.Build(); resourceRulesEntry.DefaultFilter = "*.plist"; resourceRulesEntry.Project = project; resourceRulesEntry.EntryIsEditable = true; entitlementsEntry.DefaultFilter = "*.plist"; entitlementsEntry.Project = project; entitlementsEntry.EntryIsEditable = true; additionalArgsEntry.AddOptions(IPhoneBuildOptionsWidget.menuOptions); profiles = MobileProvision.GetAllInstalledProvisions(); var txtRenderer = new CellRendererText(); txtRenderer.Ellipsize = Pango.EllipsizeMode.End; identityCombo.Model = identityStore; identityCombo.PackStart(txtRenderer, true); identityCombo.AddAttribute(txtRenderer, "markup", 0); identityCombo.RowSeparatorFunc = delegate(TreeModel model, TreeIter iter) { return((string)model.GetValue(iter, 0) == "-"); }; identityCombo.Changed += delegate { UpdateProfiles(); }; provisioningCombo.Model = profileStore; provisioningCombo.PackStart(txtRenderer, true); provisioningCombo.AddAttribute(txtRenderer, "markup", 0); var signingCerts = Keychain.FindNamedSigningCertificates(x => x.StartsWith("iPhone")).ToList(); signingCerts.Sort((x, y) => Keychain.GetCertificateCommonName(x).CompareTo(Keychain.GetCertificateCommonName(x))); identityStore.AppendValues("<b>Developer (Automatic)</b>", Keychain.DEV_CERT_PREFIX, null); identityStore.AppendValues("<b>Distribution (Automatic)</b>", Keychain.DIST_CERT_PREFIX, null); int trimStart = "iPhone ".Length; identityStore.AppendValues("-", "-", null); foreach (var cert in signingCerts) { string cn = Keychain.GetCertificateCommonName(cert); if (cn.StartsWith(Keychain.DEV_CERT_PREFIX)) { identityStore.AppendValues(GLib.Markup.EscapeText(cn.Substring(trimStart, cn.Length - trimStart)), cn, cert); } } identityStore.AppendValues("-", "-", null); foreach (var cert in signingCerts) { string cn = Keychain.GetCertificateCommonName(cert); if (cn.StartsWith(Keychain.DIST_CERT_PREFIX)) { identityStore.AppendValues(GLib.Markup.EscapeText(cn.Substring(trimStart, cn.Length - trimStart)), cn, cert); } } this.ShowAll(); }
public Task<string> GetAlbumLocalIdentifier () { if (albumLocalIdTcs == null || (int)albumLocalIdTcs.Task.Status >= 5) { albumLocalIdTcs = new TaskCompletionSource<string> (); } else if ((int)albumLocalIdTcs.Task.Status <= 4) { return albumLocalIdTcs.Task; } PHPhotoLibrary.RequestAuthorization(async status => { if (status == PHAuthorizationStatus.Authorized) { if (!string.IsNullOrEmpty(albumLocalIdentifier)) { albumLocalIdTcs.TrySetResult(albumLocalIdentifier); } else { var keychain = new Keychain<TrapAlbum> (new TrapAlbum ()); var values = keychain.GetStoredKeyValues(); var identifier = values.ContainsKey(DataKeys.LocalIdentifier) ? values[DataKeys.LocalIdentifier] : null; if (identifier != null) { // ensure the album with that localIdentifier is there var collection = PHAssetCollection.FetchAssetCollections(new [] { identifier }, null)?.firstObject as PHAssetCollection; if (collection != null) { albumLocalIdentifier = identifier; if (!albumLocalIdTcs.TrySetResult(identifier)) { var ex = new Exception ("GetAlbumLocalIdentifier Failed"); albumLocalIdTcs.TrySetException(ex); // Log.Error(ex); } } else { if (!albumLocalIdTcs.TrySetResult(await createAlbumAndSaveLocalIdentifier())) { var ex = new Exception ("GetAlbumLocalIdentifier Failed"); albumLocalIdTcs.TrySetException(ex); // Log.Error(ex); } } } else { if (!albumLocalIdTcs.TrySetResult(await createAlbumAndSaveLocalIdentifier())) { var ex = new Exception ("GetAlbumLocalIdentifier Failed"); albumLocalIdTcs.TrySetException(ex); // Log.Error(ex); } } } } else { var ex = new Exception ("Unauthorized"); albumLocalIdTcs.TrySetException(ex); // Log.Error(ex); } }); return albumLocalIdTcs.Task; }
/// <summary> /// Trackers the has auth credentials. /// </summary> /// <returns>the dictionary if the keys needed are in the keychain, <c>null</c> otherwise.</returns> /// <param name="trackerType">Tracker type.</param> public Dictionary<DataKeys, string> TrackerHasAuthCredentials (TrackerType trackerType) { var storedValues = new Keychain<TrackerType> (trackerType).GetStoredKeyValues(); return trackerType.Valid(storedValues) ? storedValues : null; }
public void FixtureSetup() { Keychain.TryDeleteKeychain(TestKeyChain); Keychain.CurrentKeychain = Keychain.CreateKeychain(TestKeyChain, "mypassword"); }
public void ShouldDeleteFromCacheWhenLoadReturnsNullFromConnectionManagerDueToUserMismatch() { const string connectionsCachePath = @"c:\UserCachePath\"; const string connectionsCacheFile = @"c:\UserCachePath\connections.json"; const string cachedUsername = "******"; const string credentialedUsername = "******"; const string token = "SomeToken"; var hostUri = new UriString("https://github.com/"); var fileSystem = SubstituteFactory.CreateFileSystem(new CreateFileSystemOptions { FilesThatExist = new List <string> { connectionsCacheFile }, FileContents = new Dictionary <string, IList <string> > { { connectionsCacheFile, new List <string> { $@"[{{""Host"":""https://github.com/"",""Username"":""{cachedUsername}""}}]" } } } }); NPath.FileSystem = fileSystem; var environment = SubstituteFactory.CreateEnvironment(); environment.UserCachePath.Returns(info => connectionsCachePath.ToNPath()); environment.FileSystem.Returns(fileSystem); var credentialManager = Substitute.For <ICredentialManager>(); credentialManager.Load(hostUri).Returns(info => { var credential = Substitute.For <ICredential>(); credential.Username.Returns(credentialedUsername); credential.Token.Returns(token); credential.Host.Returns(hostUri); return(TaskEx.FromResult(credential)); }); var keychain = new Keychain(environment, credentialManager); keychain.Initialize(); fileSystem.Received(1).FileExists(connectionsCacheFile); fileSystem.DidNotReceive().FileDelete(Args.String); fileSystem.Received(1).ReadAllText(connectionsCacheFile); fileSystem.DidNotReceive().ReadAllLines(Args.String); fileSystem.DidNotReceive().WriteAllText(Args.String, Args.String); fileSystem.DidNotReceive().WriteAllLines(Args.String, Arg.Any <string[]>()); credentialManager.DidNotReceive().Load(Args.UriString); credentialManager.DidNotReceive().HasCredentials(); credentialManager.DidNotReceive().Delete(Args.UriString); credentialManager.DidNotReceive().Save(Arg.Any <ICredential>()); fileSystem.ClearReceivedCalls(); var uriString = keychain.Hosts.FirstOrDefault(); var keychainAdapter = keychain.Load(uriString).Result; keychainAdapter.Credential.Should().BeNull(); keychainAdapter.OctokitCredentials.AuthenticationType.Should().Be(AuthenticationType.Anonymous); keychainAdapter.OctokitCredentials.Login.Should().BeNull(); keychainAdapter.OctokitCredentials.Password.Should().BeNull(); fileSystem.DidNotReceive().FileExists(Args.String); fileSystem.DidNotReceive().ReadAllText(Args.String); fileSystem.DidNotReceive().FileDelete(Args.String); fileSystem.Received(1).WriteAllText(connectionsCacheFile, "[]"); fileSystem.DidNotReceive().WriteAllLines(Args.String, Arg.Any <string[]>()); credentialManager.Received(1).Load(hostUri); credentialManager.DidNotReceive().HasCredentials(); credentialManager.DidNotReceive().Delete(Args.UriString); credentialManager.DidNotReceive().Save(Arg.Any <ICredential>()); }
public void DeleteKeychain(Keychain keychain) => KeycheckBlock.Keychains.Remove(keychain);
void FillIdentities() { var signingCerts = Keychain.FindNamedSigningCertificates(x => x.StartsWith("iPhone")).ToList(); signingCerts.Sort((x, y) => Keychain.GetCertificateCommonName(x).CompareTo(Keychain.GetCertificateCommonName(x))); identityCombo.AddItemWithMarkup("<b>Developer (Automatic)</b>", IPhoneProject.DEV_CERT_PREFIX, null); identityCombo.AddItemWithMarkup("<b>Distribution (Automatic)</b>", IPhoneProject.DIST_CERT_PREFIX, null); int trimStart = "iPhone ".Length; identityCombo.AddSeparator(); foreach (var cert in signingCerts) { string cn = Keychain.GetCertificateCommonName(cert); if (cn.StartsWith(IPhoneProject.DEV_CERT_PREFIX)) { identityCombo.AddItem(cn.Substring(trimStart, cn.Length - trimStart), cn, cert); } } identityCombo.AddSeparator(); foreach (var cert in signingCerts) { string cn = Keychain.GetCertificateCommonName(cert); if (cn.StartsWith(IPhoneProject.DIST_CERT_PREFIX)) { identityCombo.AddItem(cn.Substring(trimStart, cn.Length - trimStart), cn, cert); } } }
public AddPublicKeyDialog(Keychain keychain) { InitializeComponent(); Keychain = keychain; }
public KeychainViewerViewModel(Keychain keychain) { rlSettingsService = SP.GetService <RuriLibSettingsService>(); this.keychain = keychain; }
public static string build_info(WalletConfig config, Keychain keychain) { var sb = new StringBuilder(); var result = Checker.refresh_outputs(config, keychain); WalletData.Read_wallet(config.DataFileDir, walletData => { ulong currentHeight; try { var tip = Checker.get_tip_from_node(config); currentHeight = tip.Height; } catch { currentHeight = walletData.Outputs.Any() ? walletData.Outputs.Values.Max(m => m.Height) : 0; } ulong unspentTotal = 0; ulong unspentButLockedTotal = 0; ulong unconfirmedTotal = 0; ulong lockedTotal = 0; foreach (var op in walletData.Outputs.Values.Where(w => w.RootKeyId == keychain.Root_key_id().HexValue)) { if (op.Status == OutputStatus.Unspent) { unspentTotal += op.Value; if (op.LockHeight > currentHeight) { unspentButLockedTotal += op.Value; } } if (op.Status == OutputStatus.Unconfirmed && !op.IsCoinbase) { unconfirmedTotal += op.Value; } if (op.Status == OutputStatus.Locked) { lockedTotal += op.Value; } } var title = $"Wallet Summary Info - Block Height: {currentHeight}"; sb.AppendLine($"{title}"); sb.AppendLine("----------------------------------------------"); sb.AppendLine(""); sb.AppendLine($"Total: {unspentTotal + unconfirmedTotal}"); sb.AppendLine($"Awaiting Confirmation: {unconfirmedTotal}"); sb.AppendLine($"Confirmed but Still Locked: {unspentButLockedTotal}"); sb.AppendLine($"Currently Spendable {unspentTotal - unspentButLockedTotal}"); sb.AppendLine(""); sb.AppendLine("-----------------------------------------------"); sb.AppendLine(""); sb.AppendLine($"Locked by previous transaction: {lockedTotal}"); return(walletData); }); if (!result) { sb.AppendLine(""); sb.AppendLine( "WARNING - Showing local data only - Wallet was unable to contact a node to update and verify the info shown here."); } return(sb.ToString()); }
public static void show_info(WalletConfig config, Keychain keychain) { var txt = build_info(config, keychain); Console.WriteLine(txt); }
public override void FromLC(ref string script, ref int lineNumber) { /* * KEYCHAIN SUCCESS OR * STRINGKEY @myVariable Contains "abc" * DICTKEY @data.COOKIES HasKey "my-cookie" * KEYCHAIN FAIL AND * LISTKEY @myList Contains "item" * FLOATKEY 1 GreaterThan 2 */ // First parse the options that are common to every BlockInstance base.FromLC(ref script, ref lineNumber); using var reader = new StringReader(script); string line, lineCopy; while ((line = reader.ReadLine()) != null) { line = line.Trim(); lineCopy = line; lineNumber++; if (string.IsNullOrWhiteSpace(line)) { continue; } if (line.StartsWith("KEYCHAIN")) { try { var keychain = new Keychain(); LineParser.ParseToken(ref line); keychain.ResultStatus = LineParser.ParseToken(ref line); keychain.Mode = Enum.Parse <KeychainMode>(LineParser.ParseToken(ref line)); Keychains.Add(keychain); } catch { throw new LoliCodeParsingException(lineNumber, $"Invalid keychain declaration: {lineCopy.TruncatePretty(50)}"); } } else if (Regex.IsMatch(line, "^[A-Z]+KEY ")) { try { var keyType = LineParser.ParseToken(ref line); Keychains.Last().Keys.Add(LoliCodeParser.ParseKey(ref line, keyType)); } catch { throw new LoliCodeParsingException(lineNumber, $"Invalid key declaration: {lineCopy.TruncatePretty(50)}"); } } else { try { LoliCodeParser.ParseSetting(ref line, Settings, Descriptor); } catch { throw new LoliCodeParsingException(lineNumber, $"Could not parse the setting: {lineCopy.TruncatePretty(50)}"); } } } }
public CoinbaseHandler(WalletConfig config, Keychain keychain) { Config = config; Keychain = keychain; }
void UpdateProfiles() { suppressSelectionSnapshot = true; provisioningCombo.ClearList(); var identityName = identityCombo.SelectedName; string previousSelection = null; if (identityName != null) { profileSelections.TryGetValue(identityName, out previousSelection); } suppressSelectionSnapshot = false; if (identityName != null) { var identityObj = identityCombo.SelectedItem; var cert = identityObj as X509Certificate2; Func <X509Certificate2, bool> matchIdentity; //known identity if (cert != null) { matchIdentity = c => c.Thumbprint == cert.Thumbprint; } //unknown identity else if (identityObj != null) { matchIdentity = c => false; } //auto identity else { string autoPrefix = identityName.StartsWith(IPhoneProject.DIST_CERT_PREFIX)? IPhoneProject.DIST_CERT_PREFIX : IPhoneProject.DEV_CERT_PREFIX; matchIdentity = c => Keychain.GetCertificateCommonName(c).StartsWith(autoPrefix); } var isDuplicate = new Dictionary <string, bool> (); var filtered = profiles.Where(p => p.DeveloperCertificates.Any(matchIdentity)).Where(p => { if (string.IsNullOrEmpty(p.Uuid)) { LoggingService.LogWarning("Provisioning Profile '{0}' has no UUID", p.Name); return(false); } isDuplicate[p.Name] = isDuplicate.ContainsKey(p.Name); return(true); }).ToList(); if (filtered.Any()) { provisioningCombo.AddItemWithMarkup(GettextCatalog.GetString("<b>Automatic</b>"), null, null); foreach (var f in filtered) { var displayName = isDuplicate[f.Name] ? string.Format("{0} ({1})", f.Name, f.CreationDate) : f.Name; provisioningCombo.AddItem(displayName, f.Uuid, f); } provisioningCombo.SelectedName = previousSelection; return; } } if (previousSelection != null) { provisioningCombo.SelectedName = previousSelection; } else { provisioningCombo.AddItem(GettextCatalog.GetString("No matching profiles found"), null, null); provisioningCombo.Active = 0; } }
public static bool BuildPackage(IProgressMonitor monitor, MonoMacProject project, ConfigurationSelector conf, MonoMacPackagingSettings settings, FilePath target) { string bundleKey = settings.BundleSigningKey; string packageKey = settings.PackageSigningKey; if (settings.SignBundle || (settings.CreatePackage && settings.SignPackage)) { var identities = Keychain.GetAllSigningIdentities(); if (string.IsNullOrEmpty(bundleKey)) { bundleKey = identities.FirstOrDefault(k => k.StartsWith(MonoMacPackagingSettingsWidget.APPLICATION_PREFIX)); if (string.IsNullOrEmpty(bundleKey)) { monitor.ReportError("Did not find default app signing key", null); return(false); } else if (!identities.Any(k => k == bundleKey)) { monitor.ReportError("Did not find app signing key in keychain", null); return(false); } } if (string.IsNullOrEmpty(packageKey)) { packageKey = identities.FirstOrDefault(k => k.StartsWith(MonoMacPackagingSettingsWidget.INSTALLER_PREFIX)); if (string.IsNullOrEmpty(packageKey)) { monitor.ReportError("Did not find default package signing key", null); return(false); } else if (!identities.Any(k => k == packageKey)) { monitor.ReportError("Did not find package signing key in keychain", null); return(false); } } } if (project.NeedsBuilding(conf)) { BuildResult res = project.Build(monitor, conf); if (res.ErrorCount > 0) { foreach (BuildError e in res.Errors) { monitor.ReportError(e.ToString(), null); } monitor.ReportError(GettextCatalog.GetString("The project failed to build."), null); return(false); } } var cfg = (MonoMacProjectConfiguration)project.GetConfiguration(conf); FilePath tempDir = "/tmp/monomac-build-" + DateTime.Now.Ticks; FilePath workingApp = tempDir.Combine(cfg.AppDirectory.FileName); try { //user will have agreed to overwrite when they picked the target if (Directory.Exists(target)) { Directory.Delete(target); } else if (File.Exists(target)) { File.Delete(target); } monitor.BeginTask(GettextCatalog.GetString("Creating app bundle"), 0); var files = Directory.GetFiles(cfg.AppDirectory, "*", SearchOption.AllDirectories); HashSet <string> createdDirs = new HashSet <string> (); foreach (FilePath f in files) { var rel = f.ToRelative(cfg.AppDirectory); var parentDir = rel.ParentDirectory; if (settings.IncludeMono) { if (parentDir.IsNullOrEmpty || parentDir == "." || parentDir == "Contents/MacOS") { continue; } var ext = rel.Extension; if (ext == ".mdb" || ext == ".exe" || ext == ".dll") { continue; } } if (monitor.IsCancelRequested) { return(false); } if (createdDirs.Add(parentDir)) { Directory.CreateDirectory(workingApp.Combine(parentDir)); } monitor.Log.WriteLine(rel); File.Copy(f, workingApp.Combine(rel)); } monitor.EndTask(); if (settings.IncludeMono) { monitor.BeginTask(GettextCatalog.GetString("Merging Mono into app bundle"), 0); var args = new ProcessArgumentBuilder(); switch (settings.LinkerMode) { case MonoMacLinkerMode.LinkNone: args.Add("--nolink"); break; case MonoMacLinkerMode.LinkFramework: args.Add("--linksdkonly"); break; case MonoMacLinkerMode.LinkAll: // nothing break; } args.Add("-o"); args.AddQuoted(tempDir); args.Add("-n"); args.AddQuoted(cfg.AppName); var assemblies = project.GetReferencedAssemblies(conf, true); foreach (var a in assemblies) { args.Add("-a"); args.AddQuoted(a); } args.AddQuoted(cfg.CompiledOutputName); string mmpPath = Mono.Addins.AddinManager.CurrentAddin.GetFilePath("mmp"); //FIXME: workaround for Mono.Addins losing the executable bit during packaging var mmpInfo = new Mono.Unix.UnixFileInfo(mmpPath); if ((mmpInfo.FileAccessPermissions & Mono.Unix.FileAccessPermissions.UserExecute) == 0) { mmpInfo.FileAccessPermissions |= Mono.Unix.FileAccessPermissions.UserExecute; } var psi = new ProcessStartInfo(mmpPath, args.ToString()); monitor.Log.WriteLine("mmp " + psi.Arguments); string err; if (MacBuildUtilities.ExecuteCommand(monitor, psi, out err) != 0) { monitor.Log.WriteLine(err); monitor.ReportError("Merging Mono failed", null); return(false); } var plistFile = workingApp.Combine("Contents", "Info.plist"); var plistDoc = new PlistDocument(); plistDoc.LoadFromXmlFile(plistFile); ((PlistDictionary)plistDoc.Root)["MonoBundleExecutable"] = cfg.CompiledOutputName.FileName; plistDoc.WriteToFile(plistFile); monitor.EndTask(); } //TODO: verify bundle details if for app store? if (settings.SignBundle) { monitor.BeginTask(GettextCatalog.GetString("Signing app bundle"), 0); var args = new ProcessArgumentBuilder(); args.Add("-v", "-f", "-s"); args.AddQuoted(bundleKey, workingApp); var psi = new ProcessStartInfo("codesign", args.ToString()); monitor.Log.WriteLine("codesign " + psi.Arguments); string err; if (MacBuildUtilities.ExecuteCommand(monitor, psi, out err) != 0) { monitor.Log.WriteLine(err); monitor.ReportError("Signing failed", null); return(false); } monitor.EndTask(); } if (settings.CreatePackage) { monitor.BeginTask(GettextCatalog.GetString("Creating installer"), 0); var args = new ProcessArgumentBuilder(); args.Add("--component"); args.AddQuoted(workingApp); args.Add("/Applications"); if (settings.SignPackage) { args.Add("--sign"); args.AddQuoted(packageKey); } if (!settings.ProductDefinition.IsNullOrEmpty) { args.Add("--product"); args.AddQuoted(settings.ProductDefinition); } args.AddQuoted(target); var psi = new ProcessStartInfo("productbuild", args.ToString()); monitor.Log.WriteLine("productbuild " + psi.Arguments); string err; int pbRet; try { pbRet = MacBuildUtilities.ExecuteCommand(monitor, psi, out err); } catch (System.ComponentModel.Win32Exception) { monitor.ReportError("productbuild not found", null); return(false); } if (pbRet != 0) { monitor.Log.WriteLine(err); monitor.ReportError("Package creation failed", null); return(false); } monitor.EndTask(); } else { Directory.Move(workingApp, target); } } finally { try { if (Directory.Exists(tempDir)) { Directory.Delete(tempDir, true); } } catch (Exception ex) { LoggingService.LogError("Error removing temp directory", ex); } } return(true); }
public void AddWebPassword(Uri uri, string password) { Keychain.AddInternetPassword(uri, password); }
public void ShouldConnectSetCredentialsAndClear() { const string connectionsCachePath = @"c:\UserCachePath\"; const string connectionsCacheFile = @"c:\UserCachePath\connections.json"; const string username = "******"; const string password = "******"; const string token = "SomeToken"; var hostUri = new UriString("https://github.com/"); var fileSystem = SubstituteFactory.CreateFileSystem(); NPath.FileSystem = fileSystem; var environment = SubstituteFactory.CreateEnvironment(); environment.UserCachePath.Returns(info => connectionsCachePath.ToNPath()); environment.FileSystem.Returns(fileSystem); var credentialManager = Substitute.For <ICredentialManager>(); credentialManager.Delete(Args.UriString).Returns(info => TaskEx.FromResult(0)); credentialManager.Save(Arg.Any <ICredential>()).Returns(info => TaskEx.FromResult(0)); var keychain = new Keychain(environment, credentialManager); keychain.Initialize(); fileSystem.Received(1).FileExists(connectionsCacheFile); fileSystem.DidNotReceive().ReadAllText(Args.String); fileSystem.DidNotReceive().ReadAllLines(Args.String); fileSystem.DidNotReceive().WriteAllText(Args.String, Args.String); fileSystem.DidNotReceive().FileDelete(Args.String); fileSystem.ClearReceivedCalls(); credentialManager.DidNotReceive().Load(Args.UriString); credentialManager.DidNotReceive().HasCredentials(); credentialManager.DidNotReceive().Delete(Args.UriString); credentialManager.DidNotReceive().Save(Arg.Any <ICredential>()); keychain.HasKeys.Should().BeFalse(); keychain.Hosts.Should().BeEmpty(); var keychainAdapter = keychain.Connect(hostUri); keychainAdapter.Credential.Should().BeNull(); keychainAdapter.OctokitCredentials.Should().NotBeNull(); keychainAdapter.OctokitCredentials.AuthenticationType.Should().Be(AuthenticationType.Anonymous); keychainAdapter.OctokitCredentials.Login.Should().BeNull(); keychainAdapter.OctokitCredentials.Password.Should().BeNull(); keychain.SetCredentials(new Credential(hostUri, username, password)); keychainAdapter.Credential.Should().NotBeNull(); keychainAdapter.Credential.Host.Should().Be(hostUri); keychainAdapter.Credential.Username.Should().Be(username); keychainAdapter.Credential.Token.Should().Be(password); keychainAdapter.OctokitCredentials.AuthenticationType.Should().Be(AuthenticationType.Basic); keychainAdapter.OctokitCredentials.Login.Should().Be(username); keychainAdapter.OctokitCredentials.Password.Should().Be(password); keychain.Clear(hostUri, false).Wait(); keychainAdapter.Credential.Should().BeNull(); keychainAdapter.OctokitCredentials.AuthenticationType.Should().Be(AuthenticationType.Anonymous); keychainAdapter.OctokitCredentials.Login.Should().BeNull(); keychainAdapter.OctokitCredentials.Password.Should().BeNull(); fileSystem.DidNotReceive().FileExists(Args.String); fileSystem.DidNotReceive().FileDelete(Args.String); fileSystem.DidNotReceive().ReadAllText(Args.String); fileSystem.DidNotReceive().ReadAllLines(Args.String); fileSystem.Received(1).WriteAllText(connectionsCacheFile, "[]"); credentialManager.DidNotReceive().Load(Args.UriString); credentialManager.DidNotReceive().HasCredentials(); credentialManager.DidNotReceive().Delete(Args.UriString); credentialManager.DidNotReceive().Save(Arg.Any <ICredential>()); }
public string GetWebPassword(Uri uri) { return(Keychain.FindInternetPassword(uri)); }
public void FixtureTeardown() { Keychain.DeleteKeychain(Keychain.CurrentKeychain); Keychain.CurrentKeychain = IntPtr.Zero; }
public void AddWebUserNameAndPassword(Uri url, string username, string password) { Keychain.AddInternetPassword(url, username, password); }
public Tuple <string, string> GetWebUserNameAndPassword(Uri url) { return(Keychain.FindInternetUserNameAndPassword(url)); }
public void ShouldLoadFromConnectionManager() { const string connectionsCachePath = @"c:\UserCachePath\"; const string connectionsCacheFile = @"c:\UserCachePath\connections.json"; var hostUri = new UriString("https://github.com/"); var fileSystem = SubstituteFactory.CreateFileSystem(new CreateFileSystemOptions { FilesThatExist = new List <string> { connectionsCacheFile }, FileContents = new Dictionary <string, IList <string> > { { connectionsCacheFile, new List <string> { @"[{""Host"":""https://github.com/"",""Username"":""SomeUser""}]" } } } }); NPath.FileSystem = fileSystem; var environment = SubstituteFactory.CreateEnvironment(); environment.UserCachePath.Returns(info => connectionsCachePath.ToNPath()); environment.FileSystem.Returns(fileSystem); const string username = "******"; const string token = "SomeToken"; var credentialManager = Substitute.For <ICredentialManager>(); credentialManager.Load(hostUri).Returns(info => { var credential = Substitute.For <ICredential>(); credential.Username.Returns(username); credential.Token.Returns(token); credential.Host.Returns(hostUri); return(credential); }); var keychain = new Keychain(environment, credentialManager); keychain.Initialize(); fileSystem.Received(1).FileExists(connectionsCacheFile); fileSystem.DidNotReceive().FileDelete(Args.String); fileSystem.Received(1).ReadAllText(connectionsCacheFile); fileSystem.DidNotReceive().ReadAllLines(Args.String); fileSystem.DidNotReceive().WriteAllText(Args.String, Args.String); fileSystem.DidNotReceive().WriteAllLines(Args.String, Arg.Any <string[]>()); var uriString = keychain.Hosts.FirstOrDefault(); var keychainAdapter = keychain.LoadFromSystem(uriString); keychainAdapter.Credential.Username.Should().Be(username); keychainAdapter.Credential.Token.Should().Be(token); keychainAdapter.Credential.Host.Should().Be(hostUri); credentialManager.Received(1).Load(hostUri); credentialManager.DidNotReceive().HasCredentials(); credentialManager.DidNotReceive().Delete(Args.UriString); credentialManager.DidNotReceive().Save(Arg.Any <ICredential>()); }
Task<string> createAlbumAndSaveLocalIdentifier () { var tcs = new TaskCompletionSource<string> (); string collectionLocalIdentifier = null; PHPhotoLibrary.SharedPhotoLibrary.PerformChanges(() => { var request = PHAssetCollectionChangeRequest.CreateAssetCollection("bugTrap"); collectionLocalIdentifier = request.PlaceholderForCreatedAssetCollection.LocalIdentifier; }, (success, error) => { if (success && !string.IsNullOrEmpty(collectionLocalIdentifier)) { var keychain = new Keychain<TrapAlbum> (new TrapAlbum ()); // ensure the album with that localIdentifier is var collectionResult = PHAssetCollection.FetchAssetCollections(new [] { collectionLocalIdentifier }, null); if (collectionResult != null) { var collection = collectionResult.firstObject as PHAssetCollection; if (collection != null) { albumLocalIdentifier = collectionLocalIdentifier; if (!tcs.TrySetResult(albumLocalIdentifier)) { var ex = new Exception ("createAlbumAndSaveLocalIdentifier Failed"); tcs.TrySetException(ex); // Log.Error(ex); } keychain.StoreKeyValues(new Dictionary<DataKeys, string> { { DataKeys.LocalIdentifier, albumLocalIdentifier } }); } } else { var ex = new Exception ("createAlbumAndSaveLocalIdentifier Failed"); tcs.TrySetException(ex); // Log.Error(ex); } } else { var ex = new Exception ("createAlbumAndSaveLocalIdentifier Failed"); tcs.TrySetException(ex); // Log.Error(ex); } }); return tcs.Task; }
public string SignTransaction(string transactionHex, WalletUnsignedTransactionUnspent[] unspents, Keychain userKeychain) { var hexEncoder = new NBitcoin.DataEncoders.HexEncoder(); var extKey = ExtKey.Parse(userKeychain.ExtendedPrivateKey); var builder = new TransactionBuilder().ContinueToBuild(Transaction.Parse(transactionHex)); foreach (var unspent in unspents) { builder .AddCoins(new ScriptCoin(new OutPoint(uint256.Parse(unspent.TransactionHash), unspent.TransactionOutputIndex), new TxOut(unspent.Value, new Script(hexEncoder.DecodeData(unspent.Script))), new Script(hexEncoder.DecodeData(unspent.RedeemScript)))) .AddKeys(extKey.Derive(KeyPath.Parse($"{userKeychain.Path}/0/0{unspent.ChainPath}")).PrivateKey); } return(builder.BuildTransaction(true).ToHex()); }