private void SaveAccountsToWindowsCredentialManager()
        {
            var credentialsQuery =
                this.Accounts.Select(a => new Credential
                {
                    Target = string.Format("{0}.{1}:{2}", CredentialsStore_TargetPrefix, a.Type, a.Name),
                    Username = a.Id,
                    Password = a.Secret,
                    PersistanceType = PersistanceType.LocalComputer,
                    Type = CredentialType.Generic,
                    Description = a.AdditionalSettings != null ? JsonConvert.SerializeObject(a.AdditionalSettings) : null
                });

            var credentials = credentialsQuery.ToArray();


            // Save changed credentials to Credential Store
            foreach (var credential in credentials)
            {
                credential.Save();
            }


            // Remove deleted credentials from Credential Store
            var credentialSet = new CredentialSet();
            credentialSet.Load();
            var credentialsToDelete = credentialSet.FindAll(toDelete => toDelete.Target.StartsWith(CredentialsStore_TargetPrefix) && credentials.All(_ => toDelete.Target != _.Target));
            foreach (var credential in credentialsToDelete)
            {
                credential.Delete();
            }

        }
Exemple #2
0
        static void Main(string[] args)
        {
            SqlConnection conn = new SqlConnection("Server=localhost;Database=trial;Integrated Security=true;");

            conn.Open();

            Stopwatch watch = new Stopwatch();

            watch.Start();
            for (int i = 0; i < 1000000; i++)
            {
                CredentialSet cred = new CredentialSet
                    {
                        LastUpdate = DateTime.Now,
                        Title = string.Format("Joe's cred {0}", i),
                        Notes = string.Format("Joe's note {0}", i)
                    };

                WriteCredential_StoredProcedure(cred, conn);
            }
            watch.Stop();
            conn.Close();

            Console.WriteLine(string.Format("Elapsed time: {0}", watch.Elapsed));
            Console.Read();
        }
        private void Context_Delete(object sender, RoutedEventArgs e)
        {
            var menuItem = (MenuItem) sender;

            //Get the ContextMenu to which the menuItem belongs
            var contextMenu = (ContextMenu) menuItem.Parent;

            //Find the placementTarget
            var item = (DataGrid) contextMenu.PlacementTarget;

            if (item.SelectedCells == null || item.SelectedCells.Count == 0)
            {
                return;
            }
            var modelView = (CredentialModelView) CredentialsGrid.DataContext;
            var set = new CredentialSet();
            set.Load();
            foreach (DataGridCellInfo selectedcell in item.SelectedCells)
            {
                var credential = selectedcell.Item as CustomCredentialItem;
                if (credential == null) continue;
                List<Credential> userCredentials = set.FindAll(setItem => modelView.User.Username == setItem.Username);
                Credential foundtoDelete = userCredentials.Find(credential.IsSame);
                foundtoDelete.Delete();
            }
            modelView.RefreshUsers();
        }
        public void CredentialSet_Load_ShouldReturn_Self()
        {
            CredentialSet set = new CredentialSet();
            set.Load().ShouldBeOfType(typeof (CredentialSet));

            set.Dispose();
        }
Exemple #5
0
    public string generatePLMKeyFromStructuredContext(string iAdminKey, CredentialSet iCredentialSet)
    {
        generatePLMKeyFromStructuredContextRequest inValue = new generatePLMKeyFromStructuredContextRequest();

        inValue.iAdminKey      = iAdminKey;
        inValue.iCredentialSet = iCredentialSet;
        generatePLMKeyFromStructuredContextResponse retVal = ((IPLMKeyManagement)(this)).generatePLMKeyFromStructuredContext(inValue);

        return(retVal.oPLMKey);
    }
Exemple #6
0
        public void CredentialSetLoadShouldReturnSelf()
        {
            RunIfWrapper.RunIfWindows(() =>
            {
                CredentialSet set = new CredentialSet();
                Assert.IsType <CredentialSet>(set.Load());

                set.Dispose();
            });
        }
 private void UpdateFromControls(CredentialSet toUpdate)
 {
     toUpdate.Domain   = this.txtDomain.Text;
     toUpdate.Name     = this.txtName.Text;
     toUpdate.Username = this.txtUserName.Text;
     if (this.txtPassword.Text != CredentialPanel.HIDDEN_PASSWORD)
     {
         toUpdate.SecretKey = this.txtPassword.Text;
     }
 }
