public static void Main(string tenantId, string clientId, string orgName)
{
_ = tenantId ?? throw new ArgumentNullException("TenantId cannot be null");
_ = clientId ?? throw new ArgumentNullException("ClientId cannot be null");
_ = orgName ?? throw new ArgumentNullException("OrgId cannot be null");
_FullUrl = $"{baseUrl}{orgName}";
AuthenticationContext ctx = GetAuthenticationContext(tenantId);
AuthenticationResult result = null;
try
{
DeviceCodeResult codeResult = ctx.AcquireDeviceCodeAsync(ADOResourceId, clientId).Result;
Console.WriteLine("You need to sign in.");
Console.WriteLine("Message: " + codeResult.Message + "\n");
result = ctx.AcquireTokenByDeviceCodeAsync(codeResult).Result;
var bearerAuthHeader = new AuthenticationHeaderValue("Bearer", result.AccessToken);
ListProjects(bearerAuthHeader);
}
catch (Exception ex)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Something went wrong.");
Console.WriteLine("Message: " + ex.Message + "\n");
}
}
protected override async Task <AuthenticationResult> InitialGetAccessCodeAsync(CancellationToken ct)
{
var codeResult = await AuthenticationContext.AcquireDeviceCodeAsync(ResourceUri, ClientId).ConfigureAwait(false);
_notifyDeviceCodeRequest(codeResult.VerificationUrl, codeResult.UserCode);
return(await AuthenticationContext.AcquireTokenByDeviceCodeAsync(codeResult).ConfigureAwait(false));
}
public static async Task <string> AcquireAccessTokenAsync(string tenant)
{
string accessToken = null;
var ctx = new AuthenticationContext($"https://login.windows.net/{tenant}", _tokenCache);
try
{
accessToken = (await ctx.AcquireTokenSilentAsync(resource, clientId)).AccessToken;
}
catch (AdalException x)
{
Logger.WriteLine($"Silent token acquisition failed.");
Logger.WriteLine($"ADAL Exception: {x.Message}");
Logger.WriteLine($"Retrieving token via device code authentication now.");
DeviceCodeResult codeResult = await ctx.AcquireDeviceCodeAsync(resource, clientId);
Logger.WriteLine("Please sign into your AAD account.");
Logger.WriteLine($"{codeResult.Message}");
Logger.WriteLine("");
accessToken = (await ctx.AcquireTokenByDeviceCodeAsync(codeResult)).AccessToken;
SerializationHelper.WriteToFile(TokenCacheFileName, new ByteArrayWrapper {
theBytes = _tokenCache.SerializeAdalV3()
});
}
return(accessToken);
}
public async Task <IAdalToken> AcquireTokenWithDeviceFlowAsync(Func <DeviceCodeResult, Task> deviceCodeHandler, CancellationToken cancellationToken, ILogger logger)
{
var authenticationContext = new AuthenticationContext(authority, tokenCache);
var deviceCode = await authenticationContext.AcquireDeviceCodeAsync(resource, clientId);
cancellationToken.ThrowIfCancellationRequested();
if (deviceCodeHandler != null)
{
await deviceCodeHandler(deviceCode);
cancellationToken.ThrowIfCancellationRequested();
}
AuthenticationResult result = null;
var deviceFlowTimeout = EnvUtil.GetDeviceFlowTimeoutFromEnvironmentInSeconds(logger);
var task = authenticationContext.AcquireTokenByDeviceCodeAsync(deviceCode);
if (await Task.WhenAny(task, Task.Delay(deviceFlowTimeout * 1000, cancellationToken)) == task)
{
result = await task;
}
else
{
logger.Error(string.Format(Resources.DeviceFlowTimedOut, deviceFlowTimeout));
}
return(new AdalToken(result));
}
public override async Task ProcessHttpRequestAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
AuthenticationResult ar;
try
{
ar = await _authenticationContext.AcquireTokenSilentAsync(_audience, _clientId).ConfigureAwait(false);
}
catch (AdalSilentTokenAcquisitionException ex)
{
if (UserTokenInteraction == null)
{
throw new AuthenticationException("Interactive logon required, but no UI element was supplied", ex);
}
DeviceCodeResult dc = await _authenticationContext.AcquireDeviceCodeAsync(_audience, _clientId);
UserTokenInteraction.UserCode = dc.UserCode;
UserTokenInteraction.VerificationUrl = dc.VerificationUrl;
ar = await _authenticationContext.AcquireTokenByDeviceCodeAsync(dc);
await UserTokenInteraction.CompleteAuthAsync();
}
catch (Exception ex)
{
throw ex;
}
if (UserInfoReceiver != null)
{
UserInfoReceiver.SetUserInfo(ar.UserInfo);
}
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", ar.AccessToken);
}
/// <summary>
/// Acquires a user token with the bot service first party app as audience
/// </summary>
/// <returns></returns>
public async Task <AuthenticationResult> AcquireTokenAsync()
{
var authority = $"https://login.windows.net/{tenantId}";
var context = new AuthenticationContext(
authority: authority,
validateAuthority: true);
SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
#if NET452
return(context.AcquireToken(
resource: BotFirstPartyAppId,
clientId: AadClientId,
redirectUri: new Uri(AadRedirectUri),
promptBehavior: PromptBehavior.Always));
#endif
#if NETSTANDARD1_4
// Request a device code
var deviceCodeResult = await context.AcquireDeviceCodeAsync(BotFirstPartyAppId, AadClientId);
if (deviceCodeAuthHandler == null)
{
throw new ArgumentException(BotServiceErrorMessages.DeviceCodeAuthNotProvided,
nameof(deviceCodeAuthHandler));
}
// Execute the user-provided handler for device code. It should prompt the user to
// do device login
deviceCodeAuthHandler(deviceCodeResult);
// Now, the user should have entered the device code, acquire token
return(await context.AcquireTokenByDeviceCodeAsync(deviceCodeResult));
#endif
}
static void Main(string[] args)
{
#region parameters
string authority, resource, deviceloginaddr;
//#if(instance=="global")
authority = "https://login.microsoftonline.com/common";
resource = "https://office365devlabs.onmicrosoft.com/TodoListService-OBO";
deviceloginaddr = "https://aka.ms/devicelogin";
//#else
authority = "https://login.chinacloudapi.cn/common";
resource = "https://modtsp.partner.onmschina.cn/dotnet-obo-webapi";
deviceloginaddr = "https://aka.ms/gallatindevicelogin";
//#endif
#endregion
var ctx = new AuthenticationContext(authority: authority);
var deviceCode = ctx.AcquireDeviceCodeAsync(resource, "{{obo-console-clientid}}").Result;
Console.WriteLine($"请打开浏览器，访问 {deviceloginaddr} ,并以 {deviceCode.UserCode} 登陆");
var result = ctx.AcquireTokenByDeviceCodeAsync(deviceCode).Result;
var httpClient = new HttpClient();
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", result.AccessToken);
// Call the To Do list service.
HttpResponseMessage response = httpClient.GetAsync("http://localhost:5000/api/values").Result;
Console.WriteLine(response.Content.ReadAsStringAsync().Result);
}
static async Task Main(string[] args)
{
const string aadInstance = "https://login.windows.net/{0}";
const string tenant = "thinktecture.com";
const string serviceResourceId = "https://gab-easy-auth-test.azurewebsites.net";
const string clientId = "fb50c490-9ecf-4a1a-88d6-5ba9759de599";
var authContext = new AuthenticationContext(string.Format(CultureInfo.InvariantCulture, aadInstance, tenant));
var deviceCodeResult = await authContext.AcquireDeviceCodeAsync(serviceResourceId, clientId);
Console.WriteLine(deviceCodeResult.Message);
var result = await authContext.AcquireTokenByDeviceCodeAsync(deviceCodeResult);
Console.WriteLine($"Token acquired. ");
Console.WriteLine("--------------------------------------------");
var httpClient = new HttpClient();
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", result.AccessToken);
Console.WriteLine("Calling Function 1");
var response = await httpClient.GetAsync($"https://gab-easy-auth-test.azurewebsites.net/api/Function1");
Console.WriteLine($"Status {response.StatusCode} Content: {await response.Content.ReadAsStringAsync()}");
Console.WriteLine("--------------------------------------------");
Console.WriteLine("Calling Function 2");
response = await httpClient.GetAsync($"https://gab-easy-auth-test.azurewebsites.net/api/Function2");
Console.WriteLine($"Status {response.StatusCode} Content: {await response.Content.ReadAsStringAsync()}");
}
// This prompts the user to open a browser and input a unique key to authenticate their app
// This allows dotnet core apps to authorize an application through user credentials without displaying UI.
private static async Task <AuthenticationResult> GetResultsUsingDeviceCode(AuthenticationContext authContext, AppSettings appSettings)
{
var codeResult = await authContext.AcquireDeviceCodeAsync(appSettings.Resource, appSettings.ClientId);
Console.WriteLine(codeResult.Message);
return(await authContext.AcquireTokenByDeviceCodeAsync(codeResult));
}
/// <summary>
/// Authenticates using the device code flow. See here for more information:
/// https://azure.microsoft.com/en-us/resources/samples/active-directory-dotnet-deviceprofile/.
/// </summary>
/// <param name="displayDeviceCodeMessageToUser">
/// The action which displays the message from ADAL (containing the retrieved device code) to the user.
/// The message will instruct the user to enter the device code by navigating to http://aka.ms/devicelogin/.
/// </param>
/// <param name="useAdminConsentFlow">
/// Whether or not to trigger the admin consent flow for this app ID.
/// </param>
/// <returns>The HTTP header to use when making calls.</returns>
internal static SdkAuthResult AuthWithDeviceCode(
Action <string> displayDeviceCodeMessageToUser,
bool useAdminConsentFlow = false)
{
if (displayDeviceCodeMessageToUser == null)
{
throw new ArgumentNullException(nameof(displayDeviceCodeMessageToUser));
}
// Get the environment parameters
EnvironmentParameters environmentParameters = AuthUtils.CurrentEnvironmentParameters;
// Create auth context that we will use to connect to the AAD endpoint
AuthenticationContext authContext = new AuthenticationContext(environmentParameters.AuthUrl);
if (useAdminConsentFlow)
{
// Remove this user's token from the token cache so they have to log in again (we must use the "Auto" Prompt behavior to add query parameters)
SdkAuthResult currentLogin = AuthUtils.LatestAdalAuthResult;
if (currentLogin != null)
{
// Find all the items in the cache with the logged in user ID, client ID and resource ID
IEnumerable <TokenCacheItem> toRemove = authContext.TokenCache.ReadItems()
.Where(
tokenCacheItem => tokenCacheItem.UniqueId == currentLogin.UserUniqueId &&
tokenCacheItem.ClientId == environmentParameters.AppId &&
tokenCacheItem.Resource == environmentParameters.ResourceId);
// Remove the items
foreach (TokenCacheItem tokenCacheItem in toRemove)
{
authContext.TokenCache.DeleteItem(tokenCacheItem);
}
}
}
// Get the device code
DeviceCodeResult deviceCodeResult = authContext.AcquireDeviceCodeAsync(
environmentParameters.ResourceId,
environmentParameters.AppId,
useAdminConsentFlow ? AuthUtils.AdminConsentQueryParameter : null)
.GetAwaiter().GetResult();
// Display the device code
displayDeviceCodeMessageToUser(deviceCodeResult.Message);
// Get the auth token
//TODO: Figure out why this call hangs and crashes the PowerShell session if the first login was cancelled and the second login times out
AuthenticationResult authenticationResult = authContext.AcquireTokenByDeviceCodeAsync(deviceCodeResult)
.GetAwaiter().GetResult();
// Convert the auth result into our own type
SdkAuthResult authResult = authenticationResult.ToSdkAuthResult();
// Save the auth result
AuthUtils.LatestAdalAuthResult = authResult;
return(authResult);
}
// This prompts the user to open a browser and input a unique key to authenticate their app
// This allows dotnet core apps to authorize an application through user credentials without displaying UI.
private static async Task <AuthenticationResult> GetResultsUsingDeviceCode(AuthenticationContext authContext, string resource, string clientId)
{
var codeResult = await authContext.AcquireDeviceCodeAsync(resource, clientId);
await FeedbackHelper.Channel.SendMessageAsync(codeResult.Message, MessageType.Info);
return(await authContext.AcquireTokenByDeviceCodeAsync(codeResult));
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public static async Task <AuthenticationResult> AcquireTokenWithDeviceCodeAsync()
{
DeviceCodeResult codeResult = await ctx.AcquireDeviceCodeAsync(Resource, ClientId);
Console.WriteLine("You need to sign in.");
Console.WriteLine("Message: " + codeResult.Message + "\n");
return(await ctx.AcquireTokenByDeviceCodeAsync(codeResult).ConfigureAwait(false));
}
private static async Task <AuthenticationResult> GetTokenFromDeviceCodeAsync()
{
// [SCENARIO] OAuth 2.0 Device Code Flow
// Get a token to authenticate against the Web API.
var context = new AuthenticationContext(StsConfiguration.Authority, StsConfiguration.CanValidateAuthority);
var deviceCode = await context.AcquireDeviceCodeAsync(AppConfiguration.TodoListWebApiResourceId, AppConfiguration.TodoListConsoleClientId);
Console.WriteLine(deviceCode.Message);
return(await context.AcquireTokenByDeviceCodeAsync(deviceCode));
}
static AuthenticationResult UserLogin()
{
authenticationContext = new AuthenticationContext
(String.Format(CultureInfo.InvariantCulture, Configuration["AzureAd:AadInstance"], Configuration["AzureAd:TenantId"]));
authenticationContext.TokenCache.Clear();
DeviceCodeResult deviceCodeResult = authenticationContext.AcquireDeviceCodeAsync(aadResourceAppId, (Configuration["AzureAd:ClientId"])).Result;
Console.WriteLine(deviceCodeResult.Message);
return(authenticationContext.AcquireTokenByDeviceCodeAsync(deviceCodeResult).Result);
}
static void Main(string[] args)
{
#region parameters
string authority, resource, deviceloginaddr;
//#if(instance=="gallatin")
authority = "https://login.chinacloudapi.cn/common";
resource = "https://microsoftgraph.chinacloudapi.cn";
deviceloginaddr = "https://aka.ms/gallatindevicelogin";
//#else
authority = "https://login.microsoftonline.com/common";
resource = "https://graph.microsoft.com";
deviceloginaddr = "https://aka.ms/devicelogin";
//#endif
#endregion
var token = "";
var client = new GraphServiceClient(new DelegateAuthenticationProvider((request) =>
{
if (string.IsNullOrEmpty(token))
{
var ctx = new AuthenticationContext(authority: authority);
var deviceCode = ctx.AcquireDeviceCodeAsync(resource, "{{clientId}}").Result;
Console.WriteLine($"请打开浏览器，访问 {deviceloginaddr} ,并以 {deviceCode.UserCode} 登陆");
token = ctx.AcquireTokenByDeviceCodeAsync(deviceCode).Result.AccessToken;
}
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", token);
return(Task.FromResult(0));
}))
{
BaseUrl = $"{resource}/{{version}}"
};
var user = client.Me.Request().GetAsync().Result;
Console.WriteLine($"当前登录用户为:{user.DisplayName}\r\n");
var messages = client.Me.Messages.Request().GetAsync().Result;
Console.WriteLine($"当前用户的收件箱最近十封邮件如下：");
foreach (var item in messages)
{
Console.WriteLine($"\t{item.Subject}");
}
var files = client.Me.Drive.Root.Children.Request().GetAsync().Result;
Console.WriteLine($"\r\n当前用户的个人网盘的文件信息如下：");
foreach (var item in files)
{
Console.WriteLine($"\t{item.Name}");
}
}
static async Task <string> GetTokenAsync()
{
var authContext = new AuthenticationContext(Settings.Authority);
var deviceCodeResult = await
authContext.AcquireDeviceCodeAsync(Settings.DigitalTwinsResourceId, Settings.ClientId);
Console.WriteLine(deviceCodeResult.Message);
var token = await authContext.AcquireTokenByDeviceCodeAsync(deviceCodeResult);
return(token.AccessToken);
}
public async Task EnsureAuthTokenValid(HttpClient client)
{
// Check to see if the token has expired before requesting one.
// We will go ahead and request a new one if we are within 2 minutes of the token expiring.
if (_tokenExpiresAtUtc < DateTime.UtcNow.AddMinutes(-2))
{
var context = new AuthenticationContext("https://login.microsoftonline.com/common", _tokenCache);
string tenantFromToken = null;
if (context.TokenCache.Count > 0)
{
tenantFromToken = context.TokenCache.ReadItems().First().TenantId;
}
var tenant = tenantFromToken ?? _tenantId ?? "common";
context = new AuthenticationContext("https://login.microsoftonline.com/" + tenant, _tokenCache);
AuthenticationResult result;
if (!string.IsNullOrEmpty(_clientId) && !string.IsNullOrEmpty(_clientSecret))
{
result = await context.AcquireTokenAsync(
AzureManagementResource,
new ClientCredential(_clientId, _clientSecret));
}
else
{
try
{
result = await context.AcquireTokenSilentAsync(
AzureManagementResource,
PowerShellClientId);
}
catch (AdalSilentTokenAcquisitionException)
{
var codeResult = await context.AcquireDeviceCodeAsync(
AzureManagementResource,
PowerShellClientId);
Console.WriteLine("You need to sign in.");
Console.WriteLine(codeResult.Message);
result = await context.AcquireTokenByDeviceCodeAsync(codeResult);
}
}
if (string.IsNullOrEmpty(result.AccessToken))
{
throw new AuthenticationFailureException("Blank Auth Token");
}
_tokenExpiresAtUtc = result.ExpiresOn.UtcDateTime;
_tokenValue = result.AccessToken;
Console.WriteLine($"Authenticated as {AuthUser}");
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", _tokenValue);
}
}
public async Task FullCoveragePositiveTestAsync()
{
MockHttpMessageHandler mockMessageHandler = new MockHttpMessageHandler(TestConstants.DefaultAuthorityHomeTenant)
{
Method = HttpMethod.Get,
Url = TestConstants.DefaultAuthorityHomeTenant + "oauth2/devicecode",
ResponseMessage = MockHelpers.CreateSuccessDeviceCodeResponseMessage()
};
HttpMessageHandlerFactory.AddMockHandler(mockMessageHandler);
mockMessageHandler = new MockHttpMessageHandler(TestConstants.DefaultAuthorityHomeTenant)
{
Method = HttpMethod.Post,
Url = TestConstants.DefaultAuthorityHomeTenant + "oauth2/token",
ResponseMessage = MockHelpers.CreateFailureResponseMessage("{\"error\":\"authorization_pending\"," +
"\"error_description\":\"AADSTS70016: Pending end-user authorization." +
"\\r\\nTrace ID: f6c2c73f-a21d-474e-a71f-d8b121a58205\\r\\nCorrelation ID: " +
"36fe3e82-442f-4418-b9f4-9f4b9295831d\\r\\nTimestamp: 2015-09-24 19:51:51Z\"," +
"\"error_codes\":[70016],\"timestamp\":\"2015-09-24 19:51:51Z\",\"trace_id\":" +
"\"f6c2c73f-a21d-474e-a71f-d8b121a58205\",\"correlation_id\":" +
"\"36fe3e82-442f-4418-b9f4-9f4b9295831d\"}")
};
HttpMessageHandlerFactory.AddMockHandler(mockMessageHandler);
HttpMessageHandlerFactory.AddMockHandler(new MockHttpMessageHandler(TestConstants.DefaultAuthorityHomeTenant)
{
Method = HttpMethod.Post,
Url = TestConstants.DefaultAuthorityHomeTenant + "oauth2/token",
ResponseMessage =
MockHelpers.CreateSuccessTokenResponseMessage(TestConstants.DefaultUniqueId,
TestConstants.DefaultDisplayableId, TestConstants.DefaultResource)
});
TokenCache cache = new TokenCache();
AuthenticationContext ctx = new AuthenticationContext(TestConstants.DefaultAuthorityHomeTenant, cache);
DeviceCodeResult dcr = await ctx.AcquireDeviceCodeAsync("some-resource", "some-client").ConfigureAwait(false);
Assert.IsNotNull(dcr);
Assert.AreEqual("some-device-code", dcr.DeviceCode);
Assert.AreEqual("some-user-code", dcr.UserCode);
Assert.AreEqual("some-URL", dcr.VerificationUrl);
Assert.AreEqual(5, dcr.Interval);
Assert.AreEqual("some-message", dcr.Message);
Assert.AreEqual("some-client", dcr.ClientId);
AuthenticationResult result = await ctx.AcquireTokenByDeviceCodeAsync(dcr).ConfigureAwait(false);
Assert.IsNotNull(result);
Assert.AreEqual("some-access-token", result.AccessToken);
// There should be one cached entry.
Assert.AreEqual(1, ctx.TokenCache.Count);
}
static async Task <AuthenticationResult> GetTokenViaCode(AuthenticationContext ctx)
{
AuthenticationResult result = null;
DeviceCodeResult codeResult = await ctx.AcquireDeviceCodeAsync(RESOURCE_ID, CLIENT_ID);
Console.ResetColor();
Console.WriteLine("You need to sign in.");
Console.WriteLine("Message: " + codeResult.Message + "\n");
result = await ctx.AcquireTokenByDeviceCodeAsync(codeResult);
return(result);
}
private static async Task <string> GetTokenViaCode(string clientId)
{
var resource = "https://graph.microsoft.com";
var ctx = new AuthenticationContext("https://login.microsoftonline.com/common");
DeviceCodeResult codeResult = await ctx.AcquireDeviceCodeAsync(resource, clientId);
Console.WriteLine("You need to sign in.");
Console.WriteLine("Message: " + codeResult.Message);
var token = await ctx.AcquireTokenByDeviceCodeAsync(codeResult);
return(token.AccessToken);
}
public async Task <AuthData> AcquireDeviceCodeAsync()
{
TokenCache TC = new TokenCache();
// Create an instance of AuthenticationContext to acquire an Azure access token
authContext = new AuthenticationContext(authority, TC);
deviceCode = await authContext.AcquireDeviceCodeAsync(resourceUri, clientID);
return(new AuthData
{
VerificationUrl = deviceCode.VerificationUrl,
UserCode = deviceCode.UserCode
});
}
public static async Task <string> GetTokenByCode(AzureAd azureAd)
{
var ctx = new AuthenticationContext("https://login.microsoftonline.com/common");
var resource = azureAd.Resource;
var clientId = azureAd.ClientId;
var deviceCodeResult = await ctx.AcquireDeviceCodeAsync(resource, clientId);
Console.ResetColor();
Console.WriteLine("You need to sign in.");
Console.WriteLine("Message: " + deviceCodeResult.Message);
var authResult = await ctx.AcquireTokenByDeviceCodeAsync(deviceCodeResult);
return(authResult.AccessToken);
}
public static async Task <string> GetAccessTokenAsync(AadMetadata aad, CancellationToken cancellationToken)
{
var authority = aad.Authority;
var authContext = new AuthenticationContext(authority);
AuthenticationResult authResult = null;
var token = string.Empty;
// On full .net framework, use interactive logon to get token.
// On dotnet core, acquire token using device id.
// https://github.com/AzureAD/azure-activedirectory-library-for-dotnet/wiki/Acquiring-a-token-return-AuthenticationResult-and-possibly-UserInfo
#if DotNetCoreClr
try
{
authResult = await authContext.AcquireTokenSilentAsync(aad.Cluster, aad.Client);
}
catch (AdalException adalException)
{
if (adalException.ErrorCode == AdalError.FailedToAcquireTokenSilently ||
adalException.ErrorCode == AdalError.InteractionRequired)
{
try
{
var codeResult = await authContext.AcquireDeviceCodeAsync(aad.Cluster, aad.Client);
Console.WriteLine(Resource.MsgAADSignin);
Console.WriteLine(codeResult.Message + "\n");
authResult = await authContext.AcquireTokenByDeviceCodeAsync(codeResult);
}
catch (Exception ex)
{
Console.WriteLine(Resource.ErrorAAD);
Console.WriteLine("Message: " + ex.Message + "\n");
}
}
}
token = authResult.AccessToken;
#else
authResult = await authContext.AcquireTokenAsync(
aad.Cluster,
aad.Client,
new Uri(aad.Redirect),
new PlatformParameters(PromptBehavior.SelectAccount));
token = authResult.AccessToken;
#endif
return(token);
}
public static async Task <string> AcquireUserAccessTokenAsync(string authority, string resource, string scope)
{
var context = new AuthenticationContext(authority, TokenCache.DefaultShared);
if (_deviceCodeResponse == null)
{
_deviceCodeResponse = await context.AcquireDeviceCodeAsync(resource, SampleConstants.WellKnownClientId).ConfigureAwait(false);
Console.WriteLine("############################################################################################");
Console.WriteLine("To continue with the test run, please follow these instructions: {0}", _deviceCodeResponse.Message);
Console.WriteLine("############################################################################################");
}
var result = await context.AcquireTokenByDeviceCodeAsync(_deviceCodeResponse).ConfigureAwait(false);
return(result.AccessToken);
}
private static async Task <(TokenCredentials, TokenCredentials)> AuthenticateDeviceCode(string tenantId)
{
var authority = new Authority(tenantId);
var context = new AuthenticationContext(authority.AuthorityUri);
var code = await context.AcquireDeviceCodeAsync(authority.ResourceUri, authority.ClientId);
Console.WriteLine("\n" + code.Message + "\n\n");
AuthenticationResult token = await context.AcquireTokenByDeviceCodeAsync(code);
var serviceCredentials = new TokenCredentials(token.AccessToken);
var silentToken = await context.AcquireTokenSilentAsync(authority.GraphUri, authority.ClientId, new UserIdentifier(token.UserInfo.UniqueId, UserIdentifierType.UniqueId));
var graphCredentials = new TokenCredentials(silentToken.AccessToken);
return(serviceCredentials, graphCredentials);
}
public async Task NegativeDeviceCodeTimeoutTestAsync()
{
MockHttpMessageHandler mockMessageHandler = new MockHttpMessageHandler(TestConstants.DefaultAuthorityHomeTenant)
{
Method = HttpMethod.Get,
Url = TestConstants.DefaultAuthorityHomeTenant + "oauth2/devicecode",
ResponseMessage = MockHelpers.CreateSuccessDeviceCodeResponseMessage("1")
};
HttpMessageHandlerFactory.AddMockHandler(mockMessageHandler);
mockMessageHandler = new MockHttpMessageHandler(TestConstants.DefaultAuthorityHomeTenant)
{
Method = HttpMethod.Post,
Url = TestConstants.DefaultAuthorityHomeTenant + "oauth2/token",
ResponseMessage = MockHelpers.CreateFailureResponseMessage("{\"error\":\"authorization_pending\"," +
"\"error_description\":\"AADSTS70016: Pending end-user authorization." +
"\\r\\nTrace ID: f6c2c73f-a21d-474e-a71f-d8b121a58205\\r\\nCorrelation ID: " +
"36fe3e82-442f-4418-b9f4-9f4b9295831d\\r\\nTimestamp: 2015-09-24 19:51:51Z\"," +
"\"error_codes\":[70016],\"timestamp\":\"2015-09-24 19:51:51Z\",\"trace_id\":" +
"\"f6c2c73f-a21d-474e-a71f-d8b121a58205\",\"correlation_id\":" +
"\"36fe3e82-442f-4418-b9f4-9f4b9295831d\"}")
};
HttpMessageHandlerFactory.AddMockHandler(mockMessageHandler);
mockMessageHandler = new MockHttpMessageHandler(TestConstants.DefaultAuthorityHomeTenant)
{
Method = HttpMethod.Post,
Url = TestConstants.DefaultAuthorityHomeTenant + "oauth2/token",
ResponseMessage = MockHelpers.CreateDeviceCodeExpirationErrorResponse()
};
HttpMessageHandlerFactory.AddMockHandler(mockMessageHandler);
TokenCache cache = new TokenCache();
AuthenticationContext ctx = new AuthenticationContext(TestConstants.DefaultAuthorityHomeTenant, cache);
DeviceCodeResult dcr = await ctx.AcquireDeviceCodeAsync("some resource", "some authority").ConfigureAwait(false);
Assert.IsNotNull(dcr);
AuthenticationResult result;
AdalServiceException ex = AssertException.TaskThrows <AdalServiceException>(async() => result = await ctx.AcquireTokenByDeviceCodeAsync(dcr).ConfigureAwait(false));
Assert.IsTrue(ex.Message.Contains("Verification code expired"));
}
static async Task <AuthenticationResult> RetrieveToken(string method, ActiveDirectoryConfig config)
{
var ctx = new AuthenticationContext(ActiveDirectoryConfig.AuthorityHost + "/" + config.Tenant);
AuthenticationResult result;
try
{
result = await ctx.AcquireTokenSilentAsync(ActiveDirectoryConfig.Resource, config.ClientId);
}
catch (Exception)
{
switch (method)
{
case "aadauthcode":
result = await ctx.AcquireTokenAsync(ActiveDirectoryConfig.Resource, config.ClientId,
new Uri(config.RedirectUri),
new PlatformParameters(PromptBehavior.SelectAccount));
break;
case "aaddevice":
var codeResult = await ctx.AcquireDeviceCodeAsync(ActiveDirectoryConfig.Resource, config.ClientId);
Console.WriteLine("Open: " + codeResult.VerificationUrl);
Console.WriteLine("Enter: " + codeResult.UserCode);
result = await ctx.AcquireTokenByDeviceCodeAsync(codeResult);
break;
case "aadclient":
var clientCredential = new ClientCredential(config.ClientId, config.ClientSecret);
result = await ctx.AcquireTokenAsync(ActiveDirectoryConfig.Resource, clientCredential);
break;
default:
Console.WriteLine("Method not found");
throw new Exception("Method not found");
}
}
return(result);
}
public async Task <IAdalToken> AcquireTokenWithDeviceFlowAsync(Func <DeviceCodeResult, Task> deviceCodeHandler, CancellationToken cancellationToken)
{
var deviceCode = await authenticationContext.AcquireDeviceCodeAsync(resource, clientId);
cancellationToken.ThrowIfCancellationRequested();
if (deviceCodeHandler != null)
{
await deviceCodeHandler(deviceCode);
cancellationToken.ThrowIfCancellationRequested();
}
var result = await authenticationContext.AcquireTokenByDeviceCodeAsync(deviceCode);
cancellationToken.ThrowIfCancellationRequested();
return(new AdalToken(result));
}
static AuthenticationResult GetTokenViaCode(AuthenticationContext ctx)
{
AuthenticationResult result = null;
try
{
DeviceCodeResult codeResult = ctx.AcquireDeviceCodeAsync(resource, clientId).Result;
Console.ResetColor();
Console.WriteLine("You need to sign in.");
Console.WriteLine("Message: " + codeResult.Message + "\n");
result = ctx.AcquireTokenByDeviceCodeAsync(codeResult).Result;
}
catch (Exception exc)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Something went wrong.");
Console.WriteLine("Message: " + exc.Message + "\n");
}
return(result);
}
private async Task <string> GetAccessTokenAsync()
{
var context = new AuthenticationContext(_settings.Authority);
AuthenticationResult result;
try
{
result = await context.AcquireTokenSilentAsync(_settings.ApiResourceUri, _settings.ClientId);
}
catch (AdalSilentTokenAcquisitionException)
{
DeviceCodeResult deviceCodeResult = await context.AcquireDeviceCodeAsync(_settings.ApiResourceUri, _settings.ClientId);
Console.WriteLine(deviceCodeResult.Message);
result = await context.AcquireTokenByDeviceCodeAsync(deviceCodeResult);
}
return(result.AccessToken);
}