private static void AppendAvailableStoreList(StringBuilder sb)
{
if (PlatformUtils.IsWindows())
{
sb.AppendFormat(" {1,-13} : Windows Credential Manager (not available over network/SSH sessions){0}",
Environment.NewLine, StoreNames.WindowsCredentialManager);
sb.AppendFormat(" {1,-13} : DPAPI protected files{0}",
Environment.NewLine, StoreNames.Dpapi);
}
if (PlatformUtils.IsMacOS())
{
sb.AppendFormat(" {1,-13} : macOS Keychain{0}",
Environment.NewLine, StoreNames.MacOSKeychain);
}
if (PlatformUtils.IsLinux())
{
sb.AppendFormat(" {1,-13} : freedesktop.org Secret Service (requires graphical interface){0}",
Environment.NewLine, StoreNames.SecretService);
}
if (PlatformUtils.IsPosix())
{
sb.AppendFormat(" {1,-13} : GNU `pass` compatible credential storage (requires GPG and `pass`){0}",
Environment.NewLine, StoreNames.Gpg);
}
sb.AppendFormat(" {1,-13} : Git's in-memory credential cache{0}",
Environment.NewLine, StoreNames.Cache);
sb.AppendFormat(" {1,-13} : store credentials in plain-text files (UNSECURE){0}",
Environment.NewLine, StoreNames.Plaintext);
}
private string CreateServiceSlug(string service)
{
var sb = new StringBuilder();
char sep = Path.DirectorySeparatorChar;
if (!string.IsNullOrWhiteSpace(Namespace))
{
sb.AppendFormat("{0}{1}", Namespace, sep);
}
if (Uri.TryCreate(service, UriKind.Absolute, out Uri serviceUri))
{
sb.AppendFormat("{0}{1}", serviceUri.Scheme, sep);
sb.AppendFormat("{0}", serviceUri.Host);
if (!serviceUri.IsDefaultPort)
{
sb.Append(PlatformUtils.IsWindows() ? '-' : ':');
sb.Append(serviceUri.Port);
}
sb.Append(serviceUri.AbsolutePath.Replace('/', sep));
}
else
{
sb.Append(service);
}
return(sb.ToString());
}
private static string GetGitPath(IEnvironment environment, IFileSystem fileSystem, ITrace trace)
{
const string unixGitName = "git";
const string winGitName = "git.exe";
string gitExecPath;
string programName = PlatformUtils.IsWindows() ? winGitName : unixGitName;
// Use the GIT_EXEC_PATH environment variable if set
if (environment.Variables.TryGetValue(Constants.EnvironmentVariables.GitExecutablePath,
out gitExecPath))
{
// If we're invoked from WSL we must locate the UNIX Git executable
if (PlatformUtils.IsWindows() && WslUtils.IsWslPath(gitExecPath))
{
programName = unixGitName;
}
string candidatePath = Path.Combine(gitExecPath, programName);
if (fileSystem.FileExists(candidatePath))
{
trace.WriteLine($"Using Git executable from GIT_EXEC_PATH: {candidatePath}");
return(candidatePath);
}
}
// Otherwise try to locate the git(.exe) on the current PATH
gitExecPath = environment.LocateExecutable(programName);
trace.WriteLine($"Using PATH-located Git executable: {gitExecPath}");
return(gitExecPath);
}
private static string GetDefaultStore()
{
if (PlatformUtils.IsWindows())
{
return(StoreNames.WindowsCredentialManager);
}
if (PlatformUtils.IsMacOS())
{
return(StoreNames.MacOSKeychain);
}
// Other platforms have no default store
return(null);
}
private string GetGitConfigAppPath()
{
string path = Context.ApplicationPath;
// On Windows we must use UNIX style path separators
if (PlatformUtils.IsWindows())
{
path = path.Replace('\\', '/');
}
// We must escape escape characters like ' ', '(', and ')'
return(path
.Replace(" ", "\\ ")
.Replace("(", "\\(")
.Replace(")", "\\)"));;
}
private void ValidateWindowsCredentialManager()
{
if (!PlatformUtils.IsWindows())
{
throw new Exception(
$"Can only use the '{StoreNames.WindowsCredentialManager}' credential store on Windows." +
Environment.NewLine +
$"See {Constants.HelpUrls.GcmCredentialStores} for more information."
);
}
if (!WindowsCredentialManager.CanPersist())
{
throw new Exception(
$"Unable to persist credentials with the '{StoreNames.WindowsCredentialManager}' credential store." +
Environment.NewLine +
$"See {Constants.HelpUrls.GcmCredentialStores} for more information."
);
}
}
public override async Task <ICredential> GenerateCredentialAsync(InputArguments input)
{
ThrowIfDisposed();
Uri uri = input.GetRemoteUri();
// Determine the if the host supports Windows Integration Authentication (WIA)
if (IsWindowsAuthAllowed)
{
if (PlatformUtils.IsWindows())
{
Context.Trace.WriteLine($"Checking host '{uri.AbsoluteUri}' for Windows Integrated Authentication...");
bool isWiaSupported = await _winAuth.GetIsSupportedAsync(uri);
if (!isWiaSupported)
{
Context.Trace.WriteLine("Host does not support WIA.");
}
else
{
Context.Trace.WriteLine("Host supports WIA - generating empty credential...");
// WIA is signaled to Git using an empty username/password
return(new GitCredential(string.Empty, string.Empty));
}
}
else
{
string osType = PlatformUtils.GetPlatformInformation().OperatingSystemType;
Context.Trace.WriteLine($"Skipping check for Windows Integrated Authentication on {osType}.");
}
}
else
{
Context.Trace.WriteLine("Windows Integrated Authentication detection has been disabled.");
}
Context.Trace.WriteLine("Prompting for basic credentials...");
return(_basicAuth.GetCredentials(uri.AbsoluteUri, input.UserName));
}
private void ValidateDpapi(out string storeRoot)
{
if (!PlatformUtils.IsWindows())
{
throw new Exception(
$"Can only use the '{StoreNames.Dpapi}' credential store on Windows." +
Environment.NewLine +
$"See {Constants.HelpUrls.GcmCredentialStores} for more information."
);
}
// Check for a redirected credential store location
if (!_context.Settings.TryGetSetting(
Constants.EnvironmentVariables.GcmDpapiStorePath,
Constants.GitConfiguration.Credential.SectionName,
Constants.GitConfiguration.Credential.DpapiStorePath,
out storeRoot))
{
// Use default store root at ~/.gcm/dpapi_store
storeRoot = Path.Combine(_context.FileSystem.UserDataDirectoryPath, "dpapi_store");
}
}
public CommandContext(string appPath)
{
EnsureArgument.NotNullOrWhiteSpace(appPath, nameof(appPath));
ApplicationPath = appPath;
Streams = new StandardStreams();
Trace = new Trace();
if (PlatformUtils.IsWindows())
{
FileSystem = new WindowsFileSystem();
SessionManager = new WindowsSessionManager();
SystemPrompts = new WindowsSystemPrompts();
Environment = new WindowsEnvironment(FileSystem);
Terminal = new WindowsTerminal(Trace);
string gitPath = GetGitPath(Environment, FileSystem, Trace);
Git = new GitProcess(
Trace,
Environment,
gitPath,
FileSystem.GetCurrentDirectory()
);
Settings = new WindowsSettings(Environment, Git, Trace);
}
else if (PlatformUtils.IsMacOS())
{
FileSystem = new MacOSFileSystem();
SessionManager = new MacOSSessionManager();
SystemPrompts = new MacOSSystemPrompts();
Environment = new PosixEnvironment(FileSystem);
Terminal = new MacOSTerminal(Trace);
string gitPath = GetGitPath(Environment, FileSystem, Trace);
Git = new GitProcess(
Trace,
Environment,
gitPath,
FileSystem.GetCurrentDirectory()
);
Settings = new Settings(Environment, Git);
}
else if (PlatformUtils.IsLinux())
{
FileSystem = new LinuxFileSystem();
// TODO: support more than just 'Posix' or X11
SessionManager = new PosixSessionManager();
SystemPrompts = new LinuxSystemPrompts();
Environment = new PosixEnvironment(FileSystem);
Terminal = new LinuxTerminal(Trace);
string gitPath = GetGitPath(Environment, FileSystem, Trace);
Git = new GitProcess(
Trace,
Environment,
gitPath,
FileSystem.GetCurrentDirectory()
);
Settings = new Settings(Environment, Git);
}
else
{
throw new PlatformNotSupportedException();
}
HttpClientFactory = new HttpClientFactory(FileSystem, Trace, Settings, Streams);
CredentialStore = new CredentialStore(this);
// Set the parent window handle/ID
SystemPrompts.ParentWindowId = Settings.ParentWindowId;
}