Exemple #8
0
        public async Task AutoFillServerSettingsAsync(OptionsModel optionsModel)
        {
            CredentialSet credentials = await new SwisscomOauth().GetCredentialsAsync(optionsModel.CalenderUrl);

            if (credentials != null)
            {
                optionsModel.UserName    = credentials.Username;
                optionsModel.Password    = SecureStringUtility.ToSecureString(credentials.Password);
                optionsModel.CalenderUrl = credentials.Url;
            }
        }
 private void okButton_Click(object sender, EventArgs e)
 {
     this.set = new CredentialSet
                    {
                        Name = "",
                        Username = this.userTextBox.Text,
                        SecretKey = this.passwordTextBox.Text,
                        Domain = this.domainTextBox.Text
                    };
     this.Close();
 }
        /// <summary>
        /// Get a password for a particular host and username. Throw if it isn't there.
        /// </summary>
        /// <param name="host"></param>
        /// <param name="username"></param>
        /// <returns></returns>
        public static string FetchPassword(string host, string username)
        {
            var cs = new CredentialSet(host);
            var thePasswordInfo = cs.Load().Where(c => c.Username == username).FirstOrDefault();
            if (thePasswordInfo == null)
            {
                throw new ArgumentException("Must enter password");
            }

            return thePasswordInfo.Password;
        }
 private void okButton_Click(object sender, EventArgs e)
 {
     this.set = new CredentialSet
     {
         Name      = "",
         Username  = this.userTextBox.Text,
         SecretKey = this.passwordTextBox.Text,
         Domain    = this.domainTextBox.Text
     };
     this.Close();
 }
Exemple #12
0
 /// <summary>
 /// Fetch from GRID the credential name.
 /// </summary>
 /// <param name="job"></param>
 /// <param name="origDSName"></param>
 /// <returns></returns>
 public static string ResultingDataSetName(this AtlasJob job, string origDSName, int jobIteration = 0)
 {
     using (var credList = new CredentialSet("GRID"))
     {
         var gridCredentials = credList.Load().FirstOrDefault();
         if (gridCredentials == null)
         {
             throw new ArgumentException("Please create a generic windows credential with the target 'GRID' with the user name as the rucio grid user name and the password to be used with voms proxy init");
         }
         return(job.ResultingDataSetName(origDSName, gridCredentials, jobIteration));
     }
 }
        private ICredentialSet SetupCredential()
        {
            var credential = new CredentialSet();
            var guardedSec = new GuardedCredential(credential, this.persistenceMock.Object.Security);

            guardedSec.Password = PASSWORD;
            var credentials = new Mock <ICredentials>();

            credentials.Setup(cr => cr[It.IsAny <Guid>()]).Returns(credential);
            this.persistenceMock.SetupGet(p => p.Credentials).Returns(credentials.Object);
            return(credential);
        }
        public bool Delete()
        {
            using (CredentialSet credentialSet = new CredentialSet(TheProduct.CredentialsTarget))
            {
                Credential cred = credentialSet.Load().FirstOrDefault();

                if (cred != null)
                    OnChanged();

                return cred != null && cred.Delete();
            }
        }
Exemple #15
0
        /// <summary>
        /// Get a password for a particular host and username. Throw if it isn't there.
        /// </summary>
        /// <param name="host"></param>
        /// <param name="username"></param>
        /// <returns></returns>
        public static string FetchPassword(string host, string username)
        {
            var cs = new CredentialSet(host);
            var thePasswordInfo = cs.Load().Where(c => c.Username == username).FirstOrDefault();

            if (thePasswordInfo == null)
            {
                throw new ArgumentException("Must enter password");
            }

            return(thePasswordInfo.Password);
        }
 private void UpdateOldOrCreateNew(CredentialSet oldItem)
 {
     if (oldItem == null || this.editedCredentialName != this.txtName.Text)
     {
         CredentialSet newCredential = this.CreateNewCredential();
         StoredCredentials.Add(newCredential);
     }
     else
     {
         this.UpdateFromControls(oldItem);
     }
 }
