static async Task Main()
{
// discover endpoints from metadata
var client = new HttpClient();
var disco = await client.GetDiscoveryDocumentAsync(new DiscoveryDocumentRequest
{
Address = "https://identity.website.com:5001",
Policy = { RequireHttps = false }
});
if (disco.IsError)
{
Console.WriteLine(disco.Error);
return;
}
// request token
var tokenResponse = await client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "client",
ClientSecret = "secret",
Scope = "api1"
});
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
Console.WriteLine(tokenResponse.Json);
Console.WriteLine("\n\n");
// call api
var apiClient = new HttpClient();
apiClient.SetBearerToken(tokenResponse.AccessToken);
string baseUrl = "https://api.website.com:5003";
// call authorized identity
var response = await apiClient.GetAsync(baseUrl + "/identity");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
// call authorized controller
response = await apiClient.GetAsync(baseUrl + "/cake");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(content);
}
// call unauthorized controller
response = await apiClient.GetAsync(baseUrl + "/weatherforecast");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
}
private static async Task MainAsync()
{
Console.WriteLine("Spotify API");
var token = GetToken().Result;
//Console.WriteLine(String.Format("Access Token: {0}", token.access_token));
// discover endpoints from metadata
var disco = await DiscoveryClient.GetAsync("http://localhost:5001");
if (disco.IsError)
{
Console.WriteLine(disco.Error);
return;
}
// request token
var tokenClient = new TokenClient(disco.TokenEndpoint, "client", "secret");
var tokenResponse = await tokenClient.RequestClientCredentialsAsync("api1");
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
Console.WriteLine(tokenResponse.Json);
Console.WriteLine("\n\n");
// call api
var client = new HttpClient();
client.SetBearerToken(tokenResponse.AccessToken);
var response = await client.GetAsync("http://localhost:5000/api/Modulo");
//var response = await client.GetAsync("https://localhost:44322/api/Modulo");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
//// request token
//var tokenClientx = new TokenClient(disco.TokenEndpoint, "ro.client", "secret");
//var tokenResponsex = await tokenClientx.RequestResourceOwnerPasswordAsync("alice", "password", "api1");
//if (tokenResponsex.IsError)
//{
// Console.WriteLine(tokenResponsex.Error);
// return;
//}
//Console.WriteLine(tokenResponsex.Json);
//Console.WriteLine("\n\n");
//// call api
//var clientx = new HttpClient();
//clientx.SetBearerToken(tokenResponsex.AccessToken);
//var responsex = await clientx.GetAsync("http://localhost:5001/identity");
//if (!responsex.IsSuccessStatusCode)
//{
// Console.WriteLine(responsex.StatusCode);
//}
//else
//{
// var contentx = await responsex.Content.ReadAsStringAsync();
// Console.WriteLine(JArray.Parse(contentx));
//}
}
private static async Task <string> GetToken()
{
using (var client = new HttpClient())
{
//Define Headers
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer");
//Prepare Request Body
List <KeyValuePair <string, string> > requestData = new List <KeyValuePair <string, string> >();
requestData.Add(new KeyValuePair <string, string>("grant_type", "client_credentials"));
requestData.Add(new KeyValuePair <string, string>("client_id", "client"));
requestData.Add(new KeyValuePair <string, string>("client_secret", "secret"));
requestData.Add(new KeyValuePair <string, string>("redirect_uri", "http://localhost:59820"));
requestData.Add(new KeyValuePair <string, string>("response_type", "token"));
requestData.Add(new KeyValuePair <string, string>("RequestedScopes", "modulo_api"));
FormUrlEncodedContent requestBody = new FormUrlEncodedContent(requestData);
//Request Token
var request = await client.PostAsync("http://localhost:5001/connect/token", requestBody);
var response = request.Content.ReadAsStringAsync();
var token = JsonConvert.DeserializeObject <AccessToken>(response.Result.ToString());
client.SetBearerToken(token.access_token);
var responseA = await client.GetAsync("http://localhost:59820/api/Home");
if (!responseA.IsSuccessStatusCode)
{
Console.WriteLine(responseA.StatusCode);
}
else
{
var content = await responseA.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
}
string clientId = "dameswaggerui";
string clientSecret = "SEGREDO";
string credentials = String.Format("{0}", clientId);
//var tokenClient = new TokenClient("http://localhost:5001/connect/token/", "dameswaggerui","SEGREDO");
// var tokenResponse = await tokenClient.RequestClientCredentialsAsync("dame_api");
// var token = await HttpContext.GetTokenAsync("access_token");
var disco = await DiscoveryClient.GetAsync("http://localhost:5001");
if (disco.IsError)
{
Console.WriteLine(disco.Error);
//return;
}
// request token
var tokenClient = new TokenClient(disco.TokenEndpoint, "client", "secret");
var tokenResponse = await tokenClient.RequestClientCredentialsAsync("dame_api");
using (var client = new HttpClient())
{
//Define Headers
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", Convert.ToBase64String(Encoding.UTF8.GetBytes(credentials)));
//Prepare Request Body
List <KeyValuePair <string, string> > requestData = new List <KeyValuePair <string, string> >();
requestData.Add(new KeyValuePair <string, string>("grant_type", "client_credentials"));
requestData.Add(new KeyValuePair <string, string>("client_id", "dameswaggerui"));
requestData.Add(new KeyValuePair <string, string>("redirect_uri", "http://localhost:59820"));
requestData.Add(new KeyValuePair <string, string>("response_type", "token"));
requestData.Add(new KeyValuePair <string, string>("RequestedScopes", "dame_api"));
requestData.Add(new KeyValuePair <string, string>("Username", "bob"));
requestData.Add(new KeyValuePair <string, string>("Password", "password"));
FormUrlEncodedContent requestBody = new FormUrlEncodedContent(requestData);
//Request Token
var request = await client.PostAsync("http://localhost:5001/connect/token", requestBody);
var response = request.Content.ReadAsStringAsync();
var token = JsonConvert.DeserializeObject <AccessToken>(response.ToString());
return("A");
}
}
private static async Task MainAsync()
{
// discover endpoints from metadata
// IdentityModel includes a client library to use with the discovery endpoint.
// This way you only need to know the base-address of IdentityServer
// - the actual endpoints addresses can be read from the metadata:
var disco = await DiscoveryClient.GetAsync("http://localhost:5000");
if (disco.IsError)
{
Console.WriteLine(disco.Error);
return;
}
// request token
TokenClient tokenClient = new TokenClient(disco.TokenEndpoint, "client", "secret");
var tokenResponse = await tokenClient.RequestClientCredentialsAsync("api1");
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
Console.WriteLine(tokenResponse.Json);
Console.WriteLine("\n\n");
// call api
HttpClient client = new HttpClient();
// To send the access token to the API you typically use the HTTP Authorization header. This is done using the SetBearerToken extension method:
client.SetBearerToken(tokenResponse.AccessToken);
var response = await client.GetAsync("http://localhost:5001/identity");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
string content = await response.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
//requesting token using password grant
// The token will now contain "sub" claim. The presence or absence of sub claim lets the Api distiguish between calls on behalf of clients and calls on behalf of users
var tokenClientPasswordGrant = new TokenClient(disco.TokenEndpoint, "ro.client", "secret");
var tokenResponsePasswordGrant = await tokenClientPasswordGrant.RequestResourceOwnerPasswordAsync("alice", "password", "api1");
if (tokenResponsePasswordGrant.IsError)
{
Console.WriteLine(tokenResponsePasswordGrant.Error);
return;
}
Console.WriteLine(tokenResponsePasswordGrant.Json);
Console.WriteLine("\n\n");
// call api
// To send the access token to the API you typically use the HTTP Authorization header. This is done using the SetBearerToken extension method:
client.SetBearerToken(tokenResponsePasswordGrant.AccessToken);
var responsePasswordGrant = await client.GetAsync("http://localhost:5001/identity");
if (!responsePasswordGrant.IsSuccessStatusCode)
{
Console.WriteLine(responsePasswordGrant.StatusCode);
}
else
{
string content = await responsePasswordGrant.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
}
static async Task Test()
{
// discover endpoints from metadata
var disco = await DiscoveryClient.GetAsync("http://localhost:5000");
if (disco.IsError)
{
Console.WriteLine(disco.Error);
return;
}
Console.WriteLine("Hello World!");
// request client token
var tokenClient = new TokenClient(disco.TokenEndpoint, "client", "secret");
var tokenResponse = await tokenClient.RequestClientCredentialsAsync("api1");
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
Console.WriteLine(tokenResponse.Json);
// call api
var client = new HttpClient();
client.SetBearerToken(tokenResponse.AccessToken);
var response = await client.GetAsync("http://localhost:5001/identity");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
// request user token
tokenClient = new TokenClient(disco.TokenEndpoint, "ro.client", "secret");
tokenResponse = await tokenClient.RequestResourceOwnerPasswordAsync("alice", "password", "api1");
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
client = new HttpClient();
client.SetBearerToken(tokenResponse.AccessToken);
response = await client.GetAsync("http://localhost:5001/identity");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
Console.WriteLine(tokenResponse.Json);
Console.WriteLine("\n\n");
}
private static async Task MainAsync()
{
// // discover endpoints from metadata
// var disco = await DiscoveryClient.GetAsync("http://localhost:5000");
// if (disco.IsError)
// {
// Console.WriteLine(disco.Error);
// return;
// }
// // request token
// var tokenClient = new TokenClient(disco.TokenEndpoint, "client", "secret");
// var tokenResponse = await tokenClient.RequestClientCredentialsAsync("api1");
// if (tokenResponse.IsError)
// {
// Console.WriteLine(tokenResponse.Error);
// return;
// }
// Console.WriteLine(tokenResponse.Json);
// Console.WriteLine("\n\n");
// // call api
// var client = new HttpClient();
// client.SetBearerToken(tokenResponse.AccessToken);
// var response = await client.GetAsync("http://localhost:5001/identity");
// if (!response.IsSuccessStatusCode)
// {
// Console.WriteLine(response.StatusCode);
// }
// else
// {
// var content = await response.Content.ReadAsStringAsync();
// Console.WriteLine(JArray.Parse(content));
// }
// 从元数据中发现客户端
var disco = await DiscoveryClient.GetAsync("http://localhost:5000");
// 请求令牌
var tokenClient = new TokenClient(disco.TokenEndpoint, "ro.client", "secret");
var tokenResponse = await tokenClient.RequestResourceOwnerPasswordAsync("wjk", "123", "api1");//使用用户名密码
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
Console.WriteLine(tokenResponse.Json);
Console.WriteLine("\n\n");
// call api
var client = new HttpClient();
client.SetBearerToken(tokenResponse.AccessToken);
var response = await client.GetAsync("http://localhost:5001/identity");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
}
public void Configure(IApplicationBuilder app)
{
app.UseCookieAuthentication(options =>
{
options.AuthenticationScheme = "Cookies";
options.AutomaticAuthentication = true;
});
app.Map("/code", application =>
{
application.Use((context, next) =>
{
var client = new OAuth2Client(new Uri("http://localhost:5000/core/connect/authorize"));
var url = client.CreateCodeFlowUrl(clientId: "0011FF", redirectUri: "http://localhost:5001/callback", scope: "read write");
context.Response.Redirect(url);
return(Task.FromResult(0));
});
});
app.Map("/callback", application =>
{
application.Use(next => async context =>
{
var client = new OAuth2Client(new Uri("http://localhost:5000/core/connect/token"), "0011FF", "ABCDEFG");
var code = context.Request.Query["code"];
TokenResponse response = await client.RequestAuthorizationCodeAsync(code, "http://localhost:5001/callback");
if (!string.IsNullOrEmpty(response.AccessToken))
{
List <Claim> claims = new List <Claim>();
claims.Add(new Claim("access_token", response.AccessToken));
claims.Add(new Claim("expires_at", (DateTime.UtcNow.ToEpochTime() + response.ExpiresIn).ToDateTimeFromEpoch().ToString()));
ClaimsIdentity id = new ClaimsIdentity(claims, "cookie");
ClaimsPrincipal principal = new ClaimsPrincipal(id);
context.Response.SignIn("Cookies", principal);
}
});
});
app.Map("/info", application =>
{
application.Use(next => async context =>
{
ClaimsPrincipal principal = context.User;
await context.Response.WriteAsync(principal.FindFirst("access_token").Value);
});
});
app.Map("/call", application =>
{
application.Use(next => async context =>
{
HttpClient client = new HttpClient();
string accessToken = context.User.FindFirst("access_token").Value;
client.SetBearerToken(accessToken);
string response = await client.GetStringAsync("http://localhost:5002/action");
await context.Response.WriteAsync(response);
});
});
}
static async void getToken()
{
// discover endpoints from metadata
DiscoveryResponse disco = null;
string url = "http://localhost:5000";
//url = "http://10.202.203.29:5000";
url = "http://10.15.4.155:5000";
url = "https://centerbmdwtest.staff.xdf.cn";
//url = "https://localhost";
//if (url.Contains("https"))
//{
// ServicePointManager.ServerCertificateValidationCallback = delegate { return true; };
// //ServicePointManager.Expect100Continue = false;
//}
//using (var dc = new DiscoveryClient(url))
//{
// dc.Policy.RequireHttps = false;
// disco = await dc.GetAsync();
//}
disco = await DiscoveryClient.GetAsync(url);
if (disco.IsError)
{
Console.WriteLine(disco.Error);
return;
}
// request token
var tokenClient = new TokenClient(disco.TokenEndpoint, "test", "secret");
var tokenResponse = await tokenClient.RequestClientCredentialsAsync("api1");
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
Console.WriteLine(tokenResponse.Json);
// call api
var client = new HttpClient();
client.SetBearerToken(tokenResponse.AccessToken);
var response = await client.GetAsync(url + "/api/identity");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(content);
Console.WriteLine(JArray.Parse(content));
}
}
private static async System.Threading.Tasks.Task TestAsync()
{
Console.WriteLine("Testing Client Token");
var disco = await DiscoveryClient.GetAsync("http://localhost:61871");
var tokenClient = new TokenClient(disco.TokenEndpoint, "client", "secret");
var tokenResponse = await tokenClient.RequestClientCredentialsAsync("api1");
Console.WriteLine("Talking to Authentification");
if (tokenResponse.IsError)
{
Console.WriteLine("ERROR");
Console.WriteLine(tokenResponse.Error);
return;
}
Console.WriteLine("SUCCESS");
Console.WriteLine(tokenResponse.Json);
var client = new HttpClient();
client.SetBearerToken(tokenResponse.AccessToken);
Console.WriteLine("Talking to Api with username and password...");
var response = await client.GetAsync("http://localhost:61872/identity");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine("NOT SUCCESS");
Console.WriteLine(response.StatusCode);
}
else
{
Console.WriteLine("CONTENT");
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
Console.WriteLine("Testing client with username and password");
var tokenClient2 = new TokenClient(disco.TokenEndpoint, "ro.client", "secret");
var tokenResponse2 = await tokenClient2.RequestResourceOwnerPasswordAsync("alice", "password", "api1");
if (tokenResponse2.IsError)
{
Console.WriteLine("ERROR");
Console.WriteLine(tokenResponse2.Error);
return;
}
Console.WriteLine("SUCCESS");
Console.WriteLine(tokenResponse2.Json);
Console.WriteLine("\n\n");
var client2 = new HttpClient();
client2.SetBearerToken(tokenResponse2.AccessToken);
Console.WriteLine("Talking to Api with allowed username and password...");
var response2 = await client2.GetAsync("http://localhost:61872/identity");
if (!response2.IsSuccessStatusCode)
{
Console.WriteLine("NOT SUCCESS");
Console.WriteLine(response2.StatusCode);
}
else
{
Console.WriteLine("CONTENT");
var content = await response2.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
}
private static async Task Main()
{
Console.WriteLine("Client Application started. Press Ctrl+C to shut down.");
Console.CancelKeyPress += delegate(object sender, ConsoleCancelEventArgs e) {
e.Cancel = true;
Program.keepRunning = false;
Console.WriteLine("Stop Requested");
};
while (Program.keepRunning)
{
Console.WriteLine("\n==================\nWaitting next cycle...");
await Task.Delay(5000);
string proxyUrl = Environment.GetEnvironmentVariable("proxy_url");
string identityServerUrl = Environment.GetEnvironmentVariable("identity_server_url");
string apiUrl = Environment.GetEnvironmentVariable("api_url");
bool identityServerRequireHttps = Environment.GetEnvironmentVariable("identity_server_require_https") == "true";
string identityServerClientId = Environment.GetEnvironmentVariable("identity_server_client_id");
string identityServerClientSecret = Environment.GetEnvironmentVariable("identity_server_client_secret");
string identityServerScope = Environment.GetEnvironmentVariable("identity_server_scope");
Console.WriteLine("\n00 - Current Configuration:");
Console.WriteLine("- Proxy URL (proxy_url): " + proxyUrl);
Console.WriteLine("- Identity Server URL (identity_server_url): " + identityServerUrl);
Console.WriteLine("- Identity Server Scope (identity_server_scope): " + identityServerScope);
Console.WriteLine("- Identity Server Client ID (identity_server_client_id): " + identityServerClientId);
Console.WriteLine("- Identity Server Client Secret (identity_server_client_secret): " + identityServerClientSecret);
Console.WriteLine("- API URL (api_url): " + apiUrl);
Console.WriteLine("- Require HTTPS (require_https): " + identityServerRequireHttps.ToString());
//define a HTTPHandler with Proxy configuration
HttpClientHandler httpHandlerWithProxy = null;
if (proxyUrl != null && proxyUrl != "")
{
Console.WriteLine("\n00 - Creating Proxy Handler: " + proxyUrl);
httpHandlerWithProxy = new HttpClientHandler
{
//UseDefaultCredentials = true
UseProxy = true,
PreAuthenticate = true,
Proxy = new WebProxy()
{
Address = new Uri(proxyUrl), //proxy address
UseDefaultCredentials = false,
Credentials = System.Net.CredentialCache.DefaultNetworkCredentials
}
};
}
// discover endpoints from metadata
Console.WriteLine("\n01 - Discovering Entrypoints:");
DiscoveryResponse discoveryResponse = null;
if (identityServerRequireHttps)
{
Console.WriteLine("- Using HTTPS");
var discoveryClient = new HttpClient(httpHandlerWithProxy);
discoveryResponse = await discoveryClient.GetDiscoveryDocumentAsync(identityServerUrl); //URL of the IdentityServer
}
else
{
Console.WriteLine("- Not Using HTTPS");
#pragma warning disable CS0618 // Type or member is obsolete
var discoveryClient = httpHandlerWithProxy != null ? new DiscoveryClient(identityServerUrl, httpHandlerWithProxy) : new DiscoveryClient(identityServerUrl);
//var discoveryClient = new DiscoveryClient(identityServerUrl);
#pragma warning restore CS0618 // Type or member is obsolete
discoveryClient.Policy.RequireHttps = false;
discoveryResponse = await discoveryClient.GetAsync();
}
if (discoveryResponse.IsError)
{
Console.WriteLine("Error: " + discoveryResponse.Error);
continue;
}
// request token
Console.WriteLine("\n02 - Requesting Tokens:");
var client = httpHandlerWithProxy != null ? new HttpClient(httpHandlerWithProxy) : new HttpClient();
// Requesting a token using the client_credentials Grant Type
var tokenResponse = await client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
{
Address = discoveryResponse.TokenEndpoint,
ClientId = identityServerClientId,
ClientSecret = identityServerClientSecret,
Scope = identityServerScope
});
if (tokenResponse.IsError)
{
Console.WriteLine("Error: " + tokenResponse.Error);
continue;
}
Console.WriteLine(tokenResponse.Json);
// call api
var apiClient = new HttpClient();
Console.WriteLine("\n03 - Calling API:");
apiClient.SetBearerToken(tokenResponse.AccessToken); //Use HTTP Authorization header to send the access token to the API
try
{
var response = await apiClient.GetAsync(apiUrl + "/identity"); //API address
if (!response.IsSuccessStatusCode)
{
Console.WriteLine("Error: " + response.StatusCode);
continue;
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
}
catch (Exception ex)
{
Console.WriteLine("Error Accessing the API. Source: " + ex.Source + " ; Description: " + ex.Message);
continue;
}
Console.WriteLine("\n04 - Done :)");
}
Console.WriteLine("Exited gracefully!");
}
private static async Task Main(string[] args)
{
var insecureHandler = InsecureHttpsHandler.GetInsecureHandler();
var builder = new HostBuilder()
.ConfigureServices((hostContext, services) =>
{
services.AddHttpClient("DebugClient")
.ConfigureHttpMessageHandlerBuilder(handlerBuilder =>
handlerBuilder.PrimaryHandler = insecureHandler);
services.AddHttpClient("NormalClient");
}).UseConsoleLifetime();
var host = builder.Build();
using var serviceScope = host.Services.CreateScope();
var serviceProvider = serviceScope.ServiceProvider;
var clientFactory = serviceProvider.GetService <IHttpClientFactory>();
#if DEBUG
using var client = clientFactory.CreateClient("DebugClient");
#else
using var client = clientFactory.CreateClient("NormalClient");
#endif
// discover endpoints from metadata
var disco = await client.GetDiscoveryDocumentAsync("https://192.168.1.46:5000");
if (disco.IsError)
{
Console.WriteLine(disco.Error);
return;
}
// request token
var tokenResponse = await client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "client",
ClientSecret = "secret",
Scope = "api1"
});
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
// call api
var apiClient = new HttpClient();
apiClient.SetBearerToken(tokenResponse.AccessToken);
var response = await apiClient.GetAsync("https://localhost:5001/identity");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine($"{(int)response.StatusCode}: {response.StatusCode}");
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
}
private static async Task MainAsync()
{
// discover endpoints from metadata
//var disco = await DiscoveryClient.GetAsync("http://*****:*****@163.com", "123456").Result;
//var tokenResponse = await tokenClient.RequestClientCredentialsAsync("api1");
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
Console.WriteLine(tokenResponse.Json);
Console.WriteLine("\n\n");
// call api
var client = new HttpClient();
client.SetBearerToken(tokenResponse.AccessToken);
//api地址
//var response = await client.GetAsync("http://localhost:1624/identity");
var response = await client.GetAsync("http://DOcelot.APIGateway.com/api/productservice/values");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
Console.WriteLine("\n\n");
var response2 = await client.GetAsync("http://DOcelot.APIGateway.com/api/orderservice/values");
if (!response2.IsSuccessStatusCode)
{
Console.WriteLine(response2.StatusCode);
}
else
{
var content2 = await response2.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content2));
}
Console.ReadLine();
}
private static async Task Main()
{
// discover endpoints from metadata
var client = new HttpClient();
var disco = await client.GetDiscoveryDocumentAsync("http://localhost:5000");
if (disco.IsError)
{
Console.WriteLine(disco.Error);
return;
}
// request token
var tokenResponse = await client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "client",
ClientSecret = "secret2",
Scope = "apiall IdentityServerApi zero_identity_api"
});
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
Console.WriteLine(tokenResponse.Json);
Console.WriteLine("\n\n");
// call api
var apiClient = new HttpClient();
apiClient.SetBearerToken(tokenResponse.AccessToken);
//Api.ApiManagementPermissions.Post zero.tenantRole1:f4898a97-8f4e-4f52-9102-6fdd0639dcf9
var permissionResult = await apiClient.GetAsync("http://localhost:9001/permissions?name=Api.ApiManagementPermissions.Post&providerType=Role&providerKey=zero.tenantRole1&scopeId=3d0a1642-c2e1-4031-96a9-4fc651c245c1");
if (!permissionResult.IsSuccessStatusCode)
{
Console.WriteLine(permissionResult.StatusCode);
}
else
{
var content = await permissionResult.Content.ReadAsStringAsync();
Console.WriteLine(content);
}
var response = await apiClient.GetAsync("http://localhost:5001/identity?scopeId=bbb");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(content);
}
response = await apiClient.PostAsJsonAsync("http://localhost:5001/identity", new { ScopeId = "3d0a1642-c2e1-4031-96a9-4fc651c245c1", Name = "test" });
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(content);
}
}
private static async Task Main()
{
Console.WriteLine("Here is the Information in /.well-known/openid-configuration in STS Press any key to continue...");
Console.ReadLine();
// discover endpoints from metadata
var client = new HttpClient();
var disco = await client.GetDiscoveryDocumentAsync("https://localhost:5001");
if (disco.IsError)
{
Console.WriteLine(disco.Error);
return;
}
Console.WriteLine(disco.Json);
Console.WriteLine("\n\n");
Console.WriteLine("Here is the Token from STS using Client Credential Grany Type. Press any key to continue...");
Console.ReadLine();
// request token
var tokenResponse = await client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "client",
ClientSecret = "secret",
Scope = "default_api"
});
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
Console.WriteLine(tokenResponse.Json);
Console.WriteLine("\n\n");
Console.WriteLine("using Client Credential Grany Type we can call another API. Press any key to continue...");
Console.ReadLine();
// call api
var apiClient = new HttpClient();
apiClient.SetBearerToken(tokenResponse.AccessToken);
var response = await apiClient.GetAsync("https://localhost:10001/WeatherForecast");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
Console.WriteLine("But denied when User Information is requested for another API. Press any key to continue...");
Console.ReadLine();
// call api
apiClient = new HttpClient();
apiClient.SetBearerToken(tokenResponse.AccessToken);
response = await apiClient.GetAsync("https://localhost:10001/identity");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
Console.WriteLine("Here is the Token from STS using Resource Owner Password Grany Type. Press any key to continue...");
Console.ReadLine();
// request token
tokenResponse = await client.RequestPasswordTokenAsync(new PasswordTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "client",
ClientSecret = "secret",
UserName = "******",
Password = "******",
Scope = "default_api"
});
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
Console.WriteLine(tokenResponse.Json);
Console.WriteLine("\n\n");
Console.WriteLine("Calling User API using the Token should go through. Press any key to continue...");
Console.ReadLine();
// call api
apiClient = new HttpClient();
apiClient.SetBearerToken(tokenResponse.AccessToken);
response = await apiClient.GetAsync("https://localhost:10001/identity");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
Console.WriteLine("Calling Admin API Using User Role token, should be denied , Press any key...");
Console.ReadLine();
apiClient = new HttpClient();
apiClient.SetBearerToken(tokenResponse.AccessToken);
response = await apiClient.GetAsync("https://localhost:10001/admin");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
Console.WriteLine("Here is the User Token in Admin Role from STS using Resource Owner Password Grany Type. Press any key to continue ...");
Console.ReadLine();
// request token
tokenResponse = await client.RequestPasswordTokenAsync(new PasswordTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "client",
ClientSecret = "secret",
UserName = "******",
Password = "******",
Scope = "default_api"
});
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
Console.WriteLine(tokenResponse.Json);
Console.WriteLine("\n\n");
// call api
apiClient = new HttpClient();
apiClient.SetBearerToken(tokenResponse.AccessToken);
response = await apiClient.GetAsync("https://localhost:10001/identity");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
Console.WriteLine("Calling API Using Admin Role token, should go through , Press any key...");
Console.ReadLine();
// call api
apiClient = new HttpClient();
apiClient.SetBearerToken(tokenResponse.AccessToken);
response = await apiClient.GetAsync("https://localhost:10001/admin");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
Console.WriteLine("Press any key to End ...");
Console.ReadLine();
}
private static async Task RunDemo()
{
var client = new HttpClient();
// discover endpoints from metadata
var disco = await client.GetDiscoveryDocumentAsync("http://localhost:8001");
if (disco.IsError)
{
Console.WriteLine(disco.Error);
return;
}
// request token
var tokenResponse = await client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest()
{
Address = disco.TokenEndpoint,
ClientId = "client1",
ClientSecret = "123qwe",
//Scope = "api1,AuthServerApi",
});
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
Console.WriteLine(tokenResponse.Json);
Console.WriteLine("访问Api1");
// call api
client.SetBearerToken(tokenResponse.AccessToken);
var response = await client.GetAsync("http://localhost:8003/api/values");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(content);
}
Console.WriteLine("访问Api2");
response = await client.GetAsync("http://localhost:8004/api/values");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(content);
}
}
private static async Task Main()
{
// discover endpoints from metadata
var client = new HttpClient();
var disco = await client.GetDiscoveryDocumentAsync("http://localhost:5000");
if (disco.IsError)
{
Console.WriteLine(disco.Error);
return;
}
#region request token using Client Credentials
Console.WriteLine("--------------request token using Client Credentials--------------");
// request token using Client Credentials
var tokenResponse = await client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "client",
ClientSecret = "secret",
Scope = "api1"
});
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
Console.WriteLine(tokenResponse.Json);
Console.WriteLine("\n\n");
// call api
var apiClient = new HttpClient();
apiClient.SetBearerToken(tokenResponse.AccessToken);
var response = await apiClient.GetAsync("http://localhost:5001/identity");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
#endregion
#region request token using Passwords (alice)
Console.WriteLine("--------------request token using Passwords (alice) --------------");
// request token using Passwords
var tokenResponseAlice = await client.RequestPasswordTokenAsync(new PasswordTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "ro.client",
ClientSecret = "secret",
UserName = "******",
Password = "******",
Scope = "api1"
});
if (tokenResponseAlice.IsError)
{
Console.WriteLine(tokenResponseAlice.Error);
return;
}
Console.WriteLine(tokenResponseAlice.Json);
Console.WriteLine("\n\n");
// call api
var apiClientAlice = new HttpClient();
apiClientAlice.SetBearerToken(tokenResponseAlice.AccessToken);
var responseAlice = await apiClientAlice.GetAsync("http://localhost:5001/identity");
if (!responseAlice.IsSuccessStatusCode)
{
Console.WriteLine(responseAlice.StatusCode);
}
else
{
var content = await responseAlice.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
#endregion
#region request token using Passwords (bob)
Console.WriteLine("--------------request token using Passwords (bob)--------------");
// request token using Passwords
var tokenResponseUsingBob = await client.RequestPasswordTokenAsync(new PasswordTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "ro.client",
ClientSecret = "secret",
UserName = "******",
Password = "******",
Scope = "api1"
});
if (tokenResponseUsingBob.IsError)
{
Console.WriteLine(tokenResponseUsingBob.Error);
return;
}
Console.WriteLine(tokenResponseUsingBob.Json);
Console.WriteLine("\n\n");
// call api
var apiClientBob = new HttpClient();
apiClientBob.SetBearerToken(tokenResponseUsingBob.AccessToken);
var responseBob = await apiClientBob.GetAsync("http://localhost:5001/identity");
if (!responseBob.IsSuccessStatusCode)
{
Console.WriteLine(responseBob.StatusCode);
}
else
{
var content = await responseBob.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
#endregion
}
static async Task Run()
{
await Task.Delay(10000);
// discover endpoints from metadata
var client = new HttpClient();
var disco = await client.GetDiscoveryDocumentAsync("https://localhost:5001");
if (disco.IsError)
{
Console.WriteLine(disco.Error);
return;
}
// request token resource owner flow
var tokenResponse = await client.RequestPasswordTokenAsync(new PasswordTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "ro.client",
ClientSecret = "secret",
UserName = "******",
Password = "******",
Scope = "Chat"
});
// request token client credential flow
//var tokenResponse = await client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
//{
// Address = disco.TokenEndpoint,
// ClientId = "netClient",
// ClientSecret = "secret",
// Scope = "Chat"
//});
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
Console.WriteLine(tokenResponse.Json);
Console.WriteLine("\n\n");
// call api
var apiClient = new HttpClient();
apiClient.SetBearerToken(tokenResponse.AccessToken);
var response = await apiClient.GetAsync("https://localhost:5002/identity");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
var c = new HubConnectionBuilder()
.WithUrl("https://localhost:5002/chat", config => {
config.AccessTokenProvider = () => Task.FromResult(tokenResponse.AccessToken);
})
.Build();
c.Closed += C_Closed;
c.On <string>("Echo", m => Console.WriteLine(m));
await c.StartAsync();
try
{
await c.SendAsync("Echo", "Hallo Echo");
var e = await c.InvokeAsync <string>("Echo2", "Hallo Echo2");
Console.WriteLine(e);
}
catch (Exception e)
{
throw;
}
await Task.Delay(5000);
await c.StopAsync();
}
private static async Task MainAsync()
{
// discover endpoints from metadata
var client = new HttpClient();
var disco = await client.GetDiscoveryDocumentAsync("http://localhost:5000");
if (disco.IsError)
{
Console.WriteLine(disco.Error);
return;
}
// request token（ClientCredentials）
//var tokenResponse = await client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
//{
// Address = disco.TokenEndpoint,
// ClientId = "client",
// ClientSecret = "secret",
// Scope = "api1"
//});
// request token（ResourceOwnerPassword）
var tokenResponse = await client.RequestPasswordTokenAsync(new PasswordTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "ro.client",
ClientSecret = "secret",
UserName = "******",
Password = "******",
Scope = "api1"
});
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
Console.WriteLine(tokenResponse.Json);
Console.WriteLine("\n\n");
// call api
var apiClient = new HttpClient();
apiClient.SetBearerToken(tokenResponse.AccessToken);
var response = await apiClient.GetAsync("http://localhost:5001/api/identity");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
Console.ReadKey();
}
public static async Task MainAsync(string[] args)
{
// discover endpoints from metadata
var client = new HttpClient();
var disco = await client.GetDiscoveryDocumentAsync("http://localhost:5000");
if (disco.IsError)
{
Console.WriteLine("------------Token Error---------------------");
Console.WriteLine(disco.Error);
return;
}
// request token
//var tokenResponse = await client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
//{
// Address = disco.TokenEndpoint,
// ClientId = "client",
// ClientSecret = "secret",
// Scope = "api1"
//});
// request token
var tokenResponse = await client.RequestPasswordTokenAsync(new PasswordTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "ro.client",
ClientSecret = "secret",
UserName = "******",
Password = "******",
Scope = "api1"
});
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
Console.WriteLine("------------Token Response---------------------");
Console.WriteLine(tokenResponse.Json);
Console.WriteLine("\n\n");
// call api
var apiClient = new HttpClient();
apiClient.SetBearerToken(tokenResponse.AccessToken);
var response = await apiClient.GetAsync("http://localhost:5001/api/items");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine("------------Items api error---------------------");
var error = await response.Content.ReadAsStringAsync();
Console.WriteLine(response.StatusCode);
Console.WriteLine(error);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine("------------Items api response----------------------");
Console.WriteLine(JObject.Parse(content));
}
var stringContent = new StringContent("", UnicodeEncoding.UTF8, "application/json");
var responseBuy = await apiClient.PostAsync("http://localhost:5001/api/items/5/buy", stringContent);
if (!responseBuy.IsSuccessStatusCode)
{
var error = await responseBuy.Content.ReadAsStringAsync();
Console.WriteLine("------------Buy api error---------------------");
Console.WriteLine(responseBuy.StatusCode);
Console.WriteLine(error);
}
else
{
var content = await responseBuy.Content.ReadAsStringAsync();
Console.WriteLine("------------Buy api response---------------------");
Console.WriteLine(JObject.Parse(content));
}
}
private static async Task MainAsync()
{
Console.WriteLine("ClientCredentials模式演示");
// discover endpoints from metadata
var disco = await DiscoveryClient.GetAsync("https://localhost:5001");
// request token
var tokenClient = new TokenClient(disco.TokenEndpoint, "client", "secret");
var tokenResponse = await tokenClient.RequestClientCredentialsAsync("api1");
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
Console.WriteLine(tokenResponse.Json);
Console.WriteLine("\n\n");
// call api
var client = new HttpClient();
client.SetBearerToken(tokenResponse.AccessToken);
var response = await client.GetAsync("https://localhost:5003/identity");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
//使用ResourceOwnerPassword模式获取授权
Console.WriteLine("ResourceOwnerPassword模式演示");
// discover endpoints from metadata
//var disco = await DiscoveryClient.GetAsync("https://localhost:5001");
// request token
tokenClient = new TokenClient(disco.TokenEndpoint, "ro.client", "secret");
tokenResponse = await tokenClient.RequestResourceOwnerPasswordAsync("bob", "Pass123$", "api1");//使用用户名密码
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
Console.WriteLine(tokenResponse.Json);
Console.WriteLine("\n\n");
// call api
client = new HttpClient();
client.SetBearerToken(tokenResponse.AccessToken);
response = await client.GetAsync("https://localhost:5003/identity");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
}
static async Task Main(string[] args)
{
var client = new HttpClient();
var discoveryResponse = await client.GetDiscoveryDocumentAsync("https://localhost:5001");
if (discoveryResponse.IsError)
{
Console.WriteLine(discoveryResponse.Error);
return;
}
await ROpasswordAndClientCredentialsExample(client, discoveryResponse);
var resourceOwnerPasswordResponse = await client.RequestPasswordTokenAsync(new PasswordTokenRequest
{
Address = discoveryResponse.TokenEndpoint,
ClientId = "ResourceOwnerPassword",
ClientSecret = "secret",
GrantType = "password",
UserName = "******",
Password = "******",
Scope = "profile"
});
var tokenResponse = await client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
{
Address = discoveryResponse.TokenEndpoint,
ClientId = "client",
ClientSecret = "secret",
Scope = "api1"
});
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
Console.WriteLine(tokenResponse.Json);
var validatedToken = Validate(tokenResponse.AccessToken);
var apiClient = new HttpClient();
apiClient.SetBearerToken(tokenResponse.AccessToken);
var response = await apiClient.GetAsync("http://localhost:6001/identity");
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(JArray.Parse(content));
}
}
static void Main(string[] args)
{
// discover endpoints from metadata
var disco = DiscoveryClient.GetAsync("http://localhost:5000").Result;
if (disco.IsError)
{
Console.WriteLine(disco.Error);
return;
}
// request token
//var tokenClient = new TokenClient(disco.TokenEndpoint, "client", "secret");
//var tokenResponse = tokenClient.RequestClientCredentialsAsync("api1").Result;
//if (tokenResponse.IsError)
//{
// Console.WriteLine(tokenResponse.Error);
// return;
//}
//Console.WriteLine(tokenResponse.Json);
// request token ROP
var tokenClient = new TokenClient(disco.TokenEndpoint, "ro.client", "secret");
var tokenResponse = tokenClient.RequestResourceOwnerPasswordAsync("alice", "password1", "api1").Result;
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
Console.WriteLine(tokenResponse.Json);
Console.WriteLine("\n\n");
// call api
var client = new HttpClient();
client.SetBearerToken(tokenResponse.AccessToken);
var response = client.GetAsync("http://localhost:5001/api/identity").Result;
if (!response.IsSuccessStatusCode)
{
Console.WriteLine(response.StatusCode);
}
else
{
var content = response.Content.ReadAsStringAsync().Result;
Console.WriteLine(JArray.Parse(content));
}
Console.ReadKey();
}
