public AuthService( IUserRepository userRepository, AuthConfiguration authConfiguration) { this.userRepository = userRepository; this.authConfiguration = authConfiguration; }
public object Post( [FromBody] User user, [FromServices] UserRepository userRepository, [FromServices] AuthConfiguration authConfiguration, [FromServices] TokenConfigurations tokenConfigurations) { bool validCredentials = false; if (user != null && !String.IsNullOrWhiteSpace(user.Login)) { var userTemp = userRepository.GetUser(user.Login); validCredentials = (userTemp != null && user.Login == userTemp.Login && user.AccessKey == userTemp.AccessKey); } if (validCredentials) { ClaimsIdentity identity = new ClaimsIdentity( new GenericIdentity(user.Login, "Login"), new[] { new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")), new Claim(JwtRegisteredClaimNames.UniqueName, user.Login) } ); DateTime createDate = DateTime.Now; DateTime expireDate = createDate + TimeSpan.FromSeconds(tokenConfigurations.Seconds); var handler = new JwtSecurityTokenHandler(); var securityToken = handler.CreateToken(new SecurityTokenDescriptor { Issuer = tokenConfigurations.Issuer, Audience = tokenConfigurations.Audience, SigningCredentials = authConfiguration.SigningCredentials, Subject = identity, NotBefore = createDate, Expires = expireDate }); var token = handler.WriteToken(securityToken); return(new { authenticated = true, created = createDate.ToString("yyyy-MM-dd HH:mm:ss"), expiration = expireDate.ToString("yyyy-MM-dd HH:mm:ss"), accessToken = token, message = "OK" }); } else { return(new { authenticated = false, message = "Falha ao autenticar" }); } }
public AuthController(IAuthProvider authProvider, IMapper mapper, IOptions <AuthConfiguration> authConfiguration) { _mapper = mapper; _authProvider = authProvider; _authConfiguration = authConfiguration.Value; }
public async Task <string> Authenticate(User user, string roleName) { var result = await Task.Run(() => { var claims = new List <Claim>() { new Claim(ClaimsIdentity.DefaultNameClaimType, user.UserName), new Claim(ClaimsIdentity.DefaultRoleClaimType, roleName) }; var identity = new ClaimsIdentity(claims, "jwt", ClaimsIdentity.DefaultNameClaimType, ClaimsIdentity.DefaultRoleClaimType); var now = DateTime.Now; var expire = now.AddDays(int.Parse(configuration.GetLifeTime())); var jwt = new JwtSecurityToken( issuer: configuration.GetIssuer(), audience: configuration.GetAudience(), claims: identity.Claims, notBefore: now, expires: expire, signingCredentials: new SigningCredentials(AuthConfiguration.GetSecurityKey(configuration.GetSecurityKey()), SecurityAlgorithms.HmacSha256) ); var token = new JwtSecurityTokenHandler().WriteToken(jwt); return(token); }); return(result); }
public static IServiceCollection AddIdentity<TCurrentUserService>(this IServiceCollection services, Action<DbContextOptionsBuilder> optionsAction, Action<AuthConfiguration> authConfigurationAction) where TCurrentUserService : class, ICurrentUserService { services .AddDbContext<ApplicationIdentityDbContext>(optionsAction); var configuration = new AuthConfiguration(); authConfigurationAction.Invoke(configuration); services .AddSingleton(configuration) .AddSingleton<JwtTokenService>(); services .AddIdentity<ApplicationUser, IdentityRole>() .AddEntityFrameworkStores<ApplicationIdentityDbContext>(); services .AddScoped<IUserService, IdentityUserService>() .AddScoped<ICurrentUserService, TCurrentUserService>(); return services; }
public static IServiceCollection AddAuth(this IServiceCollection services, AuthConfiguration authConfiguration) { //Authorizations services .AddIdentity <IdentityUser, IdentityRole>() .AddEntityFrameworkStores <AppContext>() .AddDefaultTokenProviders(); //Authentications var key = Encoding.ASCII.GetBytes(authConfiguration.Secret); services .AddAuthentication(options => { options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme; options.DefaultScheme = JwtBearerDefaults.AuthenticationScheme; options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme; }).AddJwtBearer(x => { x.RequireHttpsMetadata = false; x.SaveToken = false; x.TokenValidationParameters = new TokenValidationParameters { ValidateIssuerSigningKey = true, IssuerSigningKey = new SymmetricSecurityKey(key), ValidateIssuer = false, ValidateAudience = false }; }); return(services); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { IConfigurationSection sectionCassandra = Configuration.GetSection(AppSettingsConstants.CASSANDRA_CONNECTION); services.Configure <CassandraConnectionSetting>(sectionCassandra); IConfigurationSection sectionAuth = Configuration.GetSection(AppSettingsConstants.AUTH_CONFIGURATION); AuthConfiguration authConfiguration = sectionAuth.Get <AuthConfiguration>(); services.AddCassandra(); services.AddApplicationQuery(); services.AddApplicationCommand(); #if DEBUG services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1); services.AddSwagger(_version, authConfiguration); #else services.AddMvcCore().AddJsonFormatters(); #endif services.AddAuthentication() .AddIdentityServerAuthentication(options => { options.Authority = authConfiguration.Host; options.RequireHttpsMetadata = false; options.ApiName = authConfiguration.ApiName; }); }
private void ConfigureAuth(IServiceCollection services) { string domain = Configuration["Authentication:Domain"]; domain = $"https://{domain}/"; //Authentication service services.AddAuthentication(options => { options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme; options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme; }).AddJwtBearer(options => { options.Authority = domain; options.Audience = Configuration["Authentication:Audience"]; }); //Configure scopes as policies services.AddAuthorization(options => { var authorizationConfiguration = new AuthConfiguration(); Configuration.GetSection("Authorization").Bind(authorizationConfiguration); if (authorizationConfiguration.Scopes != null) { foreach (string scope in authorizationConfiguration.Scopes) { options.AddPolicy(scope, policy => policy.Requirements.Add(new ScopeRequirement(scope, domain))); } } }); //Register the scope authorization handler services.AddSingleton <IAuthorizationHandler, ScopeHandler>(); }
private static AuthenticationBuilder AddTokenAuthentication(this IServiceCollection services, IConfiguration configuration) { AuthConfiguration authConfiguration = new AuthConfiguration(configuration); return(services .AddSingleton(authConfiguration) .AddAuthentication(options => { options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme; options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme; }) .AddJwtBearer(JwtBearerDefaults.AuthenticationScheme, jwtBearerOptions => { jwtBearerOptions.TokenValidationParameters = new TokenValidationParameters { ValidateIssuerSigningKey = true, IssuerSigningKey = authConfiguration.Key, ValidateIssuer = true, ValidIssuer = authConfiguration.Issuer, ValidateAudience = true, ValidAudience = authConfiguration.Audience, ValidateLifetime = true, ClockSkew = TimeSpan.Zero }; })); }
public void ConfigureServices(IServiceCollection services) { var authSection = Configuration.GetSection("Auth").CheckExistence(); var authConfig = new AuthConfiguration(); authSection.Bind(authConfig); services.AddAuthentication(opts => { opts.DefaultAuthenticateScheme = "Cookie"; opts.DefaultSignInScheme = "Cookie"; opts.DefaultChallengeScheme = "AuthServer"; }) .AddCookie("Cookie", opts => { }) .AddOAuth("AuthServer", opts => { opts.ClientId = authConfig.ClientId; opts.ClientSecret = authConfig.ClientSecret; opts.CallbackPath = authConfig.CallbackPath; opts.AuthorizationEndpoint = authConfig.AuthorizationEndpoint; opts.TokenEndpoint = authConfig.TokenEndpoint; }); services.AddControllersWithViews(); }
public static async Task <int> Invoke(CancellationToken token, string[] urls, string[] metricUrls, bool metrics, string diagnosticPort, bool noAuth, bool tempApiKey, bool noHttpEgress) { try { AuthConfiguration authenticationOptions = HostBuilderHelper.CreateAuthConfiguration(noAuth, tempApiKey); IHost host = HostBuilderHelper.CreateHostBuilder(urls, metricUrls, metrics, diagnosticPort, authenticationOptions) .ConfigureServices(authenticationOptions, noHttpEgress) .Build(); try { await host.StartAsync(token); await host.WaitForShutdownAsync(token); } catch (MonitoringException) { // It is the responsibility of throwers to ensure that the exceptions are logged. return(-1); } catch (OptionsValidationException ex) { host.Services.GetRequiredService <ILoggerFactory>() .CreateLogger(typeof(CollectCommandHandler)) .OptionsValidationFailure(ex); return(-1); } catch (OperationCanceledException) when(token.IsCancellationRequested) { // The host will throw a OperationCanceledException if it cannot shut down the // hosted services gracefully within the shut down timeout period. Handle the // exception and let the tool exit gracefully. return(0); } finally { if (host is IAsyncDisposable asyncDisposable) { await asyncDisposable.DisposeAsync(); } else { host.Dispose(); } } } catch (FormatException ex) { Console.Error.WriteLine(ex.Message); if (ex.InnerException != null) { Console.Error.WriteLine(ex.InnerException.Message); } return(-1); } return(0); }
public override void Load(IServiceCollection services) { var config = new ConfigurationBuilder() .AddJsonFile(_configName, optional: true, reloadOnChange: false) .AddEnvironmentVariables() .AddAzureAppConfiguration(options => { options.Connect(Environment.GetEnvironmentVariable(EnvironmentVariableNames.ENV_CONFIG_CONNECTION)) .Select(KeyFilter.Any, LabelFilter.Null) .Select(KeyFilter.Any, Environment.GetEnvironmentVariable(EnvironmentVariableNames.SYSTEM_ENVIRONMENT)); }) .Build(); var _config = new AuthConfiguration() { ApiKey = config[EnvironmentVariableNames.ENV_HF_API_KEY], AuthURL = config[EnvironmentVariableNames.ENV_AUTH_URL], Issuers = config.GetSection("ISSUERS")?.Get <string[]>(), Audiences = config.GetSection("AUDIENCES")?.Get <string[]>(), Audience = config[AppConfigurationKey.AUDIENCE], ClientId = config[AppConfigurationKey.CLIENT_ID], ClientSecret = config[AppConfigurationKey.CLIENT_SECRET], Issuer = config[AppConfigurationKey.ISSUER], AccessToken = config[AppConfigurationKey.ACCESS_TOKEN], }; var _authHelper = new AuthenticationHelper(_authServiceName, config[EnvironmentVariableNames.ENV_AUTH_URL], _config); var _raygun = new RaygunClient(config[EnvironmentVariableNames.ENV_RAYGUN_API_KEY]); services.AddSingleton <IAuthenticationHelper>(_authHelper); services.AddSingleton <IConfiguration>(config); services.AddSingleton(_raygun); services.AddSingleton <HttpClient>(); }
public UserService(IGenericRepository <Guid> genericRepository, IUnitOfWork unitOfWork, IMapper mapper, IConfiguration configuration) { this.genericRepository = genericRepository; this.unitOfWork = unitOfWork; this.mapper = mapper; this.AuthConfiguration = configuration.GetSection(AuthConfiguration.Section).Get <AuthConfiguration>(); }
public AccountService(UserManager <User> userManager, AuthConfiguration authConfiguration, ApplicationDbContext db) { _userManager = userManager; _authConfiguration = authConfiguration; this.db = db; }
protected override void ConfigureRequestContainer(IKernel container, NancyContext context) { base.ConfigureRequestContainer(container, context); RavenDbConfiguration.ConfigureSession(container); AuthConfiguration.ConfigureRequest(container); ServiceConfiguration.ConfigureRequestServices(container); }
public LogoutController( LogoutSessionManager logoutSessions, IOptions <AuthConfiguration> optionsAuthConfiguration, IHttpClientFactory httpClientFactory) { _optionsAuthConfiguration = optionsAuthConfiguration.Value; LogoutSessions = logoutSessions; _httpClient = httpClientFactory.CreateClient(); }
public HomeController( IOptions <AuthConfiguration> optionsAuthConfiguration, IConfiguration configuration, IHttpClientFactory clientFactory) { _configuration = configuration; _optionsAuthConfiguration = optionsAuthConfiguration.Value; _clientFactory = clientFactory; }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.AddControllers(); SwaggerConfiguration.AddSwaggerSetup(services); EntityFrameworkConfiguration.AddEntityFrameworkSetup(services, Configuration); DependencyInjectionConfiguration.AddDependencyInjectionSetup(services); AutoMapperConfiguration.AddAutoMapperSetup(services); AuthConfiguration.AddAuthenticationSetup(services, Configuration); }
public AuthServiceTests() { this.authConfiguration = new AuthConfiguration { Audience = "http://localhost:12345", Issuer = "http://localhost:12345", Key = "checkoutpaymentgateway2020testkey" }; this.target = new AuthService(authConfiguration); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { var connString = Configuration.GetConnectionString("DefaultConnection"); services.AddDbContext <StepCoreContext>(option => option.UseSqlServer(connString)); IocConfiguration.Init(Configuration, services); AuthConfiguration.Init(Configuration, services); services.AddControllers(); services.AddCors(opt => { opt.AddPolicy("AllowMyOrigin", builder => builder.AllowAnyHeader().AllowAnyOrigin().AllowAnyMethod()); }); }
public SamlController(ILoggerFactory logger, IOptions <AuthConfiguration> spidConfiguration, RequestOptionFactory requestOptionFactory, IAuthRequest authRequest, IAuthResponse authResponse, ILogoutResponse logoutResponse, ITokenService tokenService, IdpHelper idpHelper, IDataProtectionService dataProtectionService) { _logger = logger.CreateLogger(LogCategories.AUTHENGINE); _traceLogger = logger.CreateLogger(LogCategories.SAMLTRACE); _sessionAuthLogger = logger.CreateLogger(LogCategories.AUTHSESSION); _spidConfiguration = spidConfiguration?.Value; _requestOptionFactory = requestOptionFactory; _authRequest = authRequest; _authResponse = authResponse; _logoutResponse = logoutResponse; _tokenService = tokenService; _idpHelper = idpHelper; _dataProtectionService = dataProtectionService; }
public void ConfigureServices(IServiceCollection services) { AuthConfiguration.ConfigureServices(services, _appSettings); GraphQlConfiguration.ConfigureServices(services, _environment); ConfigureDatabaseServices(services); ConfigureMessageSenderServices(services); ConfigureRequestResponseServices(services); ConfigureSessionServices(services); services.AddHttpClient(); services .AddHealthChecks() .AddDbContextCheck <Data.ApplicationDbContext>(); services.AddSingleton(_appSettings); services.AddSingleton(_environment); // services.AddDatabaseDeveloperPageExceptionFilter(); }
public static IServiceCollection AddCommonAuthentication(this IServiceCollection services, AuthConfiguration authConfiguration) { JwtSecurityTokenHandler.DefaultInboundClaimTypeMap.Clear(); services.AddAuthentication(config => { config.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme; }) .AddJwtBearer(config => { config.Authority = authConfiguration.Authority; config.Audience = authConfiguration.Audience; config.RequireHttpsMetadata = false; }); return(services); }
public static IServiceCollection ConfigureApllicationServices(this IServiceCollection services, IConfiguration configuration) { var authConfiguration = new AuthConfiguration { ExpireTimeMinutes_Client = configuration.GetValue <int>("AuthConfiguration:ExpireTimeMinutes_Client"), ExpireTimeMinutes_Password = configuration.GetValue <int>("AuthConfiguration:ExpireTimeMinutes_Password"), ExpireTimeMinutes_Refresh = configuration.GetValue <int>("AuthConfiguration:ExpireTimeMinutes_Refresh"), Router = configuration.GetValue <string>("AuthConfiguration:Router"), TokenKey = configuration.GetValue <string>("AuthConfiguration:TokenKey"), RefreshToken_TimeValidHour = configuration.GetValue <int>("AuthConfiguration:RefreshToken_TimeValidHour"), }; services .AddSingleton <IHttpContextAccessor, HttpContextAccessor>() .AddRabbitMQ(configuration, options => { options.AddConnection("rabbitmq"); }) .AddScoped(serviceProvider => { var token = serviceProvider.GetRequiredService <TokenRead>(); var value = new SessionUser(); if (token != null && token.Claims != null) { var user_Id = token.GetValue("Id_User"); var account_Id = token.GetValue("Account_Id"); if (int.TryParse(user_Id, out int userId) && int.TryParse(account_Id, out int accountId)) { value.Id = userId; value.AccountId = accountId; } } return(value); }) .Register(configuration) .AddCorsServices(configuration) .AddResponseCompression() .AddSimpleOAuth(option => { option.AddKeyToken(authConfiguration.TokenKey); option.AddAuthRouter(authConfiguration.Router); }) .AddSingleton(_ => authConfiguration); return(services); }
public void ConfigureServices(IServiceCollection services) { // DIConfiguration.Config(services, Configuration); DbConfiguration.Config(services, Configuration); AuthConfiguration.Config(services); services.AddAntiforgery(opt => { opt.HeaderName = "X-XSRF-TOKEN"; opt.Cookie.Name = "XSRF-TOKEN"; opt.Cookie.HttpOnly = true; opt.Cookie.Path = "/"; }); services.AddMemoryCache(); services.AddDistributedMemoryCache(); services.AddSession(opt => { opt.IdleTimeout = TimeSpan.FromDays(1); }); services.AddLocalization(options => options.ResourcesPath = "Resources"); services.AddRouting(options => options.LowercaseUrls = true); services.AddMvc( options => { options.ModelMetadataDetailsProviders.Add( new CustomValidationMetadataProvider("Portal.SiteResources", typeof(SiteResources))); } ) .SetCompatibilityVersion(CompatibilityVersion.Version_2_1) .AddJsonOptions(options => { options.SerializerSettings.ContractResolver = new DefaultContractResolver { NamingStrategy = new SnakeCaseNamingStrategy() }; }) .AddDataAnnotationsLocalization() .AddViewLocalization(); services.AddAutoMapper(); // services.Configure<ApiBehaviorOptions>(options => // { // options.SuppressModelStateInvalidFilter = true; // options.SuppressConsumesConstraintForFormFileParameters = true; // }); }
public void ConfigureServices(IServiceCollection services) { services.AddOptions(); services.AddScoped <IConnectionBloodOrange, UnitOfWorkBloodOrange>(x => new UnitOfWorkBloodOrange(Configuration.GetSection("Configuracoes").GetSection("Connection-BloodOrange").Value)); services.AddScoped <IMessaging, Messages>(x => new Messages(Configuration.GetSection("Messages").Value)); services.Configure <ApplicationConfiguration>(Configuration.GetSection("Aplicacao")); services.AddTransient <PerformaceFilters>(); services.AddTransient <SecurityFilter>(); AuthConfiguration.Register(services, Configuration); AutoMapperConfiguration.Register(services, Configuration); DependencyInjectionConfiguration.Register(services, Configuration); services.AddMvc(options => { options.Filters.AddService <PerformaceFilters>(); options.Filters.AddService <SecurityFilter>(); options.Filters.Add(typeof(ErrorFilters)); }).AddJsonOptions(options => { options.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore; }).SetCompatibilityVersion(CompatibilityVersion.Latest); SwaggerApiVersioningConfiguration.Register(services); var corsBuilder = new CorsPolicyBuilder() .AllowAnyHeader() .AllowAnyMethod() .AllowAnyOrigin(); services.AddCors(options => { options.AddPolicy("SiteCorsPolicy", corsBuilder.Build()); }); }
public ScheduleTask(IServiceScopeFactory serviceScopeFactory) : base(serviceScopeFactory) { var builder = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddJsonFile("appsettings.json"); var config = builder.Build(); _authConfiguration = config .GetSection(nameof(AuthConfiguration)) .Get <AuthConfiguration>(); _myChannelConfiguration = config .GetSection(nameof(MyChannelConfiguration)) .Get <MyChannelConfiguration>(); _reportConfiguration = config .GetSection(nameof(ReportConfiguration)) .Get <ReportConfiguration>(); }
public void Configuration(IAppBuilder app) { var httpConfig = new HttpConfiguration(); AuthConfiguration.ConfigureOAuthTokenGeneration(app); AuthConfiguration.ConfigureOAuthTokenConsumption(app); OdataConfiguration.Register(httpConfig); app.UseCors(CorsOptions.AllowAll); JsConfig.EmitCamelCaseNames = true; WebApiConfigurations.ConfigureWebApi(httpConfig); httpConfig.EnsureInitialized(); }
public TelegramCore(IServiceScopeFactory serviceScopeFactory) : base(serviceScopeFactory) { var builder = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddJsonFile("appsettings.json"); var config = builder.Build(); _authConfiguration = config .GetSection(nameof(AuthConfiguration)) .Get <AuthConfiguration>(); _keywordsConfiguration = config .GetSection(nameof(KeywordsConfiguration)) .Get <KeywordsConfiguration>(); _myChannelConfiguration = config .GetSection(nameof(MyChannelConfiguration)) .Get <MyChannelConfiguration>(); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { AppSettings.Configure(services, Configuration, Environment.IsDevelopment() ? @"c:\" : Environment.ContentRootPath); //dependency injection goes here. services.AddHttpContextAccessor(); services.AddTransient <HealthCheckDelegatingHandler>(); // TODO: remove httpClientBuilder // This bypasses any certificate validation on proxy requests // Only done due to local APIs not having certificates configured services.AddProxy(httpClientBuilder => httpClientBuilder.ConfigurePrimaryHttpMessageHandler(() => new HttpClientHandler { ClientCertificateOptions = ClientCertificateOption.Manual, ServerCertificateCustomValidationCallback = (httpRequestMessage, cert, cetChain, policyErrors) => true })); services.Configure <CookiePolicyOptions>(options => { // This lambda determines whether user consent for non-essential cookies is needed for a given request. options.CheckConsentNeeded = context => true; options.MinimumSameSitePolicy = SameSiteMode.None; }); services.AddControllers(); // Add authentication services var authConfiguration = new AuthConfiguration(Configuration, "WebAppConfiguration"); services.AddAuthentication(authConfiguration, allowNonSecureCookie: Environment.IsDevelopment()); services.AddAuthorisation(authConfiguration); // In production, the React files will be served from this directory services.AddSpaStaticFiles(configuration => { configuration.RootPath = "ClientApp/build"; }); services.AddHealthChecks(); services.AddHealthChecksUI(setupSettings: setup => { setup.UseApiEndpointDelegatingHandler <HealthCheckDelegatingHandler>(); }) .AddInMemoryStorage(); }