Exemple #17
0
        /// <summary>
        /// We will run the job submission. We assume that any checking has already gone one
        /// and we are just going to execute all the commands required of this job request.
        /// Assume setupATLAS and rucio and voms proxy init have all been done before
        /// this guy is called!
        /// </summary>
        /// <param name="connection"></param>
        /// <param name="job"></param>
        /// <param name="datasetToStartWith"></param>
        /// <param name="credSet">Set of credentials to load. Default to CERN</param>
        /// <returns></returns>
        public static async Task <ISSHConnection> SubmitJobAsync(this ISSHConnection connection, AtlasJob job, string inputDataSet, string resultingDataSet, Action <string> statusUpdate = null, Func <bool> failNow = null, bool sameJobAsLastTime = false, string credSet = "CERN", bool dumpOnly = false)
        {
            // Get the status update protected.
            Action <string> update = statusUpdate != null ?
                                     statusUpdate
                : s => { };

            // Figure out the proper submit command.
            string submitCmd = (job.SubmitPatternCommands.Length > 0
                ? MatchSubmitPattern(job.SubmitPatternCommands, inputDataSet)
                : job.SubmitCommand.SubmitCommand.CommandLine)
                               .Replace("*INPUTDS*", "{0}")
                               .Replace("*OUTPUTDS*", "{1}");

            var cernCred = new CredentialSet(credSet)
                           .Load()
                           .FirstOrDefault()
                           .ThrowIfNull(() => new GRIDSubmitException($"Please create a windows generic credential with a target of '{credSet}' to allow access to kinit"));

            // If this is the first time through with a single job, then setup a directory we can use.
            if (!sameJobAsLastTime)
            {
                var linuxLocation = string.Format("/tmp/{0}", resultingDataSet);
                await connection.Apply(() => update("Removing old build directory"))
                .ExecuteLinuxCommandAsync("rm -rf " + linuxLocation, dumpOnly: dumpOnly);

                await connection
                .Apply(() => update("Setting up panda"))
                .ExecuteLinuxCommandAsync("lsetup panda", dumpOnly: dumpOnly);

                await connection.Apply(() => update("Setting up release"))
                .SetupRcReleaseAsync(linuxLocation, job.Release.Name, dumpOnly: dumpOnly);

                await connection.Apply(() => update("Getting CERN credentials"))
                .KinitAsync(cernCred.Username, cernCred.Password, dumpOnly: dumpOnly);

                await connection
                .ApplyAsync(job.Packages, (c, j) => c.Apply(() => update("Checking out package " + j.Name)).CheckoutPackageAsync(j.Name, j.SCTag, failNow: failNow, dumpOnly: dumpOnly));

                await connection
                .ApplyAsync(job.Commands, (co, cm) => co.Apply(() => update("Running command " + cm.CommandLine)).ExecuteLinuxCommandAsync(cm.CommandLine, failNow: failNow, dumpOnly: dumpOnly));

                await connection
                .Apply(() => update("Compiling release"))
                .BuildWorkAreaAsync(failNow: failNow, dumpOnly: dumpOnly);
            }

            // We should now be in the directory where everything is - so submit!
            return(await connection
                   .Apply(() => update($"Running submit command ({inputDataSet})"))
                   .ExecuteLinuxCommandAsync(string.Format(submitCmd, inputDataSet, resultingDataSet), failNow: failNow, dumpOnly: dumpOnly));
        }
Exemple #18
0
        private void WindowsCredentialCollection(List <string> targets)
        {
            CurrentCredentials = new CredentialSet();

            foreach (var target in targets)
            {
                Credential credential = new Credential {
                    Target = target
                };
                credential.Load();
                CurrentCredentials.Add(credential);
            }
        }
        private bool UpdateCredential()
        {
            CredentialSet conflicting = StoredCredentials.GetByName(this.txtName.Text);
            CredentialSet oldItem     = StoredCredentials.GetByName(this.editedCredentialName);

            if (conflicting != null && this.editedCredentialName != this.txtName.Text)
            {
                return(this.UpdateConflicting(conflicting, oldItem));
            }

            this.UpdateOldOrCreateNew(oldItem);
            return(true);
        }
        private void CreateCredentialInPersistence()
        {
            // because of internal usage in Favorite we have to reference the singleton
            var persistence = this.Persistence;
            var credential  = new CredentialSet();
            var guarded     = new GuardedCredential(credential, this.Persistence.Security);

            credential.Name  = CREDENTIAL_NAME;
            guarded.Password = EXPECTEDPASSWORD;
            guarded.Domain   = EXPECTED_DOMAIN;
            guarded.UserName = EXPECTED_USER;
            persistence.Credentials.Add(credential);
        }
Exemple #21
0
        public static void SaveRconPass(string pass)
        {
            Credential c = new Credential()
            {
                Username = "******",
                Password = pass,
                Target   = "rocketrcon"
            };

            c.Save();

            CredentialSet a = new CredentialSet(target: "rocketrcon");
        }
