예제 #1
0
        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddMvc(options =>
            {
                //This prevents ASP Core from trying to validate Vector3's children, which contain Vector3 (because Unity3D thanks)
                //so it will cause stack overflows. This will avoid it.
                options.ModelMetadataDetailsProviders.Add(new SuppressChildValidationMetadataProvider(typeof(Vector3)));
            })
            .RegisterHealthCheckController();

            RegisterDatabaseServices(services);

            X509Certificate2 cert     = null;
            string           certPath = "Certs/TestCert.pfx";

            try
            {
                cert = X509Certificate2Loader.Create(certPath).Load();
            }
            catch (Exception e)
            {
                throw new System.InvalidOperationException($"Failed to load {nameof(X509Certificate2)} from Path: {certPath} \n\n StackTrace: {e.StackTrace}", e);
            }

            services.AddResponseCaching();
            services.AddLogging();

            //This provides JwtBearer support for Authorize attribute/header
            services.AddJwtAuthorization(cert);

            //Adds and registers S3 service for URLBuilding and communication/credentials and etc
            services.AddS3Service(Configuration);
            services.AddTransient <IWorldEntryRepository, DatabaseBackedWorldEntryRepository>();
            services.AddTransient <IAvatarEntryRepository, DatabaseBackedAvatarEntryRepository>();
            services.AddTransient <IContentDownloadAuthroizationValidator, UnimplementedContentDownloadAuthorizationValidator>();
        }
예제 #2
0
        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddMvc(options =>
            {
                //This prevents ASP Core from trying to validate Vector3's children, which contain Vector3 (because Unity3D thanks)
                //so it will cause stack overflows. This will avoid it.
                options.ModelMetadataDetailsProviders.Add(new SuppressChildValidationMetadataProvider(typeof(Vector3)));
            })
            .RegisterHealthCheckController();

            RegisterDatabaseServices(services);

            X509Certificate2 cert     = null;
            string           certPath = "Certs/TestCert.pfx";

            try
            {
                cert = X509Certificate2Loader.Create(certPath).Load();
            }
            catch (Exception e)
            {
                throw new System.InvalidOperationException($"Failed to load {nameof(X509Certificate2)} from Path: {certPath} \n\n StackTrace: {e.StackTrace}", e);
            }

            services.AddResponseCaching();
            services.AddLogging();

            //This provides JwtBearer support for Authorize attribute/header
            services.AddJwtAuthorization(cert);

            services.AddSingleton <IZoneInstanceWorkQueue, LocalInMemoryZoneInstanceWorkQueue>(provider =>
            {
                //TODO: This is for testing purposes, we want and have the request to boot up at map 1 as an instance.
                return(new LocalInMemoryZoneInstanceWorkQueue(new ZoneInstanceWorkEntry(1), new ZoneInstanceWorkEntry(1)));
            });
        }
예제 #3
0
        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddMvc(options =>
            {
                //This prevents ASP Core from trying to validate Vector3's children, which contain Vector3 (because Unity3D thanks)
                //so it will cause stack overflows. This will avoid it.
                //options.ModelMetadataDetailsProviders.Add(new SuppressChildValidationMetadataProvider(typeof(Vector3)));
            })
            .RegisterHealthCheckController();

            X509Certificate2 cert     = null;
            string           certPath = "Certs/TestCert.pfx";

            try
            {
                cert = X509Certificate2Loader.Create(certPath).Load();
            }
            catch (Exception e)
            {
                throw new System.InvalidOperationException($"Failed to load {nameof(X509Certificate2)} from Path: {certPath} \n\n StackTrace: {e.StackTrace}", e);
            }

            //This provides JwtBearer support for Authorize attribute/header
            services.AddJwtAuthorization(cert);
            services.AddResponseCaching();

            services.AddSignalR(options => { }).AddJsonProtocol();

            services.AddSingleton <IUserIdProvider, SignalRPlayerCharacterUserIdProvider>();
            services.AddSingleton <IConnectionToZoneMappable, DefaultConnectionToZoneMappable>();

            //Registers service discovery client.
            services.AddSingleton <IServiceDiscoveryService>(provider =>
            {
                return(Refit.RestService.For <IServiceDiscoveryService>("http://sd.vrguardians.net:5000"));
            });

            services.AddSingleton <IAuthenticationService, AsyncEndpointAuthenticationService>(provider =>
            {
                return(new AsyncEndpointAuthenticationService(QueryForRemoteServiceEndpoint(provider.GetService <IServiceDiscoveryService>(), "Authentication")));
            });

            services.AddSingleton <ISocialServiceToGameServiceClient, AsyncEndpointISocialServiceToGameServiceClient>(provider =>
            {
                return(new AsyncEndpointISocialServiceToGameServiceClient(QueryForRemoteServiceEndpoint(provider.GetService <IServiceDiscoveryService>(), "GameServer"),
                                                                          new RefitSettings()
                {
                    AuthorizationHeaderValueGetter = () => GetSocialServiceAuthorizationToken(provider.GetService <IAuthenticationService>())
                }));
            });

            //This is for Hub connection event listeners
            services.AddSingleton <IOnHubConnectionEventListener, CharacterZoneOnHubConnectionEventListener>();
            services.AddSingleton <IOnHubConnectionEventListener, CharacterGuildOnHubConnectionEventListener>();

            services.AddSingleton <ZoneMessageBroadcastMessageHandler, ZoneMessageBroadcastMessageHandler>();
            services.AddSingleton <GuildMessageBroadcastMessageHandler, GuildMessageBroadcastMessageHandler>();

            services.AddSingleton <IFactoryCreatable <GuildChatMessageEventModel, GenericChatMessageContext <GuildChatMessageRequestModel> >, GuildChatMessageEnvelopeFactory>();
            services.AddSingleton <IFactoryCreatable <ZoneChatMessageEventModel, GenericChatMessageContext <ZoneChatMessageRequestModel> >, ZoneChatMessageEnvelopeFactory>();

            services.AddSingleton <IEntityDataLockingService, RefCountedEntityDataLockingService>();
        }
