private void ITokenStoreTest(ITokenStore tokenStore, string url, string token, DateTimeOffset expires)
{
try
{
TargetUri uri = new TargetUri(url);
Token writeToken = new Token(token, TokenType.Test);
Token readToken = null;
tokenStore.WriteToken(uri, writeToken);
if ((readToken = tokenStore.ReadToken(uri)) != null)
{
Assert.AreEqual(writeToken.Value, readToken.Value, "Token values did not match between written and read");
Assert.AreEqual(writeToken.Type, readToken.Type, "Token types did not mathc between written and read");
}
else
{
Assert.Fail("Failed to read token");
}
tokenStore.DeleteToken(uri);
Assert.IsNull(readToken = tokenStore.ReadToken(uri), "Deleted token was read back");
}
catch (Exception exception)
{
Assert.Fail(exception.Message);
}
}
public async Task<bool> ValidateCredentials(TargetUri targetUri, Credential credentials)
{
return await Task.Run(() =>
{
try
{
BaseSecureStore.ValidateCredential(credentials);
return true;
}
catch { }
return false;
});
}
public async Task<bool> ValidateToken(TargetUri targetUri, Token token)
{
return await Task.Run(() =>
{
try
{
Token.Validate(token);
return true;
}
catch { }
return false;
});
}
public void BasicAuthDeleteCredentialsTest()
{
TargetUri targetUri = new TargetUri("http://localhost");
BasicAuthentication basicAuth = GetBasicAuthentication("basic-delete");
basicAuth.CredentialStore.WriteCredentials(targetUri, new Credential("username", "password"));
Credential credentials;
basicAuth.DeleteCredentials(targetUri);
Assert.IsNull(credentials = basicAuth.CredentialStore.ReadCredentials(targetUri), "User credentials were not deleted as expected");
}
public void BasicAuthGetCredentialsTest()
{
TargetUri targetUri = new TargetUri("http://localhost");
BasicAuthentication basicAuth = GetBasicAuthentication("basic-get");
Credential credentials = null;
Assert.IsNull(credentials = basicAuth.GetCredentials(targetUri), "User credentials were unexpectedly retrieved.");
credentials = new Credential("username", "password");
basicAuth.CredentialStore.WriteCredentials(targetUri, credentials);
Assert.IsNotNull(credentials = basicAuth.GetCredentials(targetUri), "User credentials were unexpectedly not retrieved.");
}
public void BasicAuthSetCredentialsTest()
{
TargetUri targetUri = new TargetUri("http://localhost");
BasicAuthentication basicAuth = GetBasicAuthentication("basic-set");
Credential credentials = null;
Assert.IsFalse(basicAuth.GetCredentials(targetUri, out credentials), "User credentials were unexpectedly retrieved.");
try
{
basicAuth.SetCredentials(targetUri, credentials);
Assert.Fail("User credentials were unexpectedly set.");
}
catch { }
credentials = new Credential("username", "password");
Assert.IsTrue(basicAuth.SetCredentials(targetUri, credentials), "User credentials were unexpectedly not set.");
Assert.IsTrue(basicAuth.GetCredentials(targetUri, out credentials), "User credentials were unexpectedly not retrieved.");
}
/// <summary> /// Deletes a <see cref="Credential"/> from the storage used by the authentication object. /// </summary> /// <param name="targetUri"> /// The uniform resource indicator used to uniquely identify the credentials. /// </param> public abstract void DeleteCredentials(TargetUri targetUri);
public async Task<TokenPair> AcquireTokenByRefreshTokenAsync(TargetUri targetUri, string clientId, string resource, Token refreshToken)
{
return await Task.Run(() => { return new TokenPair("token-access", "token-refresh"); });
}
/// <summary> /// Gets a <see cref="Credential"/> from the storage used by the authentication object. /// </summary> /// <param name="targetUri"> /// The uniform resource indicator used to uniquely identify the credentials. /// </param> /// <returns>If successful a <see cref="Credential"/> object from the authentication object, /// authority or storage; otherwise <see langword="null"/>.</returns> public abstract Credential GetCredentials(TargetUri targetUri);
public override int GetHashCode() => unchecked ((397 * Id.GetHashCode()) ^ (397 * TargetUri.GetHashCode()) ^ Drawing.GetHashCode());
/// <summary>
/// Generate a new <see cref="TargetUri"/> to be used as the key when storing the
/// refresh_tokne alongside the access_token.
/// </summary>
/// <param name="targetUri">contains Authority URL etc used for storing the sibling access_token</param>
/// <returns></returns>
private static TargetUri GetRefreshTokenTargetUri(TargetUri targetUri)
{
var uri = new Uri(targetUri.ActualUri, refreshTokenSuffix);
return(new TargetUri(uri));
}
internal Credential ModalPromptForCredentials(TargetUri targetUri, string message) => _modalPromptForCredentials(this, targetUri, message);
public async Task<Token> GeneratePersonalAccessToken(TargetUri targetUri, Token accessToken, VstsTokenScope tokenScope, bool requireCompactToken)
{
return await Task.Run(() => { return new Token("personal-access-token", TokenType.Personal); });
}
public void DeleteCredentials(TargetUri targetUri)
{
this.data.Remove(targetUri);
}
/// <summary> /// Sets a <see cref="Credential"/> in the storage used by the authentication object. /// </summary> /// <param name="targetUri">The uniform resource indicator used to uniquely identify the credentials.</param> /// <param name="credentials">The value to be stored.</param> public abstract void SetCredentials(TargetUri targetUri, Credential credentials);
/// <summary> /// Gets a <see cref="Credential"/> from the storage used by the authentication object. /// <para/> /// Returns a `<see cref="Credential"/>` if successful; otherwise `<see langword="null"/>`. /// </summary> /// <param name="targetUri">The uniform resource indicator used to uniquely identify the credentials.</param> public abstract Credential GetCredentials(TargetUri targetUri);
/// <summary> /// Deletes a `<see cref="Credential"/>` from the storage used by the authentication object. /// </summary> /// <param name="targetUri">The uniform resource indicator used to uniquely identify the credentials.</param> /// <param name="username">The username of the credentials to be deleted.</param> public virtual void DeleteCredentials(TargetUri targetUri, string username) => DeleteCredentials(targetUri, null);
/// <summary> /// Deletes a `<see cref="Credential"/>` from the storage used by the authentication object. /// </summary> /// <param name="targetUri">The uniform resource indicator used to uniquely identify the credentials.</param> public abstract void DeleteCredentials(TargetUri targetUri);
internal void CreateTargetUri()
{
string actualUrl = null;
string queryUrl = null;
string proxyUrl = _proxyUri?.ToString();
// when the target requests a path...
if (UseHttpPath)
{
// and lacks a protocol...
if (String.IsNullOrWhiteSpace(_queryProtocol))
{
// and the target lacks a path: use just the host
if ((String.IsNullOrWhiteSpace(_queryPath)))
{
queryUrl = _queryHost;
}
// combine the host + path
else
{
queryUrl = $"{_queryHost}/{_queryPath}";
}
}
// and has a protocol...
else
{
// and the target lacks a path, combine protocol + host
if (String.IsNullOrWhiteSpace(_queryPath))
{
queryUrl = $"{_queryProtocol}://{_queryHost}";
}
// combine protocol + host + path
else
{
queryUrl = $"{_queryProtocol}://{_queryHost}/{_queryPath}";
}
}
actualUrl = queryUrl;
}
// when the target ignores paths...
else
{
// and lacks a protocol...
if (String.IsNullOrWhiteSpace(_queryProtocol))
{
// and the host starts with "\\", strip the path...
if (_queryHost.StartsWith(@"\\", StringComparison.Ordinal))
{
int idx = _queryHost.IndexOfAny(SeperatorCharacters, 2);
queryUrl = (idx > 0)
? _queryHost.Substring(0, idx)
: _queryHost;
}
// use just the host
else
{
queryUrl = _queryHost;
}
if (String.IsNullOrWhiteSpace(_queryPath))
{
actualUrl = queryUrl;
}
else
{
actualUrl = $"{queryUrl}/{_queryPath}";
}
}
// and the protocol is "file://" strip any path
else if (_queryProtocol.StartsWith(Uri.UriSchemeFile, StringComparison.OrdinalIgnoreCase))
{
int idx = _queryHost.IndexOfAny(SeperatorCharacters);
// strip the host as neccisary
queryUrl = (idx > 0)
? _queryHost.Substring(0, idx)
: _queryHost;
// combine with protocol
queryUrl = $"{_queryProtocol}://{queryUrl}";
actualUrl = queryUrl;
}
// combine the protocol + host
else
{
queryUrl = $"{_queryProtocol}://{_queryHost}";
if (String.IsNullOrWhiteSpace(_queryPath))
{
actualUrl = queryUrl;
}
else
{
actualUrl = $"{queryUrl}/{_queryPath}";
}
}
}
_targetUri = new TargetUri(actualUrl, queryUrl, proxyUrl);
}
/// <summary> /// Sets a <see cref="Credential"/> in the storage used by the authentication object. /// </summary> /// <param name="targetUri"> /// The uniform resource indicator used to uniquely identify the credentials. /// </param> /// <param name="credentials">The value to be stored.</param> /// <returns><see langword="true"/> if successful; otherwise <see langword="false"/>.</returns> public abstract bool SetCredentials(TargetUri targetUri, Credential credentials);
internal virtual void CreateTargetUri()
{
string queryUrl = null;
string proxyUrl = _proxyUri?.OriginalString;
string actualUrl = null;
StringBuilder buffer = new StringBuilder();
// URI format is {protocol}://{username}@{host}/{path] with
// everything optional except for {host}.
// Protocol.
if (!string.IsNullOrWhiteSpace(_queryProtocol))
{
buffer.Append(_queryProtocol)
.Append("://");
}
// Username.
if (!string.IsNullOrWhiteSpace(_username))
{
var username = NeedsToBeEscaped(_username)
? Uri.EscapeDataString(_username)
: _username;
buffer.Append(username)
.Append('@');
}
// Host.
buffer.Append(_queryHost)
.Append('/');
// Path
if (!string.IsNullOrWhiteSpace(_queryPath))
{
buffer.Append(_queryPath);
}
queryUrl = buffer.ToString();
// If the git-remote-http(s) command line has been captured,
// try and parse it and provide the command-url .
if (!string.IsNullOrEmpty(_gitRemoteHttpCommandLine))
{
string[] parts = _gitRemoteHttpCommandLine.Split(' ');
switch (parts.Length)
{
case 1:
{
if (Uri.TryCreate(parts[0], UriKind.Absolute, out Uri uri))
{
actualUrl = uri.ToString();
}
}
break;
case 3:
{
if (Uri.TryCreate(parts[2], UriKind.Absolute, out Uri uri))
{
actualUrl = uri.ToString();
}
}
break;
}
}
// Create the target URI object.
_targetUri = new TargetUri(queryUrl, proxyUrl, actualUrl);
}
public Credential ReadCredentials(TargetUri targetUri)
{
Credential credentials;
return(this.data.TryGetValue(targetUri, out credentials) ? credentials : null);
}
public async Task <Token> NoninteractiveAcquireToken(TargetUri targetUri, string clientId, string resource, Uri redirectUri)
{
return(await Task.Run(() => { return new Token("token-access", TokenType.Access); }));
}
public void WriteCredentials(TargetUri targetUri, Credential credentials)
{
this.data[targetUri] = credentials;
}
private Credential ModalPromptForPassword(TargetUri targetUri, string message, string username) => _modalPromptForPassword(this, targetUri, message, username);
public static async Task <Guid?> DetectAuthority(RuntimeContext context, TargetUri targetUri)
{
const int GuidStringLength = 36;
const string VstsResourceTenantHeader = "X-VSS-ResourceTenant";
if (context is null)
{
throw new ArgumentNullException(nameof(context));
}
if (targetUri is null)
{
throw new ArgumentNullException(nameof(targetUri));
}
// Assume VSTS using Azure "common tenant" (empty GUID).
var tenantId = Guid.Empty;
// Compose the request Uri, by default it is the target Uri.
var requestUri = targetUri;
// Override the request Uri, when actual Uri exists, with actual Uri.
if (targetUri.ActualUri != null)
{
requestUri = targetUri.CreateWith(queryUri: targetUri.ActualUri);
}
// If the protocol (aka scheme) being used isn't HTTP based, there's no point in
// querying the server, so skip that work.
if (OrdinalIgnoreCase.Equals(requestUri.Scheme, Uri.UriSchemeHttp) ||
OrdinalIgnoreCase.Equals(requestUri.Scheme, Uri.UriSchemeHttps))
{
var requestUrl = GetTargetUrl(requestUri, false);
// Read the cache from disk.
var cache = await DeserializeTenantCache(context);
// Check the cache for an existing value.
if (cache.TryGetValue(requestUrl, out tenantId))
{
context.Trace.WriteLine($"'{requestUrl}' is VSTS, tenant resource is {{{tenantId.ToString("N")}}}.");
return(tenantId);
}
var options = new NetworkRequestOptions(false)
{
Flags = NetworkRequestOptionFlags.UseProxy,
Timeout = TimeSpan.FromMilliseconds(Global.RequestTimeout),
};
try
{
// Query the host use the response headers to determine if the host is VSTS or not.
using (var response = await context.Network.HttpHeadAsync(requestUri, options))
{
if (response.Headers != null)
{
// If the "X-VSS-ResourceTenant" was returned, then it is VSTS and we'll need it's value.
if (response.Headers.TryGetValues(VstsResourceTenantHeader, out IEnumerable <string> values))
{
context.Trace.WriteLine($"detected '{requestUrl}' as VSTS from GET response.");
// The "Www-Authenticate" is a more reliable header, because it indicates the
// authentication scheme that should be used to access the requested entity.
if (response.Headers.WwwAuthenticate != null)
{
foreach (var header in response.Headers.WwwAuthenticate)
{
const string AuthorizationUriPrefix = "authorization_uri=";
var value = header.Parameter;
if (value.Length >= AuthorizationUriPrefix.Length + AuthorityHostUrlBase.Length + GuidStringLength)
{
// The header parameter will look something like "authorization_uri=https://login.microsoftonline.com/72f988bf-86f1-41af-91ab-2d7cd011db47"
// and all we want is the portion after the '=' and before the last '/'.
int index1 = value.IndexOf('=', AuthorizationUriPrefix.Length - 1);
int index2 = value.LastIndexOf('/');
// Parse the header value if the necessary characters exist...
if (index1 > 0 && index2 > index1)
{
var authorityUrl = value.Substring(index1 + 1, index2 - index1 - 1);
var guidString = value.Substring(index2 + 1, GuidStringLength);
// If the authority URL is as expected, attempt to parse the tenant resource identity.
if (OrdinalIgnoreCase.Equals(authorityUrl, AuthorityHostUrlBase) &&
Guid.TryParse(guidString, out tenantId))
{
// Update the cache.
cache[requestUrl] = tenantId;
// Write the cache to disk.
await SerializeTenantCache(context, cache);
// Since we found a value, break the loop (likely a loop of one item anyways).
break;
}
}
}
}
}
else
{
// Since there wasn't a "Www-Authenticate" header returned
// iterate through the values, taking the first non-zero value.
foreach (string value in values)
{
// Try to find a value for the resource-tenant identity.
// Given that some projects will return multiple tenant identities,
if (!string.IsNullOrWhiteSpace(value) &&
Guid.TryParse(value, out tenantId))
{
// Update the cache.
cache[requestUrl] = tenantId;
// Write the cache to disk.
await SerializeTenantCache(context, cache);
// Break the loop if a non-zero value has been detected.
if (tenantId != Guid.Empty)
{
break;
}
}
}
}
context.Trace.WriteLine($"tenant resource for '{requestUrl}' is {{{tenantId.ToString("N")}}}.");
// Return the tenant identity to the caller because this is VSTS.
return(tenantId);
}
}
else
{
context.Trace.WriteLine($"unable to get response from '{requestUri}' [{(int)response.StatusCode} {response.StatusCode}].");
}
}
}
catch (HttpRequestException exception)
{
context.Trace.WriteLine($"unable to get response from '{requestUri}', an error occurred before the server could respond.");
context.Trace.WriteException(exception);
}
}
else
{
context.Trace.WriteLine($"detected non-http(s) based protocol: '{requestUri.Scheme}'.");
}
if (OrdinalIgnoreCase.Equals(VstsBaseUrlHost, requestUri.Host))
{
return(Guid.Empty);
}
// Fallback to basic authentication.
return(null);
}
/// <summary>
/// Deletes a `<see cref="Credential"/>` from the storage used by the authentication object.
/// </summary>
/// <param name="targetUri">The uniform resource indicator used to uniquely identify the credentials.</param>
public override void DeleteCredentials(TargetUri targetUri)
{
DeleteCredentials(targetUri, null);
}
/// <summary>
/// Validates that a set of credentials grants access to the target resource.
/// <para/>
/// Returns `<see langword="true"/>` if successful; otherwise `<see langword="false"/>`.
/// </summary>
/// <param name="targetUri">The target resource to validate against.</param>
/// <param name="credentials">The credentials to validate.</param>
public async Task <bool> ValidateCredentials(TargetUri targetUri, Credential credentials)
{
return(await Authority.ValidateCredentials(targetUri, credentials));
}
public static Credential PasswordPrompt(Program program, TargetUri targetUri, string message, string username)
{
Debug.Assert(targetUri != null);
Debug.Assert(message != null);
Debug.Assert(username != null);
NativeMethods.CredentialUiInfo credUiInfo = new NativeMethods.CredentialUiInfo
{
BannerArt = IntPtr.Zero,
CaptionText = program.Title,
MessageText = message,
Parent = IntPtr.Zero,
Size = Marshal.SizeOf(typeof(NativeMethods.CredentialUiInfo))
};
NativeMethods.CredentialUiWindowsFlags flags = NativeMethods.CredentialUiWindowsFlags.Generic;
NativeMethods.CredentialPackFlags authPackage = NativeMethods.CredentialPackFlags.None;
IntPtr packedAuthBufferPtr = IntPtr.Zero;
IntPtr inBufferPtr = IntPtr.Zero;
uint packedAuthBufferSize = 0;
bool saveCredentials = false;
int inBufferSize = 0;
string password;
try
{
int error;
// execute with `null` to determine buffer size always returns false when determining
// size, only fail if `inBufferSize` looks bad
NativeMethods.CredPackAuthenticationBuffer(flags: authPackage,
username: username,
password: string.Empty,
packedCredentials: IntPtr.Zero,
packedCredentialsSize: ref inBufferSize);
if (inBufferSize <= 0)
{
error = Marshal.GetLastWin32Error();
Git.Trace.WriteLine($"unable to determine credential buffer size ('{NativeMethods.Win32Error.GetText(error)}').");
return(null);
}
inBufferPtr = Marshal.AllocHGlobal(inBufferSize);
if (!NativeMethods.CredPackAuthenticationBuffer(flags: authPackage,
username: username,
password: string.Empty,
packedCredentials: inBufferPtr,
packedCredentialsSize: ref inBufferSize))
{
error = Marshal.GetLastWin32Error();
Git.Trace.WriteLine($"unable to write to credential buffer ('{NativeMethods.Win32Error.GetText(error)}').");
return(null);
}
if (program.ModalPromptDisplayDialog(ref credUiInfo,
ref authPackage,
packedAuthBufferPtr,
packedAuthBufferSize,
inBufferPtr,
inBufferSize,
saveCredentials,
flags,
out username,
out password))
{
return(new Credential(username, password));
}
}
finally
{
if (inBufferPtr != IntPtr.Zero)
{
Marshal.FreeCoTaskMem(inBufferPtr);
}
}
return(null);
}
public void TestInitialize()
{
mockCredentialStore = new Mock <ICredentialStore>();
testSubject = new CredentialStore(mockCredentialStore.Object);
wellKnownTargetUri = new TargetUri("http://sonarcredtest/");
}
/// <summary> /// Sets a <see cref="Credential"/> in the storage used by the authentication object. /// </summary> /// <param name="targetUri"> /// The uniform resource indicator used to uniquely identify the credentials. /// </param> /// <param name="credentials">The value to be stored.</param> public abstract void SetCredentials(TargetUri targetUri, Credential credentials);
internal Credential BasicCredentialPrompt(TargetUri targetUri)
{
string message = "Please enter your credentials for ";
return(BasicCredentialPrompt(targetUri, message));
}
public TokenPair AcquireToken(TargetUri targetUri, string clientId, string resource, Uri redirectUri, string queryParameters = null)
{
return new TokenPair("token-access", "token-refresh");
}
internal Credential BasicCredentialPrompt(TargetUri targetUri, string titleMessage) => _basicCredentialPrompt(this, targetUri, titleMessage);
/// <summary> /// Gets a <see cref="Credential"/> from the storage used by the authentication object. /// </summary> /// <param name="targetUri"> /// The uniform resource indicator used to uniquely identify the credentials. /// </param> /// <param name="credentials"> /// If successful a <see cref="Credential"/> object from the authentication object, /// authority or storage; otherwise <see langword="null"/>. /// </param> /// <returns><see langword="true"/> if successful; otherwise <see langword="false"/>.</returns> public abstract bool GetCredentials(TargetUri targetUri, out Credential credentials);
internal bool BitbucketCredentialPrompt(string titleMessage, TargetUri targetUri, out string username, out string password) => _bitbucketCredentialPrompt(this, titleMessage, targetUri, out username, out password);
public async Task<Token> NoninteractiveAcquireToken(TargetUri targetUri, string clientId, string resource, Uri redirectUri, string queryParameters = null)
{
return await Task.Run(() => { return new Token("token-access", TokenType.Access); });
}
public async Task <Token> GeneratePersonalAccessToken(TargetUri targetUri, Token accessToken, VstsTokenScope tokenScope, bool requireCompactToken)
{
return(await Task.Run(() => { return new Token("personal-access-token", TokenType.Personal); }));
}
internal virtual void CreateTargetUri()
{
string queryUrl = null;
string proxyUrl = _proxyUri?.OriginalString;
string actualUrl = null;
var buffer = new StringBuilder();
// URI format is {protocol}://{username}@{host}/{path] with
// everything optional except for {host}.
// Protocol.
if (!string.IsNullOrWhiteSpace(_queryProtocol))
{
buffer.Append(_queryProtocol)
.Append("://");
}
// Username.
if (!string.IsNullOrWhiteSpace(_username))
{
var username = NeedsToBeEscaped(_username)
? Uri.EscapeDataString(_username)
: _username;
buffer.Append(username)
.Append('@');
}
// Host.
buffer.Append(_queryHost)
.Append('/');
// Path
if (!string.IsNullOrWhiteSpace(_queryPath))
{
buffer.Append(_queryPath);
}
queryUrl = buffer.ToString();
// if path is specified we should give the host/path priority
if (!string.IsNullOrWhiteSpace(_queryPath))
{
actualUrl = queryUrl;
}
// If the actual-url override has been set, honor it.
else if (!string.IsNullOrEmpty(_urlOverride))
{
if (Uri.TryCreate(_urlOverride, UriKind.Absolute, out Uri uri))
{
actualUrl = uri.ToString();
}
else
{
Trace.WriteLine($"failed to parse \"{_urlOverride}\", unable to set URL override.");
}
}
// If the git-remote-http(s) command line has been captured,
// try and parse it and provide the command-url .
else if (!string.IsNullOrEmpty(_gitRemoteHttpCommandLine))
{
string[] parts = _gitRemoteHttpCommandLine.Split(' ');
switch (parts.Length)
{
case 1:
{
if (Uri.TryCreate(parts[0], UriKind.Absolute, out Uri uri))
{
actualUrl = uri.ToString();
}
else
{
Trace.WriteLine($"failed to parse \"{parts[0]}\", unable to set URL override.");
}
}
break;
case 3:
{
if (Uri.TryCreate(parts[2], UriKind.Absolute, out Uri uri))
{
actualUrl = uri.ToString();
}
else
{
Trace.WriteLine($"failed to parse \"{parts[2]}\", unable to set URL override.");
}
}
break;
}
}
// Create the target URI object.
_targetUri = new TargetUri(queryUrl, proxyUrl, actualUrl);
}
public static bool AuthCodePrompt(Program program, TargetUri targetUri, Github.GitHubAuthenticationResultType resultType, string username, out string authenticationCode)
{
// ReadConsole 32768 fail, 32767 ok @linquize [https://github.com/Microsoft/Git-Credential-Manager-for-Windows/commit/a62b9a19f430d038dcd85a610d97e5f763980f85]
const int BufferReadSize = 16 * 1024;
if (program is null)
{
throw new ArgumentNullException(nameof(program));
}
if (targetUri is null)
{
throw new ArgumentNullException(nameof(targetUri));
}
var trace = program.Trace;
StringBuilder buffer = new StringBuilder(BufferReadSize);
uint read = 0;
uint written = 0;
authenticationCode = null;
NativeMethods.FileAccess fileAccessFlags = NativeMethods.FileAccess.GenericRead | NativeMethods.FileAccess.GenericWrite;
NativeMethods.FileAttributes fileAttributes = NativeMethods.FileAttributes.Normal;
NativeMethods.FileCreationDisposition fileCreationDisposition = NativeMethods.FileCreationDisposition.OpenExisting;
NativeMethods.FileShare fileShareFlags = NativeMethods.FileShare.Read | NativeMethods.FileShare.Write;
using (SafeFileHandle stdout = NativeMethods.CreateFile(NativeMethods.ConsoleOutName, fileAccessFlags, fileShareFlags, IntPtr.Zero, fileCreationDisposition, fileAttributes, IntPtr.Zero))
using (SafeFileHandle stdin = NativeMethods.CreateFile(NativeMethods.ConsoleInName, fileAccessFlags, fileShareFlags, IntPtr.Zero, fileCreationDisposition, fileAttributes, IntPtr.Zero))
{
string type = resultType == Github.GitHubAuthenticationResultType.TwoFactorApp
? "app"
: "sms";
trace.WriteLine($"2fa type = '{type}'.");
buffer.AppendLine()
.Append("authcode (")
.Append(type)
.Append("): ");
if (!NativeMethods.WriteConsole(stdout, buffer, (uint)buffer.Length, out written, IntPtr.Zero))
{
int error = Marshal.GetLastWin32Error();
throw new Win32Exception(error, "Unable to write to standard output (" + NativeMethods.Win32Error.GetText(error) + ").");
}
buffer.Clear();
// read input from the user
if (!NativeMethods.ReadConsole(stdin, buffer, BufferReadSize, out read, IntPtr.Zero))
{
int error = Marshal.GetLastWin32Error();
throw new Win32Exception(error, "Unable to read from standard input (" + NativeMethods.Win32Error.GetText(error) + ").");
}
authenticationCode = buffer.ToString(0, (int)read);
authenticationCode = authenticationCode.Trim(program.NewLineChars);
}
return(authenticationCode != null);
}
internal bool BitbucketOAuthPrompt(string title, TargetUri targetUri, Bitbucket.AuthenticationResultType resultType, string username) => _bitbucketOauthPrompt(this, title, targetUri, resultType, username);
public async Task <Token> InteractiveAcquireToken(TargetUri targetUri, string clientId, string resource, Uri redirectUri, string queryParameters = null)
{
Assert.Equal(this.ExpectedQueryParameters, queryParameters);
return(await Task.Run(() => { return new Token("token-access", TokenType.Access); }));
}
private void ICredentialStoreTest(ICredentialStore credentialStore, string url, string username, string password)
{
try
{
TargetUri uri = new TargetUri(url);
Credential writeCreds = new Credential(username, password);
Credential readCreds = null;
credentialStore.WriteCredentials(uri, writeCreds);
if ((readCreds = credentialStore.ReadCredentials(uri)) != null)
{
Assert.AreEqual(writeCreds.Password, readCreds.Password, "Passwords did not match between written and read credentials");
Assert.AreEqual(writeCreds.Username, readCreds.Username, "Usernames did not match between written and read credentials");
}
else
{
Assert.Fail("Failed to read credentials");
}
credentialStore.DeleteCredentials(uri);
Assert.IsNull(readCreds = credentialStore.ReadCredentials(uri), "Deleted credentials were read back");
}
catch (Exception exception)
{
Assert.Fail(exception.Message);
}
}
internal bool GitHubAuthCodePrompt(TargetUri targetUri, Github.GitHubAuthenticationResultType resultType, string username, out string authenticationCode) => _gitHubAuthCodePrompt(this, targetUri, resultType, username, out authenticationCode);
internal bool GitHubCredentialPrompt(TargetUri targetUri, out string username, out string password) => _gitHubCredentialPrompt(this, targetUri, out username, out password);
public void TargetUri_Basics(string actualUrl, string queryUrl, string proxyUrl)
{
TargetUri targetUri;
Uri actualUri;
Uri queryUri;
Uri proxyUri;
actualUri = new TargetUri(actualUrl);
targetUri = new TargetUri(actualUrl);
Assert.NotNull(targetUri);
Assert.Equal(actualUri.AbsolutePath, targetUri.AbsolutePath);
Assert.Equal(actualUri.DnsSafeHost, targetUri.DnsSafeHost);
Assert.Equal(actualUri.Host, targetUri.Host);
Assert.Equal(actualUri.IsAbsoluteUri, targetUri.IsAbsoluteUri);
Assert.Equal(actualUri.IsDefaultPort, targetUri.IsDefaultPort);
Assert.Equal(actualUri.Port, targetUri.Port);
Assert.Equal(actualUri.Scheme, targetUri.Scheme);
Assert.Equal(actualUri.UserInfo, targetUri.TargetUriUsername);
actualUri = actualUrl is null ? null : new Uri(actualUrl);
queryUri = queryUrl is null ? null : new Uri(queryUrl);
proxyUri = proxyUrl is null ? null : new Uri(proxyUrl);
targetUri = new TargetUri(actualUrl, queryUrl, proxyUrl);
Assert.NotNull(targetUri);
// Since the actual Uri will substitute for a null query Uri, test the correct value.
var uri = queryUri ?? actualUri;
Assert.Equal(uri.AbsolutePath, targetUri.AbsolutePath);
Assert.Equal(uri.DnsSafeHost, targetUri.DnsSafeHost);
Assert.Equal(uri.Host, targetUri.Host);
Assert.Equal(uri.IsAbsoluteUri, targetUri.IsAbsoluteUri);
Assert.Equal(uri.IsDefaultPort, targetUri.IsDefaultPort);
Assert.Equal(uri.Port, targetUri.Port);
Assert.Equal(uri.Scheme, targetUri.Scheme);
Assert.Equal(uri.UserInfo, targetUri.TargetUriUsername);
Assert.Equal(actualUri, targetUri.ActualUri);
Assert.Equal(uri, targetUri.QueryUri);
Assert.Equal(proxyUri, targetUri.ProxyUri);
targetUri = new TargetUri(actualUri, queryUri, proxyUri);
Assert.NotNull(targetUri);
Assert.Equal(uri.AbsolutePath, targetUri.AbsolutePath);
Assert.Equal(uri.DnsSafeHost, targetUri.DnsSafeHost);
Assert.Equal(uri.Host, targetUri.Host);
Assert.Equal(uri.IsAbsoluteUri, targetUri.IsAbsoluteUri);
Assert.Equal(uri.IsDefaultPort, targetUri.IsDefaultPort);
Assert.Equal(uri.Port, targetUri.Port);
Assert.Equal(uri.Scheme, targetUri.Scheme);
Assert.Equal(uri.UserInfo, targetUri.TargetUriUsername);
Assert.Equal(actualUri, targetUri.ActualUri);
Assert.Equal(uri, targetUri.QueryUri);
Assert.Equal(proxyUri, targetUri.ProxyUri);
}