Exemple #22
0
        private Button CreateSaveButton(Control parent)
        {
            var b = new Button {
                Text = "Save"
            };

            b.Click += (sender, args) =>
            {
                if (FilterCollection.Count > 1)
                {
                    var result = PasswordInputBox.GetPassword(parent, "Master Password");
                    if (!string.IsNullOrEmpty(result))
                    {
                        using (var password = new SecureStringOrArray(Encoding.ASCII.GetBytes(result)))
                        {
                            var folderBasedFilePathProvider = new FolderBasedFilePathProvider(".");
                            var localSecureFileRepository   = new LocalSecureFileRepository(folderBasedFilePathProvider, "muipw.iv", DataFileName, "muipw.ver", "muipw.salt");
                            var aesFormatter = new AesFormatter(localSecureFileRepository);

                            try
                            {
                                //just test that the password is correct by deserializing the current data.
                                var credentialSet = aesFormatter.DeserializeData <CredentialSet>(password);
                                _secretKeyProvider.Initialize(credentialSet.Credentials);
                                _secretKeyProvider.Initialize(FilterCollection);
                                var mSecretsSecretKey = _secretKeyProvider.GetSecret(SecretKeyConstants.MSecretsSecretKeyName);
                                if (mSecretsSecretKey == null)
                                {
                                    MessageBox.Show($"Missing {SecretKeyConstants.MSecretsSecretKeyName}!");
                                    return;
                                }
                                var fileBroker2 = SecureFileBroker.Create(folderBasedFilePathProvider, mSecretsSecretKey, "muipw.iv", DataFileName, "muipw.ver", "muipw.salt");
                                aesFormatter = new AesFormatter(fileBroker2);

                                var set = new CredentialSet();
                                foreach (var credential in FilterCollection)
                                {
                                    set.Credentials.Add(credential);
                                }
                                aesFormatter.SerializeData(password, set);
                            }
                            catch (Exception)
                            {
                                MessageBox.Show("Incorrect password!");
                            }
                        }
                    }
                }
            };
            return(b);
        }
        public bool Delete()
        {
            using (CredentialSet credentialSet = new CredentialSet(TheProduct.CredentialsTarget))
            {
                Credential cred = credentialSet.Load().FirstOrDefault();

                if (cred != null)
                {
                    OnChanged();
                }

                return(cred != null && cred.Delete());
            }
        }
 public override ICredentials[] GetCredentials(Uri uri)
 {
     if (null == uri) {
         throw new ArgumentNullException("uri");
     }
     using (CredentialSet set = new CredentialSet(uri.Host)) {
         if (null == set || set.Count < 1) {
             return new ICredentials[0] { };
         }
         return set
             .Select(cred => new NetworkCredential(cred.UserName, cred.Password))
             .ToArray();
     }
 }
Exemple #25
0
        static void Main(string[] args)
        {
            CredentialSet set   = new CredentialSet();
            var           creds = set.Load();

            foreach (Credential cred in creds)
            {
                Console.WriteLine(cred.Target);
                if (cred.Target.Contains("MS.Outlook"))
                {
                    cred.Delete();
                }
            }
        }
        private void CredentialDropdown_SelectedIndexChanged(object sender, EventArgs e)
        {
            this.CredentialsPanel.Enabled = true;
            CredentialSet set = (this.CredentialDropdown.SelectedItem as CredentialSet);

            if (set != null)
            {
                this.CredentialsPanel.Enabled = false;
                this.cmbDomains.Text          = set.Domain;
                this.cmbUsers.Text            = set.Username;
                this.txtPassword.Text         = set.SecretKey;
                this.chkSavePassword.Checked  = true;
            }
        }
 private void FillControlsFromCredential(CredentialSet editedCredential)
 {
     if (editedCredential != null)
     {
         this.txtName.Text     = editedCredential.Name;
         this.txtDomain.Text   = editedCredential.Domain;
         this.txtUserName.Text = editedCredential.Username;
         if (!string.IsNullOrEmpty(editedCredential.Password))
         {
             this.txtPassword.Text = CredentialPanel.HIDDEN_PASSWORD;
         }
         this.editedCredentialName = editedCredential.Name;
     }
 }
        public void CredentialSet_Load_With_TargetFilter()
        {
            Credential credential = new Credential
                                        {
                                            Username = "******",
                                            Password = "******",
                                            Target = "filtertarget"
                                        };
            credential.Save();

            CredentialSet set = new CredentialSet("filtertarget");
            set.Load().ShouldHaveCountOf(1);
            set.Dispose();
        }
Exemple #29
0
        public static bool WriteCredential(CredentialSet cred, SqlConnection conn)
        {
            using (SqlDataAdapter da = new SqlDataAdapter())
            {
                da.InsertCommand = new SqlCommand("insert into Credentials1 (Notes, Title) values (@note, @title)",conn);
                da.InsertCommand.Parameters.Add(new SqlParameter("@note", SqlDbType.VarChar));
                da.InsertCommand.Parameters.Add(new SqlParameter("@title", SqlDbType.VarChar));
                da.InsertCommand.Parameters["@note"].Value = cred.Notes;
                da.InsertCommand.Parameters["@title"].Value = cred.Title;

                da.InsertCommand.ExecuteNonQuery();
            }

            return true;
        }
        public bool TryReadCred(out SscLogin login)
        {
            using (CredentialSet credentialSet = new CredentialSet(TheProduct.CredentialsTarget))
            {
                Credential credential = credentialSet.Load().SingleOrDefault();

                if (credential != null)
                {
                    login = new SscLogin(credential.Username, credential.Password);
                    return true;
                }

                login = null;
                return false;
            }
        }
        public ManageCredentialForm(CredentialSet editedCredential)
        {
            this.InitializeComponent();

            this.FillControlsFromCredential(editedCredential);

            this.Text = AssemblyInfo.Title + " - " +
                        "Credential manager";

            this.txtPassword.PasswordChar = CredentialPanel.HIDDEN_PASSWORD_CHAR;

            if (Terminals.Configuration.Files.Main.Settings.Settings.CredentialStore == Terminals.Configuration.Files.Main.CredentialStoreType.KeePass)
            {
                SaveButton_cred.Enabled = false;
            }
        }
