private int GitCredentialHandler( out IntPtr ptr, IntPtr cUrl, IntPtr usernameFromUrl, GitCredentialType credTypes, IntPtr payload) { string url = LaxUtf8Marshaler.FromNative(cUrl); string username = LaxUtf8Marshaler.FromNative(usernameFromUrl); SupportedCredentialTypes types = default(SupportedCredentialTypes); if (credTypes.HasFlag(GitCredentialType.UserPassPlaintext)) { types |= SupportedCredentialTypes.UsernamePassword; } if (credTypes.HasFlag(GitCredentialType.Default)) { types |= SupportedCredentialTypes.Default; } var cred = CredentialsProvider(url, username, types); return(cred.GitCredentialHandler(out ptr)); }
public CredentialsDialog (string uri, SupportedCredentialTypes type, Credentials cred) { this.Build (); this.UseNativeContextMenus (); labelTop1.Text = string.Format (labelTop1.Text, uri); var table = new Table (0, 0, false); table.ColumnSpacing = 6; vbox.PackStart (table, true, true, 0); Widget firstEditor = null; switch (type) { case SupportedCredentialTypes.UsernamePassword: upcred = (UsernamePasswordCredentials)cred; firstEditor = CreateEntry (table, "Username:"******"Password:"******"Passphrase:", true); break; } table.ShowAll (); Focus = firstEditor; Default = buttonOk; }
public static Credentials WinCred(string url, string usernameFromUrl, SupportedCredentialTypes types) { var creds = new Credential { Target = url, Type = CredentialType.Generic }; if (creds.Load()) { return new UsernamePasswordCredentials { Username = creds.Username, Password = creds.Password } } ; var uri = new Uri(url); var userPart = (string.IsNullOrEmpty(usernameFromUrl) ? string.Empty : usernameFromUrl + "@"); creds.Target = $"git:{uri.Scheme}://{userPart}{uri.Host}"; if (!creds.Load()) { creds.Target += "/"; creds.Load(); } return(new UsernamePasswordCredentials { Username = creds.Username, Password = creds.Password }); }
private Credentials CredentialsProvider(string url, string usernameFromUrl, SupportedCredentialTypes types) { return(new UsernamePasswordCredentials { Username = Username, Password = Password, }); }
private Credentials OnCredentialsRequested(string forUrl, string usernameFromUrl, SupportedCredentialTypes types) { if (types == SupportedCredentialTypes.Default) { return new DefaultCredentials(); } else { var credentials = Task.Run(() => store.GetCredentialsAsync()).Result; if (credentials != null) { var credential = credentials.Where(c => c.Url == forUrl && (string.IsNullOrEmpty(usernameFromUrl) ? true : c.UserName == usernameFromUrl)).SingleOrDefault(); if (credential != null) { return new UsernamePasswordCredentials() { Username = credential.UserName, Password = credential.Password }; } } if (types == SupportedCredentialTypes.Default) { return new DefaultCredentials(); } else { return new UsernamePasswordCredentials(); } } }
public CredentialsDialog(string uri, SupportedCredentialTypes type, Credentials cred) { this.Build(); this.UseNativeContextMenus(); labelTop1.Text = string.Format(labelTop1.Text, uri); var table = new Table(0, 0, false); table.ColumnSpacing = 6; vbox.PackStart(table, true, true, 0); Widget firstEditor = null; switch (type) { case SupportedCredentialTypes.UsernamePassword: upcred = (UsernamePasswordCredentials)cred; firstEditor = CreateEntry(table, "Username:"******"Password:"******"Passphrase:", true); break; } table.ShowAll(); Focus = firstEditor; Default = buttonOk; }
private Credentials CredentialsProvider(string url, string usernameFromUrl, SupportedCredentialTypes types) { _credentials = new UsernamePasswordCredentials { Username = _allConfiguration.VsoConfiguration.ApiPat, // YOUR TOKEN HERE Password = string.Empty }; return(_credentials); }
private Credentials CredentialsProvider(string url, string usernameFromUrl, SupportedCredentialTypes types) { _credentials = new UsernamePasswordCredentials { Username = _allConfiguration.VsoConfiguration.ApiUsername, Password = _allConfiguration.VsoConfiguration.ApiPassword }; return _credentials; }
/// <summary> /// Provide the credentials from this object. /// </summary> /// <param name="url">The url to provide credentials for.</param> /// <param name="usernameFromUrl">The user to provide credentials for.</param> /// <param name="types">The type of credentials to provide.</param> /// <returns>The credentials to use.</returns> private Credentials ProvideCredentials(string url, string usernameFromUrl, SupportedCredentialTypes types) { UsernamePasswordCredentials c = new UsernamePasswordCredentials(); c.Username = Username; c.Password = Password; return(c); }
private Credentials CredentialsProvider(string url, string usernameFromUrl, SupportedCredentialTypes types) { _credentials = new UsernamePasswordCredentials { Username = _allConfiguration.VsoConfiguration.ApiUsername, Password = _allConfiguration.VsoConfiguration.ApiPassword }; return(_credentials); }
private Credentials CreateCredentials(string url, string user, SupportedCredentialTypes supportedCredentialTypes) { var userInformationService = _appServiceProvider.GetService <IUserInformationService>(); return(new SecureUsernamePasswordCredentials { Username = userInformationService.ConnectionData.UserName, Password = userInformationService.ConnectionData.Password.ToSecureString(), }); }
/// <summary> /// This is a callback from libgit2 /// </summary> /// <returns></returns> public Credentials HandleCredentials([AllowNull]string url, [AllowNull]string username, SupportedCredentialTypes types) { if (url == null) return null; // wondering if we should return DefaultCredentials instead var host = HostAddress.Create(url); return secureCache.GetObject<Tuple<string, SecureString>>("login:" + host.CredentialCacheKeyHost) .Select(CreateCredentials) .Catch(Observable.Return<Credentials>(null)) .Wait(); }
// url, usernameFromUrl, types private UsernamePasswordCredentials GetCredentials( string url, string usernameFromUrl, SupportedCredentialTypes types) { return(new UsernamePasswordCredentials { Username = login, Password = password, }); }
public static Task <bool> Run(string url, SupportedCredentialTypes types, Credentials cred, Components.Window parentWindow = null) { return(Runtime.RunInMainThread(() => { var engine = Platform.IsMac ? Toolkit.NativeEngine : Toolkit.CurrentEngine; var response = false; engine.Invoke(() => { using (var xwtDialog = new XwtCredentialsDialog(url, types, cred)) { response = xwtDialog.Run(parentWindow ?? IdeServices.DesktopService.GetFocusedTopLevelWindow()) == Command.Ok; } }); return response; })); }
/// <summary> /// This is a callback from libgit2 /// </summary> /// <returns></returns> public Credentials HandleCredentials(string url, string username, SupportedCredentialTypes types) { if (url == null) { return(null); // wondering if we should return DefaultCredentials instead } var host = HostAddress.Create(url); return(secureCache.GetObject <Tuple <string, SecureString> >("login:" + host.CredentialCacheKeyHost) .Select(CreateCredentials) .Catch(Observable.Return <Credentials>(null)) .Wait()); }
public static Credentials MicrosoftAlm(string url, string usernameFromUrl, SupportedCredentialTypes types) { var cleanUrl = new Uri(url).GetComponents(UriComponents.SchemeAndServer, UriFormat.SafeUnescaped); var auth = new BasicAuthentication(new SecretStore("git")); var newCreds = auth.GetCredentials(new TargetUri(cleanUrl)); return(newCreds == null ? null : new UsernamePasswordCredentials { Username = newCreds.Username, Password = newCreds.Password }); }
Credentials CredentialsProvider(string url, string usernameFromUrl, SupportedCredentialTypes types) { var selected = Program.GetInstance().RemoteManager.SelectedRemote; if (selected.UserName != "" && selected.Password != "") { return(AuthentificateFromLog(selected.UserName, selected.Password)); } else { return(PrompUserAuthentification()); } }
static Credentials OnHandleCredentials(string url, string usernameFromUrl, SupportedCredentialTypes types) { var secrets = new SecretStore("git"); var auth = new BasicAuthentication(secrets); // See https://github.com/microsoft/Git-Credential-Manager-for-Windows/issues/859 var uri = new Uri(url); var creds = auth.GetCredentials(new TargetUri(uri.GetComponents(UriComponents.Scheme | UriComponents.Host, UriFormat.Unescaped))); return(new UsernamePasswordCredentials { Username = creds.Username, Password = creds.Password, }); }
public Credentials GetCredentials(string url, string usernameFromUrl, SupportedCredentialTypes types) { var uri = new Uri(url); var host = uri.Scheme + Uri.SchemeDelimiter + uri.Host; var secrets = new SecretStore("git"); var auth = new BasicAuthentication(secrets); var creds = auth.GetCredentials(new TargetUri(host)); return(new UsernamePasswordCredentials() { Username = creds.Username, Password = creds.Password }); }
public Credentials GetCredentials(string url, string usernameFromUrl, SupportedCredentialTypes types) { if (OAuth2TokenCredentials == null) { // TODO the token should be kept somewhere to implement refresh token scenario one day var token = TokenProvider.GetClientCredentialsToken(); OAuth2TokenCredentials = new UsernamePasswordCredentials { Username = "******", Password = token.AccessToken }; } return(OAuth2TokenCredentials); }
public bool GetCredentials(string url, string user, SupportedCredentialTypes supportedCredentials, out Credentials credentials, out string message) { try { credentials = GetCredentialsFromTerminal(url); message = "[WindowsCredentialManager] Recieved credentials"; return(true); } catch (Exception e) { credentials = new DefaultCredentials(); //This is a hack to get the exception information out. since Lib2GitSharp keeps eating it! message = "[WindowsCredentialManager] Exception getting credentials: " + e.Message; return(false); } }
public Credentials GetCredentials(string url, string usernameFromUrl, SupportedCredentialTypes types) { var uri = new Uri(url); var cleaned = uri.Authority + uri.PathAndQuery + uri.Fragment; var creds = config.GetSection("Repository:Credentials").GetSection(cleaned); if (!string.IsNullOrEmpty(creds["Username"]) && !string.IsNullOrEmpty(creds["Password"])) { return(new UsernamePasswordCredentials() { Username = creds["Username"], Password = creds["Password"] }); } logger.LogWarning("Failed to get credentials for '{cleaned}'.", cleaned); return(null); }
private Credentials GetCredentials(string url, string usernameFromUrl, SupportedCredentialTypes types) { var uri = new Uri(url); var target = $"git:{uri.Scheme}://{uri.Host}"; var credential = new Credential { Target = target }; if (!credential.Load()) { throw new ArgumentException($"No credential was found for \"{target}\""); } return(new UsernamePasswordCredentials { Username = credential.Username, Password = credential.Password }); }
public XwtCredentialsDialog(string uri, SupportedCredentialTypes supportedCredential, Credentials credentials) { Title = GettextCatalog.GetString("Git Credentials"); Resizable = false; Width = 500; var mainContainer = new VBox(); Content = mainContainer; //Credentials var credentialsLabel = new Label(GettextCatalog.GetString("Credentials required for the repository:")) { Wrap = WrapMode.Word }; mainContainer.PackStart(credentialsLabel); var credentialValue = new Label { Markup = string.Format(credentialMarkupFormat, uri), Wrap = WrapMode.Word }; mainContainer.PackStart(credentialValue); if (supportedCredential.HasFlag(SupportedCredentialTypes.UsernamePassword)) { credentialsWidget = new UserPasswordCredentialsWidget(credentials as UsernamePasswordCredentials); } else { credentialsWidget = new SshCredentialsWidget(credentials as SshUserKeyCredentials); } credentialsWidget.CredentialsChanged += OnCredentialsChanged; mainContainer.PackStart(credentialsWidget.Widget, marginTop: InputContainerContainerSpacing); //Buttons Buttons.Add(new DialogButton(Command.Cancel)); Buttons.Add(okButton = new DialogButton(Command.Ok)); DefaultCommand = Command.Ok; okButton.Sensitive = credentialsWidget.CredentialsAreValid; }
private int GitCredentialHandler( out IntPtr ptr, IntPtr cUrl, IntPtr usernameFromUrl, GitCredentialType credTypes, IntPtr payload) { string url = LaxUtf8Marshaler.FromNative(cUrl); string username = LaxUtf8Marshaler.FromNative(usernameFromUrl); SupportedCredentialTypes types = default(SupportedCredentialTypes); if (credTypes.HasFlag(GitCredentialType.UserPassPlaintext)) { types |= SupportedCredentialTypes.UsernamePassword; } if (credTypes.HasFlag(GitCredentialType.Default)) { types |= SupportedCredentialTypes.Default; } if (credTypes.HasFlag(GitCredentialType.SshKey)) { types |= SupportedCredentialTypes.Ssh; } if (credTypes.HasFlag(GitCredentialType.Username)) { types |= SupportedCredentialTypes.UsernameQuery; } ptr = IntPtr.Zero; try { var cred = CredentialsProvider(url, username, types); if (cred == null) { return((int)GitErrorCode.PassThrough); } return(cred.GitCredentialHandler(out ptr)); } catch (Exception exception) { Proxy.giterr_set_str(GitErrorCategory.Callback, exception); return((int)GitErrorCode.Error); } }
public Credentials Provide(string url, string userName, SupportedCredentialTypes types) { bool supportsDefaultCreds = (types & SupportedCredentialTypes.Default) == SupportedCredentialTypes.Default; bool supportsUserNameCreds = (types & SupportedCredentialTypes.UsernamePassword) == SupportedCredentialTypes.UsernamePassword; if (supportsDefaultCreds) { return(new DefaultCredentials()); } if (supportsUserNameCreds) { return(_credentials ?? (_credentials = PromptUserNamePassword(userName))); } throw new NotSupportedException("Invalid authentication scheme"); }
private Credentials LookupCredentials(string url, string usernameFromUrl, SupportedCredentialTypes supportedCredentialTypes) { Log.Debug($"Lookup of Credentials: url: {url} usernameFromUrl: {usernameFromUrl}, supported Type: {supportedCredentialTypes}"); string urlLowercased = url.ToLowerInvariant(); var credential = _credentials.First(); if (credential != null) { Log.Debug($"Credentials found: {credential.HostName}, {credential.UserName}:{credential.Password}"); return(new UsernamePasswordCredentials() { Username = credential.UserName, Password = credential.Password }); } Log.Debug("No credentials found in lookup."); return(null); }
/// <summary> /// This is a callback from libgit2 /// </summary> /// <returns></returns> public Credentials HandleCredentials(string url, string username, SupportedCredentialTypes types) { if (url == null) { return(null); // wondering if we should return DefaultCredentials instead } var host = HostAddress.Create(url); try { var credentials = ThreadHelper.JoinableTaskFactory.Run(async() => await keychain.Load(host)); return(new UsernamePasswordCredentials { Username = credentials.Item1, Password = credentials.Item2, }); } catch (Exception e) { log.Error(e, "Error loading credentials in GitHubCredentialProvider"); return(null); } }
private Credentials BuildCredentialsProvider(string url, string fromUrl, SupportedCredentialTypes types, FlatFileCmsGitOptions options) { if (types.HasFlag(SupportedCredentialTypes.Ssh)) { string username = fromUrl.IsNullOrWhiteSpace() ? "git" : fromUrl; return(new SshUserKeyCredentials { Username = username, PublicKey = options.PublicKey, PrivateKey = options.PrivateKey, Passphrase = options.Passphrase }); } if (types.HasFlag(SupportedCredentialTypes.UsernamePassword)) { var repoUri = new Uri(url); var userInfo = repoUri.UserInfo.Split(':'); if (!userInfo.Any()) { return(new DefaultCredentials()); } string username = userInfo[0]; string password = userInfo.ElementAtOrDefault(1) ?? string.Empty; return(new UsernamePasswordCredentials { Username = username, Password = password }); } return(new DefaultCredentials()); }
public CredentialsDialog(string uri, SupportedCredentialTypes type, Credentials cred) { this.Build(); this.UseNativeContextMenus(); labelTop1.LabelProp = string.Format(labelTop1.LabelProp, uri); var table = new Table(0, 0, false); table.ColumnSpacing = 6; vbox.PackStart(table, true, true, 0); Entry firstEditor = null; switch (type) { case SupportedCredentialTypes.UsernamePassword: upcred = (UsernamePasswordCredentials)cred; firstEditor = CreateEntry(table, GettextCatalog.GetString("Username:"******"Password:"******"Passphrase:"), true); break; } table.ShowAll(); Focus = firstEditor; Default = buttonOk; }
private Credentials CredentialsHandler(string url, string usernamefromurl, SupportedCredentialTypes types) { if (!CredentialsCache.ContainsKey(RepositoryHost)) { if (GetCredentials != null) { var credentials = GetCredentials("Enter credentials for " + RepositoryHost); if (credentials != null) { CredentialsCache.Add(RepositoryHost, credentials); } else { return(null); } } else { return(null); } } return(CredentialsCache[RepositoryHost]); }
public static Credentials TryGet (string url, string userFromUrl, SupportedCredentialTypes types, GitCredentialsType type) { bool result = true; Uri uri = null; GitCredentialsState state; if (!credState.TryGetValue (type, out state)) credState [type] = state = new GitCredentialsState (); state.UrlUsed = url; // We always need to run the TryGet* methods as we need the passphraseItem/passwordItem populated even // if the password store contains an invalid password/no password if ((types & SupportedCredentialTypes.UsernamePassword) != 0) { uri = new Uri (url); string username; string password; if (!state.NativePasswordUsed && TryGetUsernamePassword (uri, out username, out password)) { state.NativePasswordUsed = true; return new UsernamePasswordCredentials { Username = username, Password = password }; } } Credentials cred; if ((types & SupportedCredentialTypes.UsernamePassword) != 0) cred = new UsernamePasswordCredentials (); else { // Try ssh-agent on Linux. if (!Platform.IsWindows && !state.AgentUsed) { bool agentUsable; if (!state.AgentForUrl.TryGetValue (url, out agentUsable)) state.AgentForUrl [url] = agentUsable = true; if (agentUsable) { state.AgentUsed = true; return new SshAgentCredentials { Username = userFromUrl, }; } } int key; if (!state.KeyForUrl.TryGetValue (url, out key)) { if (state.KeyUsed + 1 < Keys.Count) state.KeyUsed++; else { SelectFileDialog dlg = null; bool success = false; DispatchService.GuiSyncDispatch (() => { dlg = new SelectFileDialog (GettextCatalog.GetString ("Select a private SSH key to use.")); dlg.ShowHidden = true; dlg.CurrentFolder = Environment.GetFolderPath (Environment.SpecialFolder.Personal); success = dlg.Run (); }); if (!success || !File.Exists (dlg.SelectedFile + ".pub")) throw new VersionControlException (GettextCatalog.GetString ("Invalid credentials were supplied. Aborting operation.")); cred = new SshUserKeyCredentials { Username = userFromUrl, Passphrase = "", PrivateKey = dlg.SelectedFile, PublicKey = dlg.SelectedFile + ".pub", }; if (KeyHasPassphrase (dlg.SelectedFile)) { DispatchService.GuiSyncDispatch (delegate { using (var credDlg = new CredentialsDialog (url, types, cred)) result = MessageService.ShowCustomDialog (credDlg) == (int)Gtk.ResponseType.Ok; }); } if (result) return cred; throw new VersionControlException (GettextCatalog.GetString ("Invalid credentials were supplied. Aborting operation.")); } } else state.KeyUsed = key; cred = new SshUserKeyCredentials { Username = userFromUrl, Passphrase = "", PrivateKey = Keys [state.KeyUsed], PublicKey = Keys [state.KeyUsed] + ".pub", }; return cred; } DispatchService.GuiSyncDispatch (delegate { using (var credDlg = new CredentialsDialog (url, types, cred)) result = MessageService.ShowCustomDialog (credDlg) == (int)Gtk.ResponseType.Ok; }); if (result) { if ((types & SupportedCredentialTypes.UsernamePassword) != 0) { var upcred = (UsernamePasswordCredentials)cred; if (!string.IsNullOrEmpty (upcred.Password)) { PasswordService.AddWebUserNameAndPassword (uri, upcred.Username, upcred.Password); } } } return cred; }
internal static Credentials FetchChangesAutoCredentialHandler(string url, string user, SupportedCredentialTypes supported) { if (supported == SupportedCredentialTypes.UsernamePassword) { if (GitManager.GitCredentials != null) { string username = user; string password = string.Empty; LoadCredentials(url, ref username, ref password, true); return(new UsernamePasswordCredentials() { Username = username, Password = password }); } } return(new DefaultCredentials()); }
private Credentials BuildCredentials(string url, string usernameFromUrl, SupportedCredentialTypes types) { return new UsernamePasswordCredentials() { Username = _settings.Username, Password = _settings.Password }; }
private Credentials UsernamePasswordCredentials( string url, string usernameFromUrl, SupportedCredentialTypes types) { return(_gitCredentials); }
public static Credentials PrivateRepoCredentials(string url, string usernameFromUrl, SupportedCredentialTypes types) { return null; }
Credentials CredentialsHandler(string url, string usernameFromUrl, SupportedCredentialTypes types) { return new UsernamePasswordCredentials { Username = config.Username, Password = config.Password }; }
Credentials CredentialsHandler(string url, string usernameFromUrl, SupportedCredentialTypes types) { return(new UsernamePasswordCredentials { Username = config.Username, Password = config.Password ?? "" }); }