예제 #4
0
		// This method gets called by the runtime. Use this method to add services to the container.
		public void ConfigureServices(IServiceCollection services)
		{
			services.Configure<IISOptions>(options =>
			{
				options.ForwardClientCertificate = false;
				options.AutomaticAuthentication = false;
			});

			// Add framework services.
			services.AddMvc()
				.RegisterHealthCheckController();

			services.AddLogging();
			services.AddOptions();
			services.Configure<AuthenticationServerConfigurationModel>(GeneralConfiguration.GetSection("AuthConfig"));

			//We need to immediately resolve the authserver config options because we need them to regiter openiddict
			IOptions<AuthenticationServerConfigurationModel> authOptions = services.BuildServiceProvider()
				.GetService<IOptions<AuthenticationServerConfigurationModel>>();

			services.AddAuthentication();

			services.AddDbContext<GuardiansAuthenticationDbContext>(options =>
			{
				//TODO: Setup db options

				//On local builds we don't want to use config. We want to default to local
#if !DEBUG_LOCAL && !RELEASE_LOCAL
				options.UseMySql(authOptions.Value.AuthenticationDatabaseString);
#else
				options.UseMySql("Server=72.190.177.214;Database=guardians.auth;Uid=root;Pwd=test;");
#endif
				options.UseOpenIddict<int>();
			});

			//Below is the OpenIddict registration
			//This is the recommended setup from the official Github: https://github.com/openiddict/openiddict-core
			services.AddIdentity<GuardiansApplicationUser, GuardiansApplicationRole>(options =>
				{
					//These disable the ridiculous requirements that the defauly password scheme has
					options.Password.RequireNonAlphanumeric = false;

					//For some reason I can't figure out how to get the JWT middleware to spit out sub claims
					//so we need to map the Identity to expect nameidentifier
					options.ClaimsIdentity.UserIdClaimType = OpenIdConnectConstants.Claims.Subject;
					options.ClaimsIdentity.RoleClaimType = OpenIdConnectConstants.Claims.Role;
					options.ClaimsIdentity.UserNameClaimType = OpenIdConnectConstants.Claims.Name;
				})
				.AddEntityFrameworkStores<GuardiansAuthenticationDbContext>()
				.AddDefaultTokenProviders();

			services.AddOpenIddict<int>(options =>
			{
				// Register the Entity Framework stores.
				options.AddEntityFrameworkCoreStores<GuardiansAuthenticationDbContext>();

				//This will disable the https requirement if we're debugging or not in production/debug mode.
#if DEBUG || DEBUGBUILD
				options.DisableHttpsRequirement();
#endif
				// Register the ASP.NET Core MVC binder used by OpenIddict.
				// Note: if you don't call this method, you won't be able to
				// bind OpenIdConnectRequest or OpenIdConnectResponse parameters.
				options.AddMvcBinders();

				//This controller endpoint/action was specified in the HaloLive documentation: https://github.com/HaloLive/Documentation
				options.EnableTokenEndpoint(authOptions.Value.AuthenticationControllerEndpoint); // Enable the token endpoint (required to use the password flow).
				options.AllowPasswordFlow(); // Allow client applications to use the grant_type=password flow.
				options.AllowRefreshTokenFlow();
				options.UseJsonWebTokens();

#warning Don't deploy this into production; we should use HTTPS. Even if it is behind IIS or HAProxy etc.
				options.DisableHttpsRequirement();

				try
				{
					//Loads the cert from the specified path
					options.AddSigningCertificate(X509Certificate2Loader.Create(Path.Combine(Directory.GetCurrentDirectory(), authOptions.Value.JwtSigningX509Certificate2Path)).Load());
				}
				catch(Exception e)
				{
					throw new InvalidOperationException($"Failed to load cert at Path: {authOptions.Value.JwtSigningX509Certificate2Path} with Root: {Directory.GetCurrentDirectory()}. Error: {e.Message} \n\n Stack: {e.StackTrace}", e);
				}
			});

#warning This is just for the test build, we don't actually want to do this
			services.Configure<IdentityOptions>(options =>
			{
				options.Password.RequireDigit = false;
				options.Password.RequiredLength = 1;
				options.Password.RequireUppercase = false;
				options.Password.RequireLowercase = false;
				options.Password.RequireNonAlphanumeric = false;
			});
		}
        /// <summary>
        /// Configure the server host with the arguments encoded in the <see cref="args"/> mapped to
        /// an options instance of <see cref="DefaultWebHostingArgumentsModel"/>.
        /// </summary>
        /// <param name="builder">The web host builder.</param>
        /// <param name="args">The commandline args.</param>
        /// <returns>The provided <see cref="IWebHostBuilder"/>for fluent chaining.</returns>
        public static IWebHostBuilder ConfigureKestrelHostWithCommandlinArgs(this IWebHostBuilder builder, string[] args)
        {
            Parser.Default.ParseArguments <DefaultWebHostingArgumentsModel>(args)
            .WithParsed(model =>
            {
#if NETCOREAPP2_0
                //If https is enabled then a certifcate should be available for loading.
                builder.UseKestrel(options =>
                {
                    int port = 5000;
                    //Get the port
                    if (model.isCustomUrlDefined)
                    {
                        int.TryParse(model.Url.Split(':').Last(), out port);
                    }

                    //Remov http
                    string ip = model.Url.Replace("http://", "");
                    ip        = ip.Replace("https://", "");
                    if (ip.Contains(':'))
                    {
                        ip = ip.Split(':').First();
                    }

                    options.Listen(new IPEndPoint(IPAddress.Parse(ip), port), listenOptions =>
                    {
                        if (model.isHttpsEnabled)
                        {
                            var httpsConnectionAdapterOptions = new HttpsConnectionAdapterOptions()
                            {
                                //TODO: Do we need this in ASP Core 2.0?
                                //ClientCertificateMode = ClientCertificateMode.AllowCertificate,

                                //TODO: Mono doesn't support Tls1 or Tls2 and we have no way to config this.
                                //Ssl3 is mostly safe and supported by Mono which means it will work in Unity3D now.
                                SslProtocols = System.Security.Authentication.SslProtocols.Tls
                                               | System.Security.Authentication.SslProtocols.Tls11
                                               | System.Security.Authentication.SslProtocols.Tls12,

                                ServerCertificate = X509Certificate2Loader.Create(model.HttpsCertificateName).Load()
                            };

                            listenOptions.UseHttps(httpsConnectionAdapterOptions);
                        }
                    });

                    //We still need this for the purposes for Features addresses
                    //It won't conflict with the above
                    if (model.isCustomUrlDefined)
                    {
                        builder.UseUrls(model.isHttpsEnabled
                                                                ? model.Url
                                        .ToLower()
                                        .Replace(@"http://", @"https://")
                                                                : model.Url);
                    }
                    else
                    {
                        string prefix = model.isHttpsEnabled ? @"https://" : @"http://";
                        builder.UseUrls($@"{prefix}localhost:5000");
                    }
                });
#else
                if (model.isHttpsEnabled)
                {
                    builder.UseKestrel(options =>
                    {
                        options.UseHttps(new HttpsConnectionFilterOptions()
                        {
                            //TODO: Mono doesn't support Tls1 or Tls2 and we have no way to config this.
                            //Ssl3 is mostly safe and supported by Mono which means it will work in Unity3D now.
                            SslProtocols = System.Security.Authentication.SslProtocols.Tls
                                           | System.Security.Authentication.SslProtocols.Tls11
                                           | System.Security.Authentication.SslProtocols.Tls12,

                            //Load the cert with the cert loader
                            ServerCertificate = X509Certificate2Loader.Create(model.HttpsCertificateName).Load()
                        });
                    });
                }
                else
                {
                    builder.UseKestrel();
                }

                //TODO: Should we allow both https and non-https traffic?
                if (model.isCustomUrlDefined)
                {
                    builder.UseUrls(model.isHttpsEnabled
                                                        ? model.Url
                                    .ToLower()
                                    .Replace(@"http://", @"https://")
                                                        : model.Url);
                }
                else
                {
                    string prefix = model.isHttpsEnabled ? @"https://" : @"http://";
                    builder.UseUrls($@"{prefix}localhost:5000");
                }
#endif
            });

            return(builder);
        }