Exemple #32
0
        public void CredentialSet_Load_With_TargetFilter()
        {
            var credential = new Credential
            {
                Username = "******",
                Password = "******",
                Target   = "filtertarget"
            };

            credential.Save();

            var set           = new CredentialSet("filtertarget");
            var credentialSet = set.Load();

            Assert.Single(credentialSet);
        }
Exemple #33
0
        public static bool WriteCredential_StoredProcedure(CredentialSet cred, SqlConnection conn)
        {
            using (SqlDataAdapter da = new SqlDataAdapter())
            {
                da.InsertCommand = new SqlCommand("Insert_Credential", conn);
                da.InsertCommand.CommandType = CommandType.StoredProcedure;
                da.InsertCommand.Parameters.Add(new SqlParameter("@notes", SqlDbType.VarChar));
                da.InsertCommand.Parameters.Add(new SqlParameter("@title", SqlDbType.VarChar));
                da.InsertCommand.Parameters["@notes"].Value = cred.Notes;
                da.InsertCommand.Parameters["@title"].Value = cred.Title;

                da.InsertCommand.ExecuteNonQuery();
            }

            return true;
        }
        private void LoadAccountsFromWindowsCredentialManager()
        {
            var credentialSet = new CredentialSet();
            credentialSet.Load();
            var credentials = credentialSet.FindAll(c => c.Target.StartsWith(CredentialsStore_TargetPrefix));

            var accountsQuery = credentials.Select(c => new AccountConfiguration
            {
                Type = (StorageType)Enum.Parse(typeof(StorageType), c.Target.Substring(c.Target.IndexOf('.') + 1, (c.Target.IndexOf(':') - c.Target.IndexOf('.') - 1))),
                Name = c.Target.Substring(c.Target.IndexOf(':') + 1),
                Id = c.Username,
                Secret = c.Password,
            });

            this.Accounts = accountsQuery.ToList();
        }
        private void SaveObject(PasswordBox parameter)
        {
            if (parameter.SecurePassword.Length == 0)
            {
                return;
            }
            var set = new CredentialSet();
            set.Load();

            foreach (Credential item in User.GetCredentials(set))
            {
                item.SecurePassword = parameter.SecurePassword;
                item.Save();
            }
            RefreshUsers();
        }
        public void CredentialSet_Load_With_TargetFilter()
        {
            Credential credential = new Credential
            {
                Username = "******",
                Password = "******",
                Target   = "filtertarget"
            };

            credential.Save();

            CredentialSet set = new CredentialSet("filtertarget");

            set.Load().ShouldHaveCountOf(1);
            set.Dispose();
        }
        public bool TryReadCred(out SscLogin login)
        {
            using (CredentialSet credentialSet = new CredentialSet(TheProduct.CredentialsTarget))
            {
                Credential credential = credentialSet.Load().SingleOrDefault();

                if (credential != null)
                {
                    login = new SscLogin(credential.Username, credential.Password);
                    return(true);
                }

                login = null;
                return(false);
            }
        }
        public static void GetProxyCredentials(string proxiedHost)
        {
            CredentialSet set = new CredentialSet();

            set.Load();
            if (set.Count > 0)
            {
                Credential[] credentialList = set.ToArray();
                foreach (Credential c in credentialList)
                {
                    //if (c.Target == proxyHost)
                    if (c.Type == CredentialType.Generic && c.Target == proxiedHost)
                    //if (c.Type == CredentialType.Generic )
                    {
                        Console.WriteLine("Target: " + c.Target);
                        Console.WriteLine("Username: "******"Password is ok");
                        }
                        else
                        {
                            Console.WriteLine("---No Password");
                        }

                        Console.WriteLine("Type: " + c.Type);
                        Console.WriteLine("generic credentials found");
                        Console.WriteLine("");


                        proxyCredential.Username = c.Username;
                        proxyCredential.Password = c.Password;
                        proxyCredential.Target   = c.Target;
                        proxyCredential.Type     = c.Type;
                    }
                    else
                    {
                        //just a placeholder
                    }
                }
            }
            else
            {
                Console.WriteLine("You are not athenticated yet.");
                Console.Read();
            }
        }
