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 ?? ""
});
}
