Example #1
0
		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)));
		}
Example #3
0
        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>());
        }
Example #4
0
        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();
        }
Example #5
0
		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;
		}
Example #6
0
		/// <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;
		}
Example #7
0
 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);
Example #10
0
        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);
                }
            }
        }
Example #11
0
 public AddPublicKeyDialog(Keychain keychain)
 {
     InitializeComponent();
     Keychain = keychain;
 }
Example #12
0
 public KeychainViewerViewModel(Keychain keychain)
 {
     rlSettingsService = SP.GetService <RuriLibSettingsService>();
     this.keychain     = keychain;
 }
Example #13
0
        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());
        }
Example #14
0
        public static void show_info(WalletConfig config, Keychain keychain)
        {
            var txt = build_info(config, keychain);

            Console.WriteLine(txt);
        }
Example #15
0
        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;
 }
Example #17
0
        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;
            }
        }
Example #18
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);
        }
Example #19
0
 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>());
        }
Example #21
0
 public string GetWebPassword(Uri uri)
 {
     return(Keychain.FindInternetPassword(uri));
 }
Example #22
0
 public void FixtureTeardown()
 {
     Keychain.DeleteKeychain(Keychain.CurrentKeychain);
     Keychain.CurrentKeychain = IntPtr.Zero;
 }
Example #23
0
 public void AddWebUserNameAndPassword(Uri url, string username, string password)
 {
     Keychain.AddInternetPassword(url, username, password);
 }
Example #24
0
 public Tuple <string, string> GetWebUserNameAndPassword(Uri url)
 {
     return(Keychain.FindInternetUserNameAndPassword(url));
 }
Example #25
0
        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>());
        }
Example #26
0
		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;
		}
Example #27
0
        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());
        }