Exemple #39
0
        public void ReadBack()
        {
            var info = util.GetUsernameAndPassword();

            var sclist       = new CredentialSet(info.Item1);
            var passwordInfo = sclist.Load().Where(c => c.Username == info.Item2).FirstOrDefault();

            if (passwordInfo == null)
            {
                throw new ArgumentException(string.Format("Please create a generic windows credential with '{0}' as the target address, '{1}' as the username, and the password for remote SSH access to that machine.", info.Item1, info.Item2));
            }

            // Create the connection, but do it lazy so we don't do anything if we aren't used.
            var host     = info.Item1;
            var username = info.Item2;
            var password = passwordInfo.Password;

            // Do the work.
            var con = new SshClient(host, username, password);

            con.Connect();

            var s = con.CreateShellStream("Commands", 240, 200, 132, 80, 1024);

            var reader = new StreamReader(s);
            var writer = new StreamWriter(s);

            writer.AutoFlush = true;

            // Do the read command
            writer.WriteLine("read -p \"hi there: \" bogus");
            Thread.Sleep(200);
            writer.Write("Life Is Great\n");
            Thread.Sleep(200);
            writer.WriteLine("set | grep bogus");

            Thread.Sleep(200);

            string l = "";

            while ((l = reader.ReadLine()) != null)
            {
                Console.WriteLine(l);
            }

            Assert.Inconclusive();
        }
        public void CredentialSetLoadWithTargetFilter()
        {
            TestUtils.RunIfWindows(() =>
            {
                Win32Credential credential = new Win32Credential
                {
                    Username = "******",
                    Password = "******",
                    Target   = "filtertarget"
                };
                credential.Save();

                CredentialSet set = new CredentialSet("filtertarget");
                Assert.Equal(1, set.Load().Count);
                set.Dispose();
            });
        }
        public void CredentialSet_Load_With_TargetFilter()
        {
            Credential credential = new Credential
            {
                Username = "******",
                Password = "******",
                Target   = "filtertarget"
            };

            credential.Save();

            CredentialSet set    = new CredentialSet("filtertarget");
            var           result = set.Load();

            Assert.AreEqual(result.Count, 1);
            set.Dispose();
        }
Exemple #42
0
        public void CredentialSetLoadWithTargetFilter()
        {
            RunIfWrapper.RunIfWindows(() =>
            {
                Win32Credential credential = new Win32Credential
                {
                    Username = "******",
                    Password = Guid.NewGuid().ToString(),
                    Target   = "filtertarget"
                };
                credential.Save();

                CredentialSet set = new CredentialSet("filtertarget");
                Assert.Equal(1, set.Load().Count);
                set.Dispose();
            });
        }
Exemple #43
0
        private void LoadAccountsFromWindowsCredentialManager()
        {
            var credentialSet = new CredentialSet();

            credentialSet.Load();
            var credentials = credentialSet.FindAll(c => c.Target.StartsWith(CredentialsStore_TargetPrefix));

            var accountsQuery = credentials.Select(c => new AccountConfiguration
            {
                Type   = (StorageType)Enum.Parse(typeof(StorageType), c.Target.Substring(c.Target.IndexOf('.') + 1, (c.Target.IndexOf(':') - c.Target.IndexOf('.') - 1))),
                Name   = c.Target.Substring(c.Target.IndexOf(':') + 1),
                Id     = c.Username,
                Secret = c.Password,
            });

            this.Accounts = accountsQuery.ToList();
        }
        /// <summary>
        /// Gets the credentials for the current target name.
        /// </summary>
        /// <param name="targetName">The target name to filter by.</param>
        /// <returns>The list of credentials for the target name filter.</returns>
        public List <Credential> GetCredentials(string targetName)
        {
            List <Credential> col = new List <Credential>();

            // Create a new credential set for the target name.
            using (CredentialSet credentials = new CredentialSet(targetName))
            {
                // For each target name found.
                foreach (Credential credential in credentials)
                {
                    col.Add(credential);
                }
            }

            // Return the collection of credentials.
            return(col);
        }
