public override void Execute(IRequest request, IResponse response, object requestDto)
{
try
{
var cryptoKeyProvider = ServiceStackHost.Instance.Container.Resolve <ICryptoKeyProvider>();
ICryptoKeyPair authZServerKeys = cryptoKeyProvider.GetCryptoKey(CryptoKeyType.AuthZServer);
ICryptoKeyPair apiServiceKeys = cryptoKeyProvider.GetCryptoKey(CryptoKeyType.ApiService);
var tokenAnalyzer = new StandardAccessTokenAnalyzer(authZServerKeys.PublicSigningKey,
apiServiceKeys.PrivateEncryptionKey);
var resourceServer = new ResourceServer(tokenAnalyzer);
// Verify the signed bearer token (for specified scopes), and extract the user's identity
AccessToken token = resourceServer.GetAccessToken((HttpRequestBase)request.OriginalRequest, scopes);
// Assign this user to the current HTTP context
var user = new OAuthPrincipal(token.User, GetUserRoles(token));
((HttpRequestBase)request.OriginalRequest).RequestContext.HttpContext.User = user;
}
catch (ProtocolFaultResponseException ex)
{
//TODO: if the token is invalid in some way (i.e. malformed) then return 400-BadRequest.
// The token is either: expired or invalid or revoked, we need to return 401-Unauthorized
response.AddHeader(HttpHeaders.WwwAuthenticate, @"Bearer");
throw HttpErrorThrower.Unauthorized(ex.Message);
}
}
protected override Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
if (request.Headers.Authorization != null)
{
if (request.Headers.Authorization.Scheme == "Bearer")
{
//If there are authorization headers that use the Bearer token scheme, try to digest the token and, if available,
//set the current user context.
try
{
var AuthServerPublicKey = (RSACryptoServiceProvider)AuthorizationServerHost.AuthorizationServerCertificate.PublicKey.Key;
var ResourceServerPrivateKey = (RSACryptoServiceProvider)AuthorizationServerHost.ResourceServerCertificate.PrivateKey;
var resourceServer = new ResourceServer(new StandardAccessTokenAnalyzer(AuthServerPublicKey, ResourceServerPrivateKey));
var principal = resourceServer.GetPrincipal(request);
HttpContext.Current.User = principal;
Thread.CurrentPrincipal = principal;
}
catch (ProtocolFaultResponseException ex)
{
//A protocol fault response exception is thrown in the case that a client cannot be properly authenticated by the provided
//token. To diagnose any errors you may be getting, you can re-throw or log ex.ErrorResponseMessage.
//For now, let's just inform the client that they're unauthorized for this resource.
SendUnauthorizedResponse();
}
}
}
else
{
//This API does not allow unauthenticated access, return an unauthorized status code.
SendUnauthorizedResponse();
}
return(base.SendAsync(request, cancellationToken));
}
public OAuthServiceCall(HttpRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
OriginalRequest = request;
ServiceCall = ServiceFromString(request.PathInfo);
ResponseCallback = util.GetStringParam(request, "callback");
ResultFormat = (util.GetIntParam(request, "json", 0) != 0) ? (String.IsNullOrEmpty(ResponseCallback) ? OutputFormat.JSON : OutputFormat.JSONP) : OutputFormat.XML;
using (RSACryptoServiceProvider rsaSigning = new RSACryptoServiceProvider())
{
using (RSACryptoServiceProvider rsaEncryption = new RSACryptoServiceProvider())
{
rsaSigning.ImportParameters(OAuth2AuthorizationServer.AuthorizationServerSigningPublicKey);
rsaEncryption.ImportParameters(OAuth2AuthorizationServer.CreateAuthorizationServerSigningKey());
ResourceServer server = new ResourceServer(new StandardAccessTokenAnalyzer(rsaSigning, rsaEncryption));
Token = server.GetAccessToken();
if (Token.Lifetime.HasValue && Token.UtcIssued.Add(Token.Lifetime.Value).CompareTo(DateTime.UtcNow) < 0)
{
throw new MyFlightbookException("oAuth2 - Token has expired!");
}
if (String.IsNullOrEmpty(Token.User))
{
throw new MyFlightbookException("Invalid oAuth token - no user");
}
GeneratedAuthToken = MFBWebService.AuthTokenFromOAuthToken(Token);
}
}
}
public void TestResourceServer()
{
m_noAdmitCount = 0;
m_admitCount = 0;
m_model = new Model();
((Model)m_model).RandomServer = new Randoms.RandomServer(54321, 100);
ItemSource factory = CreatePatientGenerator("Patient_", 25, 5.0, 3.0);
Queue queue = new Queue(m_model, "TestQueue", Guid.NewGuid());
ConnectorFactory.Connect(factory.Output, queue.Input);
NormalDistribution dist = new NormalDistribution(m_model, "SvcDistribution", Guid.NewGuid(), 15.0, 3.0);
IPeriodicity per = new Periodicity(dist, Periodicity.Units.Minutes);
ResourceManager rscPool = new ResourceManager(m_model, "RscMgr", Guid.NewGuid());
for (int i = 0; i < 3; i++)
{
rscPool.Add(new Resource(m_model, "rsc_" + i, Guid.NewGuid(), 1.0, 1.0, true, true, true));
}
ResourceServer rs = new ResourceServer(m_model, "RscSvr", Guid.NewGuid(), per, new IResourceRequest[] { new SimpleResourceRequest(1.0, rscPool) });
rs.PlaceInService();
ConnectorFactory.Connect(queue.Output, rs.Input);
factory.Output.PortDataPresented += new PortDataEvent(FactoryOutput_PortDataPresented);
queue.LevelChangedEvent += new QueueLevelChangeEvent(Queue_LevelChangedEvent);
rs.ServiceBeginning += new ServiceEvent(Server_ServiceBeginning);
rs.ServiceCompleted += new ServiceEvent(Server_ServiceCompleted);
m_model.Start();
}
/// <summary>
/// Handles the AuthenticateRequest event of the HttpApplication.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
private void context_AuthenticateRequest(object sender, EventArgs e)
{
// Don't read OAuth messages directed at the OAuth controller or else we'll fail nonce checks.
if (this.IsOAuthControllerRequest())
{
return;
}
using (var crypto = OAuthResourceServer.CreateRSA()) {
var tokenAnalyzer = new SpecialAccessTokenAnalyzer(crypto, crypto);
var resourceServer = new ResourceServer(tokenAnalyzer);
var context = this.application.Context;
Task.Run(
async delegate {
ProtocolFaultResponseException exception = null;
try {
IPrincipal principal = await resourceServer.GetPrincipalAsync(new HttpRequestWrapper(context.Request));
context.User = principal;
return;
} catch (ProtocolFaultResponseException ex) {
exception = ex;
}
var errorResponse = await exception.CreateErrorResponseAsync(CancellationToken.None);
await errorResponse.SendAsync();
}).Wait();
}
}
private static async Task <IPrincipal> VerifyOAuth2(HttpRequestMessage httpDetails, params string[] requiredScopes)
{
// for this sample where the auth server and resource server are the same site,
// we use the same public/private key.
var resourceServer = new ResourceServer(new StandardAccessTokenAnalyzer((RSACryptoServiceProvider)Common.Configuration.SigningCertificate.PublicKey.Key, (RSACryptoServiceProvider)Common.Configuration.EncryptionCertificate.PrivateKey));
return(await resourceServer.GetPrincipalAsync(httpDetails, requiredScopes : requiredScopes));
}
public void TestResourceServerComplexDemands()
{
m_noAdmitCount = 0;
m_admitCount = 0;
m_model = new Model();
((Model)m_model).RandomServer = new Randoms.RandomServer(54321, 100);
ItemSource factory = CreatePatientGenerator("Patient_", 50, 5.0, 3.0);
Queue queue = new Queue(m_model, "TestQueue", Guid.NewGuid());
ConnectorFactory.Connect(factory.Output, queue.Input);
NormalDistribution dist = new NormalDistribution(m_model, "SvcDistribution", Guid.NewGuid(), 240.0, 45.0);
IPeriodicity per = new Periodicity(dist, Periodicity.Units.Minutes);
SelfManagingResource nursing = new SelfManagingResource(m_model, "Nursing", Guid.NewGuid(), 7.0, 7.0, false, false, true);
SelfManagingResource clerks = new SelfManagingResource(m_model, "Clerks", Guid.NewGuid(), 6.0, 6.0, false, false, true);
SelfManagingResource doctors = new SelfManagingResource(m_model, "Doctors", Guid.NewGuid(), 2.0, 2.0, false, false, true);
MultiResourceTracker mrt = new MultiResourceTracker(m_model);
mrt.Filter = ResourceEventRecordFilters.AcquireAndReleaseOnly;
//mrt.Filter = ResourceTracker.Filters.AllEvents;
mrt.AddTargets(nursing, clerks, doctors);
IResourceRequest[] demands = new IResourceRequest[] {
new SimpleResourceRequest(.20, nursing),
new SimpleResourceRequest(.15, clerks),
new SimpleResourceRequest(.05, doctors)
};
ResourceServer rs = new ResourceServer(m_model, "RscSvr", Guid.NewGuid(), per, demands);
rs.PlaceInService();
ConnectorFactory.Connect(queue.Output, rs.Input);
factory.Output.PortDataPresented += new PortDataEvent(FactoryOutput_PortDataPresented);
queue.LevelChangedEvent += new QueueLevelChangeEvent(Queue_LevelChangedEvent);
rs.ServiceBeginning += new ServiceEvent(Server_ServiceBeginning);
rs.ServiceCompleted += new ServiceEvent(Server_ServiceCompleted);
m_model.Start();
// string dataFileName = Highpoint.Sage.Utility.DirectoryOperations.GetAppDataDir() + @"Data.csv";
// System.IO.TextWriter tw = new System.IO.StreamWriter(dataFileName);
// foreach ( ResourceEventRecord rer in mrt ) {
// tw.WriteLine(rer.When.ToLongTimeString()+","
// +rer.Resource.Name+","
// +rer.Action.ToString()+","
// +rer.Available );
// }
// tw.Close();
// System.Diagnostics.Process.Start("excel.exe","\""+dataFileName+"\"");
Console.WriteLine(new CSVDumper(mrt, new CompoundComparer(ResourceEventRecord.ByAction(false), ResourceEventRecord.ByTime(false))).ToString());
}
protected override bool CheckAccessCore(OperationContext operationContext)
{
if (!base.CheckAccessCore(operationContext))
{
return(false);
}
var httpDetails = operationContext.RequestContext.RequestMessage.Properties[HttpRequestMessageProperty.Name] as HttpRequestMessageProperty;
var requestUri = operationContext.RequestContext.RequestMessage.Properties.Via;
return(Task.Run(
async delegate {
using (var crypto = OAuthResourceServer.CreateRSA()) {
var tokenAnalyzer = new SpecialAccessTokenAnalyzer(crypto, crypto);
var resourceServer = new ResourceServer(tokenAnalyzer);
ProtocolFaultResponseException exception = null;
try {
IPrincipal principal =
await resourceServer.GetPrincipalAsync(httpDetails, requestUri, CancellationToken.None, operationContext.IncomingMessageHeaders.Action);
var policy = new OAuthPrincipalAuthorizationPolicy(principal);
var policies = new List <IAuthorizationPolicy> {
policy,
};
var securityContext = new ServiceSecurityContext(policies.AsReadOnly());
if (operationContext.IncomingMessageProperties.Security != null)
{
operationContext.IncomingMessageProperties.Security.ServiceSecurityContext = securityContext;
}
else
{
operationContext.IncomingMessageProperties.Security = new SecurityMessageProperty {
ServiceSecurityContext = securityContext,
};
}
securityContext.AuthorizationContext.Properties["Identities"] = new List <IIdentity> {
principal.Identity,
};
return true;
} catch (ProtocolFaultResponseException ex) {
// Return the appropriate unauthorized response to the client.
exception = ex;
} catch (DotNetOpenAuth.Messaging.ProtocolException /* ex*/) {
////Logger.Error("Error processing OAuth messages.", ex);
}
var errorResponse = await exception.CreateErrorResponseAsync(CancellationToken.None);
await errorResponse.SendAsync();
}
return false;
}).Result);
}
public void GetPrincipalWithMissingAccessToken()
{
var resourceServer = new ResourceServer(new StandardAccessTokenAnalyzer(AsymmetricKey, null));
var requestHeaders = new NameValueCollection {
{ "Authorization", "Bearer " },
};
var request = new HttpRequestInfo("GET", new Uri("http://localhost/resource"), headers: requestHeaders);
Assert.That(() => resourceServer.GetPrincipal(request), Throws.InstanceOf <ProtocolException>());
}
private static async Task <IPrincipal> VerifyOAuth2Async(HttpRequestMessageProperty httpDetails, Uri requestUri, params string[] requiredScopes)
{
// for this sample where the auth server and resource server are the same site,
// we use the same public/private key.
using (var signing = Global.CreateAuthorizationServerSigningServiceProvider()) {
using (var encrypting = Global.CreateResourceServerEncryptionServiceProvider()) {
var resourceServer = new ResourceServer(new StandardAccessTokenAnalyzer(signing, encrypting));
return(await resourceServer.GetPrincipalAsync(httpDetails, requestUri, requiredScopes : requiredScopes));
}
}
}
public void GetAccessTokenWithTotallyFakeToken()
{
var resourceServer = new ResourceServer(new StandardAccessTokenAnalyzer(AsymmetricKey, null));
var requestHeaders = new NameValueCollection {
{ "Authorization", "Bearer foobar" },
};
var request = new HttpRequestInfo("GET", new Uri("http://localhost/resource"), headers: requestHeaders);
Assert.That(() => resourceServer.GetAccessTokenAsync(request).GetAwaiter().GetResult(), Throws.InstanceOf <ProtocolException>());
}
/// <summary>
/// OAuth resource provider.
/// </summary>
/// <param name="tokenStore">The token store</param>
/// <param name="consumerStore">The consumer store</param>
/// <param name="nonceStore">The nonce store.</param>
public AuthResource(ITokenStore tokenStore, IConsumerStore consumerStore, INonceStore nonceStore)
{
_tokenStore = tokenStore;
_consumerStore = consumerStore;
_nonceStore = nonceStore;
ValidateEx();
// Create the resource provider.
_resourceServer = new ResourceServer();
}
/// <summary>
/// Parses out server name from a resource server. Uses the Resource server Name unless it's a database server with a port number
/// </summary>
public static string GetServerNameForIpAddress(ResourceServer server)
{
var result = server.Name;
// if it's a DB server than anything after the last comma (,) should be the port number
var lastCommaIndex = result.LastIndexOf(',');
result = (lastCommaIndex > 0 && server.ServerType == ServerType.Database) ? result.Substring(0, lastCommaIndex) : result;
if (server.ServerType == ServerType.Database && result.Contains('\\'))
{
result = result.Split('\\')[0];
}
return(result);
}
public async Task GetAccessTokenWithCorruptedToken()
{
var accessToken = await this.ObtainValidAccessTokenAsync();
var resourceServer = new ResourceServer(new StandardAccessTokenAnalyzer(AsymmetricKey, null));
var requestHeaders = new NameValueCollection {
{ "Authorization", "Bearer " + accessToken.Substring(0, accessToken.Length - 1) + "zzz" },
};
var request = new HttpRequestInfo("GET", new Uri("http://localhost/resource"), headers: requestHeaders);
Assert.That(() => resourceServer.GetAccessTokenAsync(request).GetAwaiter().GetResult(), Throws.InstanceOf <ProtocolException>());
}
public async Task GetAccessTokenWithValidToken()
{
var accessToken = await this.ObtainValidAccessTokenAsync();
var resourceServer = new ResourceServer(new StandardAccessTokenAnalyzer(AsymmetricKey, null));
var requestHeaders = new NameValueCollection {
{ "Authorization", "Bearer " + accessToken },
};
var request = new HttpRequestInfo("GET", new Uri("http://localhost/resource"), headers: requestHeaders);
var resourceServerDecodedToken = await resourceServer.GetAccessTokenAsync(request);
Assert.That(resourceServerDecodedToken, Is.Not.Null);
}
protected override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
if (request.Headers.Authorization != null)
{
if (request.Headers.Authorization.Scheme == "Bearer")
{
var resourceServer = new ResourceServer(new StandardAccessTokenAnalyzer(AuthorizationServerHost.HardCodedCryptoKeyStore));
var principal = await resourceServer.GetPrincipalAsync(request, cancellationToken);
HttpContext.Current.User = principal;
Thread.CurrentPrincipal = principal;
}
}
return(await base.SendAsync(request, cancellationToken));
}
public override void OnAuthorization(HttpActionContext actionContext)
{
try
{
var tokenAnalyzer =
new StandardAccessTokenAnalyzer(
AuthServer.PublicSigningKey,
DataServer.PrivateEncryptionKey);
var oauth2ResourceServer = new ResourceServer(tokenAnalyzer);
((ApiController)actionContext.ControllerContext.Controller).User =
oauth2ResourceServer.GetPrincipal(actionContext.Request.GetRequestBase(), _oauth2Scopes) as PlayerPrincipal;
}
catch (ProtocolFaultResponseException ex)
{
HandleUnauthorizedRequest(actionContext, ex);
}
}
protected override bool AuthorizeCore(HttpContextBase httpContext)
{
var rsa = new RSACryptoServiceProvider();
rsa.ImportCspBlob(Convert.FromBase64String(ConfigurationManager.AppSettings["PrivateAsymmetricKey"]));
var analyzer = new StandardAccessTokenAnalyzer(rsa, rsa);
var resourceServer = new ResourceServer(analyzer);
try {
httpContext.User = resourceServer.GetPrincipal(
httpContext.Request, this.Roles.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries));
} catch (ProtocolException) {
httpContext.User = null;
}
return(httpContext.User != null);
}
public override void Execute(IHttpRequest request, IHttpResponse response, object requestDto)
{
try
{
var authServerKeys = AppHostBase.Instance.Container.ResolveNamed <ICryptoKeyPair>("authServer");
var dataServerKeys = AppHostBase.Instance.Container.ResolveNamed <ICryptoKeyPair>("dataServer");
var tokenAnalyzer = new StandardAccessTokenAnalyzer(authServerKeys.PublicSigningKey,
dataServerKeys.PrivateEncryptionKey);
var oauth2ResourceServer = new ResourceServer(tokenAnalyzer);
var wrappedRequest = new HttpRequestWrapper((HttpRequest)request.OriginalRequest);
HttpContext.Current.User = oauth2ResourceServer.GetPrincipal(wrappedRequest, oauth2Scopes) as PlayerPrincipal;
}
catch (ProtocolFaultResponseException x)
{
HandleOAuth2Exception(request, response, x);
}
}
protected override bool AuthorizeCore(HttpContextBase httpContext)
{
bool isAuthorized = false;
try
{
HttpRequestBase request = httpContext.Request;
if (!string.IsNullOrEmpty(request.Headers["Authorization"]))
{
if (request.Headers["Authorization"].StartsWith("Bearer "))
{
RSACryptoServiceProvider authorizationServerSigningPublicKey = AuthorizationServerHost.CreateRsaCryptoServiceProvider(AuthorizationServerHost.AuthorizationServerSigningPublicKey);
RSACryptoServiceProvider resourceServerEncryptionPrivateKey = AuthorizationServerHost.CreateRsaCryptoServiceProvider(AuthorizationServerHost.ResourceServerEncryptionPrivateKey);
StandardAccessTokenAnalyzer tokenAnalyzer = new StandardAccessTokenAnalyzer(authorizationServerSigningPublicKey, resourceServerEncryptionPrivateKey);
ResourceServer resourceServer = new ResourceServer(tokenAnalyzer);
IPrincipal principal = resourceServer.GetPrincipal(request);
if (principal.Identity.IsAuthenticated)
{
HttpContext.Current.User = principal;
Thread.CurrentPrincipal = principal;
isAuthorized = true;
}
var _token = resourceServer.GetAccessToken(request);
if (this.RequiredScopes.Any())
{
var token = resourceServer.GetAccessToken(request, this.RequiredScopes);
}
}
}
}
catch
{
isAuthorized = false;
}
return(isAuthorized);
}
public static string FileDownURL(IFile file)
{
if (file is Attachment)
{
file = file as Attachment;
}
else if (file is IESFile)
{
file = file as IESFile;
}
else if (file is IES.Resource.Model.File)
{
file = file as IES.Resource.Model.File;
}
ResourceServer server = StoreServie.ResourceServer_Get(file.ServerID);
return(string.Format(downurl, server.Host, server.IISPort, server.IISFolder, file.FileName));
}
/// <summary>
/// Handles the AuthenticateRequest event of the HttpApplication.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
private void context_AuthenticateRequest(object sender, EventArgs e)
{
// Don't read OAuth messages directed at the OAuth controller or else we'll fail nonce checks.
if (this.IsOAuthControllerRequest())
{
return;
}
using (var crypto = OAuthResourceServer.CreateRSA()) {
var tokenAnalyzer = new SpecialAccessTokenAnalyzer(crypto, crypto);
var resourceServer = new ResourceServer(tokenAnalyzer);
try {
IPrincipal principal = resourceServer.GetPrincipal(new HttpRequestWrapper(this.application.Context.Request));
this.application.Context.User = principal;
} catch (ProtocolFaultResponseException ex) {
ex.CreateErrorResponse().Send();
}
}
}
/// <summary>
/// 文件在线浏览地址 ：TODO
/// </summary>
/// <param name="file"></param>
/// <returns></returns>
public static string FileViewURL(IFile file)
{
if (file is Attachment)
{
file = file as Attachment;
}
else if (file is IESFile)
{
file = file as IESFile;
}
else if (file is IES.Resource.Model.File)
{
file = file as IES.Resource.Model.File;
}
string ext = StringHelp.GetFileNameExt(file.FileName).ToLower();
ResourceServer server = StoreServie.ResourceServer_Get(file.ServerID);
return(string.Format(downurl, server.Host, server.NginxPort, server.NginxFolder, file.FileName));
}
public async Task InitializeAsync()
{
var token = await GenerateManagementApiToken();
_apiClient = new ManagementApiClient(token, GetVariable("AUTH0_MANAGEMENT_API_URL"));
// We need a client in order to create client grants
_client = await _apiClient.Clients.CreateAsync(new ClientCreateRequest
{
Name = $"Integration testing {Guid.NewGuid():N}"
});
// We also need to create a resource server
var identifier = Guid.NewGuid();
_resourceServer = await _apiClient.ResourceServers.CreateAsync(new ResourceServerCreateRequest
{
Identifier = "urn:" + identifier,
Name = $"Integration testing {identifier:N}",
TokenLifetime = 1,
SigningAlgorithm = SigningAlgorithm.RS256,
Scopes = new List <ResourceServerScope>
{
new ResourceServerScope
{
Value = "scope1",
Description = "Scope number 1"
},
new ResourceServerScope
{
Value = "scope2",
Description = "Scope number 2"
},
new ResourceServerScope
{
Value = "scope3",
Description = "Scope number 3"
}
}
});
}
public async Task CreatePerformanceDashboardAgents_FreshSuccess()
{
// Arrange
var machineName = "TestServer";
var agentServer = new ResourceServer {
Name = machineName, ArtifactID = 123
};
var servers = new List <ResourceServer> {
agentServer
};
this.agentManagerMock.Setup(m => m.GetAgentServersAsync()).ReturnsAsync(servers);
this.agentRepositoryMock.Setup(m =>
m.ReadAgentWithTypeExists(It.Is <Guid>(g => Guids.Agent.CurrentAgentGuids.Contains(g)))).ReturnsAsync(false);
var agentTypeId = 1234;
var agentTypeRefs =
Guids.Agent.CurrentAgentGuids.Select(cg => new AgentTypeRef(new List <Guid> {
cg
})
{
ArtifactID = agentTypeId
}).ToList();
this.agentManagerMock.Setup(m => m.GetAgentTypesAsync()).ReturnsAsync(agentTypeRefs);
this.agentManagerMock.Setup(m =>
m.CreateSingleAsync(It.Is <Agent>(a => a.Server.ArtifactID == agentServer.ArtifactID))).ReturnsAsync(1);
// Act
var result = await this.agentManagerService.CreatePerformanceDashboardAgents(machineName);
// Assert
Assert.That(result.Count, Is.EqualTo(Guids.Agent.CurrentAgentGuids.Count));
this.agentManagerMock.VerifyAll();
this.agentRepositoryMock.VerifyAll();
}
public static bool AuthUser(HttpRequestMessage request)
{
using (RSACryptoServiceProvider authorizationServerRsa = GetAuthorizationServerRsa())
{
using (RSACryptoServiceProvider resourceServerRsa = GetResourceServerRsa())
{
ResourceServer resourceServer = new ResourceServer(new StandardAccessTokenAnalyzer(authorizationServerRsa, resourceServerRsa));
var token = resourceServer.GetAccessToken(request, new string[0]);
if (token != null)
{
IPrincipal principal = CreatePrincipal(token.User);
HttpContext.Current.User = principal;
Thread.CurrentPrincipal = principal;
request.Headers.Add("UserName", token.User);
return(true);
}
else
{
return(false);
}
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="OAuthAuthorizeAttribute"/> class.
/// </summary>
public OAuthAuthorizeAttribute()
{
var standardAccessTokenAnalyzer = new StandardAccessTokenAnalyzer(EncryptionKeys.GetAuthorizationServerSigningPublicKey(), EncryptionKeys.GetResourceServerEncryptionPrivateKey());
this.resourceServer = new ResourceServer(standardAccessTokenAnalyzer);
}
private static async Task <IPrincipal> VerifyOAuth2Async(HttpRequestMessageProperty httpDetails, Uri requestUri, params string[] requiredScopes)
{
var resourceServer = new ResourceServer(new StandardAccessTokenAnalyzer((RSACryptoServiceProvider)Common.Configuration.SigningCertificate.PublicKey.Key, (RSACryptoServiceProvider)Common.Configuration.EncryptionCertificate.PrivateKey));
return(await resourceServer.GetPrincipalAsync(httpDetails, requestUri, requiredScopes : requiredScopes));
}
/// <summary>
/// Repeatable part of the program setup. Note that the threads and database must first be disposed or null.
/// </summary>
static void Setup()
{
// Dispose existing database connections
Utils.DisposeDatabases();
#region Apply AppSettings
dynamic appSettings = Config["appSettings"];
// Create log files in release mode only
if (!DEBUG)
{
Log.Config("Creating log file");
string log = appSettings.logDir;
// Create the directory if it doesn't exist
try
{
if (!Directory.Exists(log))
{
Directory.CreateDirectory(log);
}
}
catch (Exception e)
{
Log.Fatal($"{e.GetType().Name}: {e.Message}", e, false);
Terminate(14001);
}
log += "/latest.log";
// Delete the file if it already exists
if (File.Exists(log))
{
File.Delete(log);
}
Log.OutputStreams.Add(File.CreateText(log));
}
#endregion
Log.Config("Creating database connection...");
Database = Utils.GetDatabase();
try
{
// Compile razor .cshtml templates
Templates.CompileAll();
}
catch (Exception e)
{
// Print any error and terminate
Log.Fatal("Template compilation failed:");
Log.Fatal($"{e.GetType().Name}: {e.Message}", e);
Terminate(1);
}
#region Setup Threads
dynamic performance = Config["performance"];
for (int i = 0; i < (int)performance.apiThreads; i++)
{
var server = new JsonServer(JSONQueue);
Servers.Add(server);
server.Start();
}
for (int i = 0; i < (int)performance.htmlThreads; i++)
{
var server = new HTMLServer(listener.Queue);
Servers.Add(server);
server.Start();
}
for (int i = 0; i < (int)performance.resourceThreads; i++)
{
var server = new ResourceServer(ResourceQueue);
Servers.Add(server);
server.Start();
}
#endregion
}
public OAuth2Handler(ResourceServer resourceServer)
{
m_ResourceServer = resourceServer;
}