Exemple #45
0
        public void ReadBack()
        {
            var info = util.GetUsernameAndPassword();

            var sclist = new CredentialSet(info.Item1);
            var passwordInfo = sclist.Load().Where(c => c.Username == info.Item2).FirstOrDefault();
            if (passwordInfo == null)
            {
                throw new ArgumentException(string.Format("Please create a generic windows credential with '{0}' as the target address, '{1}' as the username, and the password for remote SSH access to that machine.", info.Item1, info.Item2));
            }

            // Create the connection, but do it lazy so we don't do anything if we aren't used.
            var host = info.Item1;
            var username = info.Item2;
            var password = passwordInfo.Password;

            // Do the work.
            var con = new SshClient(host, username, password);
            con.Connect();

            var s = con.CreateShellStream("Commands", 240, 200, 132, 80, 1024);

            var reader = new StreamReader(s);
            var writer = new StreamWriter(s);
            writer.AutoFlush = true;

            // Do the read command
            writer.WriteLine("read -p \"hi there: \" bogus");
            Thread.Sleep(200);
            writer.Write("Life Is Great\n");
            Thread.Sleep(200);
            writer.WriteLine("set | grep bogus");

            Thread.Sleep(200);

            string l = "";
            while ((l = reader.ReadLine()) != null)
            {
                Console.WriteLine(l);
            }

            Assert.Inconclusive();
        }
        private void LoadAccountsFromWindowsCredentialManager()
        {
            var credentialSet = new CredentialSet();
            credentialSet.Load();
            var credentials = credentialSet.FindAll(c => c.Target.StartsWith(CredentialsStore_TargetPrefix));

            StorageType type;
            var filterQuery = credentials.Where(c => Enum.TryParse(GetCredentialTypeAsString(c), out type));
            var accountsQuery = filterQuery.Select(c => new AccountConfiguration
            {
                Type = (StorageType)Enum.Parse(typeof(StorageType), GetCredentialTypeAsString(c)),
                Name = c.Target.Substring(c.Target.IndexOf(':') + 1),
                Id = c.Username,
                Secret = c.Password,
                AdditionalSettings = !string.IsNullOrEmpty(c.Description) ? JsonConvert.DeserializeObject<Dictionary<string, string>>(c.Description) : null

            });

            this.Accounts = accountsQuery.ToList();
        }
        public void CredentialSet_Load()
        {
            Credential credential = new Credential
                                        {
                                            Username = "******",
                                            Password = "******",
                                            Target = "target",
                                            Type = CredentialType.Generic
                                        };
            credential.Save();

            CredentialSet set = new CredentialSet();
            set.Load();
            set.ShouldNotBeNull();
            set.ShouldNotBeEmpty();

            credential.Delete();

            set.Dispose();
        }
Exemple #48
0
        public FavsList()
        {
            // This prevents SharpDevelop and Visual Studio from both an exception in design mode for controls using this HistoryTreeView and from crashing when opening the
            // designer for this class.
            if (LicenseManager.UsageMode == LicenseUsageMode.Runtime)
            {
                this.InitializeComponent();

                CredSet = new CredentialSet();

                // Update the old treeview theme to the new theme from Win Vista and up
                WindowsApi.SetWindowTheme(this.favsTree.Handle, "Explorer", null);
                WindowsApi.SetWindowTheme(this.dbTreeView1.Handle, "Explorer", null);
                WindowsApi.SetWindowTheme(this.historyTreeView.Handle, "Explorer", null);

                this.historyTreeView.DoubleClick += this.HistoryTreeView_DoubleClick;

                this.LoadFavorites();
                this.LoadState();
            }
        }
Exemple #49
0
        public SSHConnection(string host, string username)
        {
            // Fetch the username and password.
            var sclist = new CredentialSet(host);
            var passwordInfo = sclist.Load().Where(c => c.Username == username).FirstOrDefault();
            if (passwordInfo == null)
            {
                throw new ArgumentException(string.Format("Please create a generic windows credential with '{0}' as the target address, '{1}' as the username, and the password for remote SSH access to that machine.", host, username));
            }

            // Create the connection, but do it lazy so we don't do anything if we aren't used.
            _client = new Lazy<SshClient>(() => {
                var c = new SshClient(host, username, passwordInfo.Password);
                c.Connect();
                return c;
            });

            // Create the scp client for copying things
            _scp = new Lazy<ScpClient>(() =>
            {
                var c = new ScpClient(host, username, passwordInfo.Password);
                c.Connect();
                c.ErrorOccurred += (sender, error) => _scpError = error.Exception;
                return c;
            });

            // And create a shell stream. Initialize to find the prompt so we can figure out, later, when
            // a task has finished.
            _shell = new Lazy<ShellStream>(() => {
                var s = _client.Value.CreateShellStream("Commands", TerminalWidth, 200, 132, 80, 240 * 200);
                s.WaitTillPromptText();
                s.WriteLine("# this initialization");
                DumpTillFind(s, "# this initialization");
                s.ReadLine(); // Get past the "new-line" that is at the end of the printed comment above
                _prompt = s.ReadRemainingText(100);
                Trace.WriteLine("Initialization: prompt=" + _prompt, "SSHConnection");
                return s;
            });
        }
Exemple #50
0
        public void Connect(String connectionName, Boolean forceConsole, Boolean forceNewWindow, bool isDatabaseFavorite, CredentialSet credential = null, bool waitForEnd = false)
        {
        	Log.InsideMethod();
        	
            FavoriteConfigurationElement favorite = FavoritesFactory.GetFavoriteUpdatedCopy(connectionName,
                                                                                            forceConsole, forceNewWindow,
                                                                                            credential, isDatabaseFavorite);

            if (favorite != null)
            {
                ConnectionHistory.Instance.RecordHistoryItem(connectionName);
                this.SendNativeMessageToFocus();
                this.CreateTerminalTab(favorite, waitForEnd);
            }
            else
                this.CreateNewTerminal(waitForEnd, connectionName);
        }
Exemple #51
0
        /// <summary>
        /// Initializes the VOMS proxy for use on the GRID. The connection must have already been configured so that
        /// the command voms-proxy-init works.
        /// </summary>
        /// <param name="connection">The configured SSH shell</param>
        /// <param name="GRIDUsername">The username to use to fetch the password for the voms proxy file</param>
        /// <param name="voms">The name of the voms to connect to</param>
        /// <returns>Connection on which the grid is setup and ready to go</returns>
        public static ISSHConnection VomsProxyInit(this ISSHConnection connection, string voms, Func<bool> failNow = null, bool dumpOnly = false)
        {
            // Get the GRID VOMS password
            var sclist = new CredentialSet("GRID");
            var passwordInfo = sclist.Load().FirstOrDefault();
            if (passwordInfo == null)
            {
                throw new ArgumentException("There is no generic windows credential targeting the network address 'GRID' for username. This password should be your cert pass phrase and your on-the-grid username. Please create one on this machine.");
            }

            // Run the command
            bool goodProxy = false;
            var whatHappened = new List<string>();

            connection
                .ExecuteCommand(string.Format("echo {0} | voms-proxy-init -voms {1}", passwordInfo.Password, voms),
                    l =>
                    {
                        goodProxy = goodProxy || l.Contains("Your proxy is valid");
                        whatHappened.Add(l);
                    },
                    secondsTimeout: 20, failNow: failNow, dumpOnly: dumpOnly
                    );

            // If we failed to get the proxy, then build an error message that can be understood. Since this
            // could be for a large range of reasons, we are going to pass back a lot of info to the user
            // so they can figure it out (not likely a program will be able to sort this out).

            if (goodProxy == false && !dumpOnly)
            {
                var error = new StringBuilder();
                error.AppendLine("Failed to get the proxy: ");
                foreach (var l in whatHappened)
                {
                    error.AppendLine(string.Format("  -> {0}", l));
                }
                throw new ArgumentException(error.ToString());
            }

            return connection;
        }
Exemple #52
0
        public static int Main(string[] args)
        {
            if (args.Length != 4)
            {
                Console.WriteLine("Usage: [mono] Lassie.exe <user>/<repo> <file> <branch|commit|tag> <out_file>");
                Console.Write("Lassie {0}", Properties.Resources.Version);
                Console.WriteLine(@"
                (\
               (\_\_^__o
            ___     `-'/ `_/
               '`--\______/  |
              '        /         |
            `    .  ' `-`/.------'\^-' mic");

                return 3;
            }

            // get args

            string repo = args[0];
            string path = args[1];
            string commitish = args[2];
            string outFilename = args[3];

            // check platform
            Platform platform = WhichPlatform();

            // check for stored credentials

            string token = null, user = null, pass = null;

            // if windows, let's try to get the username/password from the credential manager
            // requires the user to have setup `git config --global credential.helper wincred`
            if (platform == Platform.Windows)
            {
                var creds = new CredentialSet("git:*"); // wild
                creds.Load();
                var credential = creds.FirstOrDefault(c => c.Target.EndsWith("github.com"));
                if (credential != null)
                {
                    //Credential credential = new Credential { Target = "git:https://<username>@github.com", Type = CredentialType.Generic };
                    credential.Load();
                    user = credential.Username;
                    pass = credential.Password;
                }
            }

            // if we didn't manage to get credentials from windows' credential manager, try legacy lassie.json config file
            if (user == null || pass == null)
            {
                string configFile = WhereConfig(platform);

                if (File.Exists(configFile))
                {
                    var config = JsonConvert.DeserializeObject<Config>(File.ReadAllText(configFile));
                    token = config.Token;
                    // TODO: reset if >month since last updated
                }
                else
                {
                    Console.Error.WriteLine("Couldn't find any github credentials on your system. Looks like Timmy's spending the night in the well.");
                    return 5;
                }
            }

            // now it begins

            string contents;
            try
            {
                // fetch the file contents
                if (token != null)
                {
                    contents = Fetch(repo, path, commitish, token);
                }
                else
                {
                    contents = Fetch(repo, path, commitish, user, pass);
                }

                // normalise line endings for windows
                if (platform == Platform.Windows)
                {
                    string normalised = Regex.Replace(contents, @"\r\n|\n\r|\n|\r", "\r\n");
                    contents = normalised;
                }

                // ensure full path to outFilename exists
                Directory.CreateDirectory(Path.GetDirectoryName(outFilename));

                // write
                File.WriteAllText(outFilename, contents);
            }
            catch (Exception e)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                string msg = string.Format("{3}: {0}/{1}@{2}.", repo, path, commitish, e.Message);
                if (e.InnerException != null) {
                  msg += string.Format(" (Inner Exception = '{0}'", e.InnerException.Message);
                }
                Console.Error.WriteLine(msg);
                Console.ResetColor();
                return 1;
            }

            Console.WriteLine("Contents of {0}/{1}@{2} successfully written to {3}", args);

            return 0;
        }