public TokenConfigurations() { Signing = new SigningConfigurations(); }
public Object Autenticar(TUsuario usuario, [FromServices] SigningConfigurations SigningConfigurations, [FromServices] TokenConfigurations tokenConfigurations) { TUsuario user; try { user = _context.TUsuario.Single(u => u.Email == usuario.Email); } catch (InvalidOperationException) { user = null; } bool credenciaisValidas = false; if (usuario != null && !String.IsNullOrWhiteSpace(usuario.Email)) { credenciaisValidas = (user != null && user.Senha == usuario.Senha); } if (credenciaisValidas) { ClaimsIdentity identity = new ClaimsIdentity( new GenericIdentity(user.Email, "Login"), new[] { new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")), new Claim(JwtRegisteredClaimNames.UniqueName, user.Email) } ); DateTime dataCriacao = DateTime.Now; DateTime dataExpiracao = dataCriacao + TimeSpan.FromSeconds(tokenConfigurations.Seconds); var handler = new JwtSecurityTokenHandler(); var securityToken = handler.CreateToken(new SecurityTokenDescriptor { Issuer = tokenConfigurations.Issuer, Audience = tokenConfigurations.Audience, SigningCredentials = SigningConfigurations.SigningCredentials, Subject = identity, NotBefore = dataCriacao, Expires = dataExpiracao }); var token = handler.WriteToken(securityToken); return(new { userid = _context.TUsuario.Where(u => u.Email == usuario.Email).First().UserId, username = _context.TUsuario.Where(u => u.Email == usuario.Email).First().Nome, authenticated = true, created = dataCriacao.ToString("yyyy-MM-dd HH:mm:ss"), expiration = dataExpiracao.ToString("yyyy-MM-dd HH:mm:ss"), accessToken = token, message = "Ok" }); } else { return(new { authenticated = false, message = "Falha na autenticação" }); } }
public ActionResult <Response <TokenResponseDTO> > Post([FromBody] CredentialsDTO dto, [FromServices] SigningConfigurations signingConfigurations, [FromServices] TokenConfigurations tokenConfigurations, [FromServices] IMemoryCache cache) { if (dto == null || (string.IsNullOrWhiteSpace(dto.UserID) && string.IsNullOrWhiteSpace(dto.SecretKey) && string.IsNullOrWhiteSpace(dto.RefreshToken)) || (!string.IsNullOrWhiteSpace(dto.UserID) && !string.IsNullOrWhiteSpace(dto.SecretKey) && !string.IsNullOrWhiteSpace(dto.RefreshToken)) || (string.IsNullOrWhiteSpace(dto.RefreshToken) && (string.IsNullOrWhiteSpace(dto.UserID) || string.IsNullOrWhiteSpace(dto.SecretKey))) || (!string.IsNullOrWhiteSpace(dto.RefreshToken) && (!string.IsNullOrWhiteSpace(dto.UserID) || !string.IsNullOrWhiteSpace(dto.SecretKey))) ) { return(BadRequest()); } var watch = Stopwatch.StartNew(); Response <TokenResponseDTO> result = new Response <TokenResponseDTO>(); try { bool isValidCredentials = false; string cachedUserId = null; if (string.IsNullOrWhiteSpace(dto.RefreshToken)) { dto.SecretKey = GetEncode512(dto.SecretKey); isValidCredentials = _facade.Login(dto); } if (isValidCredentials || (cache.TryGetValue("refresh_token", out string cachedRefreshToken) && cache.TryGetValue("user_id", out cachedUserId) && cachedRefreshToken == dto.RefreshToken)) { ClaimsIdentity identity = new ClaimsIdentity( new GenericIdentity(cachedUserId ?? dto.UserID, "Login"), new[] { new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")), new Claim(JwtRegisteredClaimNames.UniqueName, cachedUserId ?? dto.UserID) } ); var now = DateTime.Now; var cacheExpirate = now + TimeSpan.FromSeconds(tokenConfigurations.Seconds) * 2; TokenResponseDTO tokenResponse = new TokenResponseDTO() { TokenExpirate = tokenConfigurations.Seconds, RefreshTokenExpirate = tokenConfigurations.Seconds * 2 }; var handler = new JwtSecurityTokenHandler(); var securityToken = handler.CreateToken(new SecurityTokenDescriptor { Issuer = tokenConfigurations.Issuer, Audience = tokenConfigurations.Audience, SigningCredentials = signingConfigurations.SigningCredentials, Subject = identity, NotBefore = now, Expires = now + TimeSpan.FromSeconds(tokenConfigurations.Seconds) }); tokenResponse.Token = handler.WriteToken(securityToken); cache.Remove("refresh_token"); cache.Remove("user_id"); tokenResponse.RefreshToken = SetCache(cache, "refresh_token", Guid.NewGuid().ToString().Replace("-", string.Empty), cacheExpirate); SetCache(cache, "user_id", cachedUserId ?? dto.UserID, cacheExpirate); result.Items.Add(tokenResponse); result.Success = true; } else { result.AddError(!isValidCredentials ? "Invalid credentials" : "Refresh token is invalid or expired"); } } catch (Exception ex) { result.AddError(ex); } watch.Stop(); result.ResponseTime = watch.Elapsed.TotalSeconds.ToString("0.0### seconds"); result.HttpStatusCode = System.Net.HttpStatusCode.OK; return(result); }
public LoginService(LoginRepository repository, SigningConfigurations signingConfigurations, TokenConfiguration tokenConfiguration) { _repository = repository; _signingConfigurations = signingConfigurations; _tokenConfiguration = tokenConfiguration; }
public void ConfigureServices(IServiceCollection services) { services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2); // add cors services.AddCors(); var config = Configuration["AppSettings:Database"]; // Add Context - will be removed in the real implementation services.AddDbContext <ApplicationDbContext>(options => { options.UseInMemoryDatabase("web.api"); }); // Swagger Config services.AddSwaggerGen(c => { c.SwaggerDoc("v1", new Info { Title = "Web Api 2.2", Version = "V1" }); }); // Fluent Validation services.AddValidators(); // Add Identity services.AddIdentityConfiguration(); var s = Configuration["Redis:host"]; //Add Redis services.AddDistributedRedisCache(option => { option.Configuration = Configuration["Redis:host"]; option.InstanceName = Configuration["Redis:db_name"]; }); // appSettings //var appSettingsSection = Configuration.GetSection("AppSettings"); //services.Configure<AppSettings>(appSettingsSection); // JWt Guards var signingConfigurations = new SigningConfigurations(); services.AddSingleton(signingConfigurations); var tokenConfigurations = new TokenConfigurations(); new ConfigureFromConfigurationOptions <TokenConfigurations>( Configuration.GetSection("TokenConfigurations")) .Configure(tokenConfigurations); services.AddSingleton(tokenConfigurations); var jwt = new Jwt(tokenConfigurations); services.AddSingleton(jwt); services.AddJwtSecurity(signingConfigurations, tokenConfigurations); // Auto Mapper Config var configMapper = new MapperConfiguration(cfg => { cfg.AddProfile(new DomainProfile()); }); services.AddSingleton(configMapper.CreateMapper()); // DI Injection services.AddSingleton <IAuthService, AuthService>(); services.AddSingleton <IRepositoryFacade, RepositoryFacade>(); services.AddScoped <CacheControllerAttribute>(); //services.AddAuthentication(); }
public IActionResult Login([FromBody] UsuarioDomain usuario_, [FromServices] SigningConfigurations signingConfigurations, [FromServices] TokenConfigurations tokenConfigurations) { try { UsuarioDomain _usuario = _usuarioRepository.UsuarioExiste(usuario_.Email, usuario_.Password); if (_usuario != null) { ClaimsIdentity identity = new ClaimsIdentity( new GenericIdentity(_usuario.UsuarioId.ToString(), "Login"), new[] { new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")), new Claim(JwtRegisteredClaimNames.UniqueName, _usuario.UsuarioId.ToString()), new Claim("Id", _usuario.UsuarioId.ToString()), new Claim("Nome", _usuario.Perfil.Nome), }); identity.AddClaim(new Claim(ClaimTypes.Role, _usuario.Role)); var handler = new JwtSecurityTokenHandler(); var securityToken = handler.CreateToken(new SecurityTokenDescriptor { Issuer = tokenConfigurations.Issuer, Audience = tokenConfigurations.Audience, SigningCredentials = signingConfigurations.SigningCredentials, Subject = identity }); var token = handler.WriteToken(securityToken); var retornoUsuario = new { id = _usuario.UsuarioId, email = _usuario.Email, role = _usuario.Role, ativo = _usuario.Ativo, perfil = new { id = _usuario.Perfil.PerfilId, usuarioId = _usuario.UsuarioId, nome = _usuario.Perfil.Nome, miniBio = _usuario.Perfil.MiniBio, foto = "", cep = _usuario.Perfil.Cep, sedeId = _usuario.Perfil.SedeId } }; var retorno = new { authenticated = true, accessToken = token, message = "OK", usuario = retornoUsuario }; return(Ok(retorno)); } return(NotFound("Email ou senha inválido!")); } catch (System.Exception e) { return(BadRequest(e.Message)); } }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { //Injeção de dependencia ConfigureService.ConfigureDependenciesService(services); ConfigureRepository.ConfigureDependenciesRepository(services); //Injeção do automapper var config = new AutoMapper.MapperConfiguration(cfg => { cfg.AddProfile(new DtoToModelProfile()); cfg.AddProfile(new EntityToDtoProfile()); cfg.AddProfile(new ModelToEntityProfile()); }); IMapper mapper = config.CreateMapper(); services.AddSingleton(mapper); //Token de autenticação var signingConfigurations = new SigningConfigurations(); services.AddSingleton(signingConfigurations); var tokenConfigurations = new TokenConfigurations(); new ConfigureFromConfigurationOptions <TokenConfigurations>(Configuration.GetSection("TokenConfigurations")).Configure(tokenConfigurations); services.AddSingleton(tokenConfigurations); //Authentication Bearer Token services.AddAuthentication(authOptions => { authOptions.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme; authOptions.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme; }).AddJwtBearer(bearerOptions => { var paramsValidation = bearerOptions.TokenValidationParameters; paramsValidation.IssuerSigningKey = signingConfigurations.Key; paramsValidation.ValidAudience = tokenConfigurations.Audience; paramsValidation.ValidIssuer = tokenConfigurations.Issuer; paramsValidation.ValidateIssuerSigningKey = true; paramsValidation.ValidateLifetime = true; paramsValidation.ClockSkew = TimeSpan.Zero; }); services.AddAuthorization(auth => { auth.AddPolicy("Bearer", new AuthorizationPolicyBuilder() .AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme) .RequireAuthenticatedUser().Build()); }); //Controllers MVC services.AddControllers(); //swagger services.AddSwaggerGen(c => { c.SwaggerDoc("v1", new OpenApiInfo { Version = "v1", Title = "Api Modelo Asp.Net Core 3.1", Description = "Arquitetura DDD", TermsOfService = new Uri("http://www.wmtecnologia.com.br"), Contact = new OpenApiContact { Name = "Willian Marcel Borges", Email = "*****@*****.**", Url = new Uri("http://www.wmtecnologia.com.br") }, License = new OpenApiLicense { Name = "Termos de Licensa de Uso", Url = new Uri("http://www.wmtecnologia.com.br") } }); c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme { Description = "Entre com o Token JWT", Name = "Authorization", In = ParameterLocation.Header, Type = SecuritySchemeType.ApiKey }); c.AddSecurityRequirement(new OpenApiSecurityRequirement { { new OpenApiSecurityScheme { Reference = new OpenApiReference { Id = "Bearer", Type = ReferenceType.SecurityScheme } }, new List <string>() } }); }); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.AddDistributedRedisCache(options => { options.Configuration = Configuration.GetConnectionString("ConexaoRedis"); options.InstanceName = "APIFCPark"; }); services.AddDbContext <IdentityDbContext>(options => options.UseSqlServer(Configuration.GetConnectionString("BaseIdentity"))); services.AddDbContext <FCParkDbContext>(options => options.UseSqlServer(Configuration.GetConnectionString("App"))); services.AddScoped <IUnitOfWork, UnitOfWork>(); services.AddTransient <IVeiculoService, VeiculoService>(); services.AddTransient <IEstabelecimentoService, EstabelecimentoService>(); services.AddTransient <IMovimentacaoVeiculoService, MovimentacaoVeiculoService>(); services.AddIdentity <ApplicationUser, IdentityRole>() .AddEntityFrameworkStores <IdentityDbContext>() .AddDefaultTokenProviders(); var signingConfigurations = new SigningConfigurations(); services.AddSingleton(signingConfigurations); var tokenConfigurations = new TokenConfigurations(); new ConfigureFromConfigurationOptions <TokenConfigurations>( Configuration.GetSection("TokenConfigurations")) .Configure(tokenConfigurations); services.AddSingleton(tokenConfigurations); services.AddAuthentication(authOptions => { authOptions.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme; authOptions.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme; }).AddJwtBearer(bearerOptions => { var paramsValidation = bearerOptions.TokenValidationParameters; paramsValidation.IssuerSigningKey = signingConfigurations.Key; paramsValidation.ValidAudience = tokenConfigurations.Audience; paramsValidation.ValidIssuer = tokenConfigurations.Issuer; // Valida a assinatura de um token recebido paramsValidation.ValidateIssuerSigningKey = true; // Verifica se um token recebido ainda é válido paramsValidation.ValidateLifetime = true; // Tempo de tolerância para a expiração de um token (utilizado // caso haja problemas de sincronismo de horário entre diferentes // computadores envolvidos no processo de comunicação) paramsValidation.ClockSkew = TimeSpan.Zero; }); services.AddAuthorization(auth => { auth.AddPolicy("Bearer", new AuthorizationPolicyBuilder() .AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme) .RequireAuthenticatedUser().Build()); }); services.AddCors(); services.AddSwaggerGen(c => { c.SwaggerDoc("v1", new Microsoft.OpenApi.Models.OpenApiInfo { Title = "API FC PARK", Version = "v1", Description = "REST API de estacionamento para demonstrativo de aplicação .NET CORE", Contact = new OpenApiContact { Name = "Vinícius Espuri Barboza", Email = "*****@*****.**" }, License = new OpenApiLicense { Name = "OPEN REST API FC PARK" } }); var xmlFile = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml"; var xmlPath = Path.Combine(AppContext.BaseDirectory, xmlFile); c.IncludeXmlComments(xmlPath); c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme { Name = "Authorization", Type = SecuritySchemeType.ApiKey, Scheme = "Bearer", BearerFormat = "JWT", In = ParameterLocation.Header, Description = "JWT Authorization header using the Bearer scheme." }); c.AddSecurityRequirement(new OpenApiSecurityRequirement { { new OpenApiSecurityScheme { Reference = new OpenApiReference { Type = ReferenceType.SecurityScheme, Id = "Bearer" } }, new string[] {} } }); }); services.AddScoped <AccessManager>(); services.AddControllers().AddXmlSerializerFormatters(); services.AddAutoMapper(typeof(Startup)); }
public static IServiceCollection AddAuthJwtConfigurations(this IServiceCollection services, SigningConfigurations signingConfigurations, TokenConfigurations tokenConfigurations) { services.AddAuthentication(authOptions => { authOptions.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme; authOptions.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme; }).AddJwtBearer(bearerOptions => { var paramsValidation = bearerOptions.TokenValidationParameters; paramsValidation.IssuerSigningKey = signingConfigurations.Key; paramsValidation.ValidAudience = tokenConfigurations.Audience; paramsValidation.ValidIssuer = tokenConfigurations.Issuer; // Valida a assinatura de um token recebido paramsValidation.ValidateIssuerSigningKey = true; // Verifica se um token recebido ainda é válido paramsValidation.ValidateLifetime = true; // Tempo de tolerância para a expiração de um token paramsValidation.ClockSkew = TimeSpan.Zero; }); // Ativa o uso do token como forma de autorizar o acesso // a recursos deste projeto services.AddAuthorization(auth => { auth.AddPolicy("Bearer", new AuthorizationPolicyBuilder() .AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme) .RequireAuthenticatedUser().Build()); }); return(services); }
public UserServiceImpl(IUserRepository repository, SigningConfigurations signingConfigurations, TokenConfiguration tokenConfiguration) { _repository = repository; _signingConfigurations = signingConfigurations; _tokenConfiguration = tokenConfiguration; }
public object Post( [FromBody] UserViewModel usuario, [FromServices] UserManager <ApplicationUser> userManager, [FromServices] SignInManager <ApplicationUser> signInManager, [FromServices] SigningConfigurations signingConfigurations, [FromServices] TokenConfigurations tokenConfigurations) { bool credenciaisValidas = false; ApplicationUser userIdentity = new ApplicationUser(); if (usuario == null && string.IsNullOrWhiteSpace(usuario.UserID)) { LoginResponse response = new LoginResponse { Authenticated = false, Message = "Falha ao autenticar" }; return(response); } // Verifica a existência do usuário nas tabelas do // ASP.NET Core Identity userIdentity = userManager.FindByNameAsync(usuario.UserID).Result; if (userIdentity != null) { // Efetua o login com base no Id do usuário e sua senha var resultadoLogin = signInManager .CheckPasswordSignInAsync(userIdentity, usuario.Password, false) .Result; if (resultadoLogin.Succeeded) { // Verifica se o usuário em questão possui a role de Acesso credenciaisValidas = userManager.IsInRoleAsync(userIdentity, Roles.ROLE_API).Result; if (credenciaisValidas) { ClaimsIdentity identity = new ClaimsIdentity( new[] { new Claim(JwtRegisteredClaimNames.UniqueName, usuario.UserID), new Claim("userName", usuario.UserID.ToUpper()), new Claim("userGuid", userIdentity.Id), new Claim("RememberMe", usuario.RememberMe.ToString()), new Claim("Dominio", usuario.Dominio) } , CookieAuthenticationDefaults.AuthenticationScheme); DateTime dataCriacao = DateTime.Now; DateTime dataExpiracao = dataCriacao + TimeSpan.FromSeconds(tokenConfigurations.Seconds); var handler = new JwtSecurityTokenHandler(); var jwtSecurityToken = handler.CreateJwtSecurityToken(new SecurityTokenDescriptor { Issuer = tokenConfigurations.Issuer, Audience = tokenConfigurations.Audience, SigningCredentials = signingConfigurations.SigningCredentials, EncryptingCredentials = signingConfigurations.EncryptingCredentials, Subject = identity, NotBefore = dataCriacao, Expires = dataExpiracao }); var token = handler.WriteToken(jwtSecurityToken); LoginResponse response = new LoginResponse { Authenticated = true, Created = dataCriacao.ToString("yyyy-MM-dd HH:mm:ss"), Expiration = dataExpiracao.ToString("yyyy-MM-dd HH:mm:ss"), AccessToken = token, Message = "OK" }; return(response); } else { LoginResponse response = new LoginResponse { Authenticated = false, Message = "Falha ao autenticar" }; return(response); } } else { LoginResponse response = new LoginResponse { Authenticated = false, Message = "Erro ao autenticar. Usuário ou senha inválidos!" }; return(response); } } else { LoginResponse response = new LoginResponse { Authenticated = false, Message = "Erro ao autenticar. Usuário ou senha inválidos!" }; return(response); } }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { ConfigureService.ConfigureDependeniesService(services); ConfigureRepository.ConfigureDependeniesRepository(services); var config = new AutoMapper.MapperConfiguration(cfg => { cfg.AddProfile(new DtoToModelProfile()); cfg.AddProfile(new EntityToDtoProfile()); cfg.AddProfile(new ModelToEntityProfile()); }); IMapper mapper = config.CreateMapper(); services.AddSingleton(mapper); var signingConfigurations = new SigningConfigurations(); services.AddSingleton(signingConfigurations); var tokenConfiguration = new TokenConfigurations(); new ConfigureFromConfigurationOptions <TokenConfigurations>( Configuration.GetSection("TokenConfigurations")).Configure(tokenConfiguration); services.AddSingleton(tokenConfiguration); services.AddAuthentication(authOptions => { authOptions.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme; authOptions.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme; }).AddJwtBearer(bearerOptions => { var paramsValidation = bearerOptions.TokenValidationParameters; paramsValidation.IssuerSigningKey = signingConfigurations.SecurityKey; paramsValidation.ValidAudience = tokenConfiguration.Audience; paramsValidation.ValidIssuer = tokenConfiguration.Issuer; paramsValidation.ValidateIssuerSigningKey = true; paramsValidation.ClockSkew = TimeSpan.Zero; }); services.AddAuthorization(auth => { auth.AddPolicy("Bearer", new AuthorizationPolicyBuilder() .AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme) .RequireAuthenticatedUser().Build()); }); services.AddSwaggerGen(c => { c.SwaggerDoc("v1", new OpenApiInfo { Version = "v1", Title = "AspnetCore 3.1", Description = "Exemplo de API REST criada com o Asp.Net core e arquitetura DDD", TermsOfService = new Uri("https://example.com/terms"), Contact = new OpenApiContact { Name = "Ivan Barros", Email = "*****@*****.**", Url = new Uri("https://twitter.com/spboyer"), }, License = new OpenApiLicense { Name = "Use under LICX", Url = new Uri("https://example.com/license"), } }); c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme { In = ParameterLocation.Header, Description = "Entre com o token JWT", Name = "authorization", Type = SecuritySchemeType.ApiKey }); // Swagger 2.+ support c.AddSecurityRequirement(new OpenApiSecurityRequirement { { new OpenApiSecurityScheme { Reference = new OpenApiReference { Id = "Bearer", Type = ReferenceType.SecurityScheme } }, new List <string>() } }); }); services.AddControllers().AddNewtonsoftJson(); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { _logger.LogInformation("Adding services..."); services.AddSingleton <IPasswordHasher, PasswordHasher>(); services.AddSingleton <ITokenHandler, Core.TokenHandler>(); services.AddScoped <IAuthenticationService, AuthenticationService>(); services.Configure <StripeSettings>(Configuration.GetSection("Stripe")); services.Configure <AppOptions>(Configuration.GetSection("app")); services.Configure <TokenOptions>(Configuration.GetSection("TokenOptions")); services.Configure <EmailSettings>(Configuration.GetSection("EmailSettings")); var tokenOptions = Configuration.GetSection("TokenOptions").Get <TokenOptions>(); // Add services that will be used for CRUD operations services.AddCustomServices(); services.AddAutoMapper(typeof(Startup).Assembly); services.AddResponseCaching(); var connectionString = Configuration.GetConnectionString("TuringBackendDB"); services.AddDbContext <TuringBackendContext>(c => c.UseMySql(connectionString)); services.AddCors(o => o.AddPolicy("DefaultPolicy", builder => { builder.AllowAnyOrigin(); })); services.AddSwaggerGen(c => { c.SwaggerDoc("v1", new Info { Title = "Turing ECommerce API", Version = "1.2.9", Description = "Official documentation about Turing ECommerce API" }); //Locate the XML file being generated by ASP.NET... var xmlFile = $"{Path.GetFileName(Assembly.GetExecutingAssembly().GetName().Name)}.xml"; //... and tell Swagger to use those XML comments. c.IncludeXmlComments(xmlFile.ToLower()); c.AddSecurityDefinition("Bearer", new ApiKeyScheme { Description = "JWT Authorization header using the Bearer scheme. Example: \"user-key: Bearer {token}\"", Name = "Authorization", In = "header", Type = "apiKey" }); var security = new Dictionary <string, IEnumerable <string> > { { "Bearer", new string[] { } } }; c.AddSecurityRequirement(security); }); var signingConfigurations = new SigningConfigurations(); services.AddSingleton(signingConfigurations); services.AddScoped <IAuthenticationService, AuthenticationService>(); services.AddAuthentication(x => { x.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme; x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme; }) .AddJwtBearer(jwtBearerOptions => { jwtBearerOptions.SaveToken = true; jwtBearerOptions.TokenValidationParameters = new TokenValidationParameters { ValidateAudience = true, ValidateLifetime = true, ValidateIssuerSigningKey = true, ValidIssuer = tokenOptions.Issuer, ValidAudience = tokenOptions.Audience, IssuerSigningKey = signingConfigurations.Key, ClockSkew = TimeSpan.Zero }; }); services.AddMvc(options => { options.OutputFormatters.Clear(); options.OutputFormatters.Add(new JsonOutputFormatter(new JsonSerializerSettings(), ArrayPool <char> .Shared)); }) .SetCompatibilityVersion(CompatibilityVersion.Version_2_2); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.AddMvc(options => { options.RespectBrowserAcceptHeader = true; // permite que a Api aceite o tipo de formato enviado pelo client no header da requisição options.ReturnHttpNotAcceptable = true; // especifica que a Api retornará 406 Not Acceptable caso o client passe no header um formato não suportado options.FormatterMappings.SetMediaTypeMappingForFormat("xml", MediaTypeHeaderValue.Parse("text/xml")); options.FormatterMappings.SetMediaTypeMappingForFormat("json", MediaTypeHeaderValue.Parse("application/json")); options.FormatterMappings.SetMediaTypeMappingForFormat("csv", MediaTypeHeaderValue.Parse("text/csv")); }).AddXmlSerializerFormatters().AddCsvSerializerFormatters(); services.AddDbContext <Context>(options => options.UseMySQL(Configuration.GetConnectionString("ConDb"))); services.AddApiVersioning(); var filterOptions = new HyperMediaFilterOptions(); filterOptions.ObjectContentResponseEnricherList.Add(new PersonEricher()); services.AddSingleton(filterOptions); // DEPENDECY INJECTION services.AddScoped(typeof(IRepository <>), typeof(Repository <>)); services.AddScoped <IPersonRepository, PersonRepository>(); services.AddScoped <IUserRepository, UserRepository>(); services.AddScoped <PersonBusiness>(); services.AddScoped <IBusiness <BookVO>, BookBusiness>(); services.AddScoped <ILoginBusiness, LoginBusiness>(); services.AddScoped <PersonConverter>(); services.AddScoped <BookConverter>(); services.AddRouting(); // DOCUMENTATION services.AddSwaggerGen(x => { x.SwaggerDoc("v1", new Info { Title = "RESTful API with ASP.NET Core", Version = "v1" }); x.ResolveConflictingActions(apiDescriptions => apiDescriptions.First()); }); services.AddCors(); // SECURITY var signingConfigurations = new SigningConfigurations(); services.AddSingleton(signingConfigurations); var tokenConfigurations = new TokenConfigurations(); new ConfigureFromConfigurationOptions <TokenConfigurations>(Configuration.GetSection("TokenConfigurations")).Configure(tokenConfigurations); services.AddSingleton(tokenConfigurations); services.AddAuthentication(options => { options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme; options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme; }).AddJwtBearer(options => { var paramsValidation = options.TokenValidationParameters; paramsValidation.IssuerSigningKey = signingConfigurations.Key; paramsValidation.ValidAudience = tokenConfigurations.Audience; paramsValidation.ValidIssuer = tokenConfigurations.Issuer; paramsValidation.ValidateIssuerSigningKey = true; paramsValidation.ValidateLifetime = true; paramsValidation.ClockSkew = TimeSpan.Zero; }); services.AddAuthorization(options => { options.AddPolicy("Bearer", new AuthorizationPolicyBuilder() .AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme) .RequireAuthenticatedUser().Build()); }); }
public async Task <object> Post( [FromBody] UserDto usuario, [FromServices] SigningConfigurations signingConfigurations, [FromServices] TokenConfigurations tokenConfigurations) { bool credenciaisValidas = false; if (usuario != null && !string.IsNullOrEmpty(usuario.UserID)) { var usuarioBase = await _userService.GetUser(usuario.UserID); credenciaisValidas = (usuarioBase != null && usuario.UserID == usuarioBase.UserID && usuario.AccessKey == usuarioBase.AccessKey); } if (credenciaisValidas) { var identity = new ClaimsIdentity( new GenericIdentity(usuario.UserID, "Login"), new[] { new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")), new Claim(JwtRegisteredClaimNames.UniqueName, usuario.UserID) } ); var dataCriacao = DateTime.Now; var dataExpiracao = dataCriacao + TimeSpan.FromSeconds(tokenConfigurations.Seconds); var handler = new JwtSecurityTokenHandler(); var securityToken = handler.CreateToken(new SecurityTokenDescriptor { Issuer = tokenConfigurations.Issuer, Audience = tokenConfigurations.Audience, SigningCredentials = signingConfigurations.SigningCredentials, Subject = identity, NotBefore = dataCriacao, Expires = dataExpiracao }); var token = handler.WriteToken(securityToken); var retorno = new { authenticated = true, created = dataCriacao.ToString("yyyy-MM-dd HH:mm:ss"), expiration = dataExpiracao.ToString("yyyy-MM-dd HH:mm:ss"), accessToken = token, message = "OK" }; return(Task.FromResult(retorno).Result); } else { var retorno = new { authenticated = false, message = "Falha ao autenticar" }; return(Task.FromResult(retorno).Result); } }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { if (_enviroment.IsEnvironment("Test")) { Environment.SetEnvironmentVariable("AUTH_AUDIENCE", "ExempleAudience"); Environment.SetEnvironmentVariable("AUTH_ISSUER", "ExempleIssuer"); Environment.SetEnvironmentVariable("AUTH_DURATION", "28800"); } ConfigureService.ConfigureDependenciesService(services); ConfigureRepository.ConfigureDependenciesRepository(services); var config = new AutoMapper.MapperConfiguration(cfg => { cfg.AddProfile(new DtoToModelProfile()); cfg.AddProfile(new EntityToDtoProfile()); cfg.AddProfile(new ModelToEntityProfile()); }); IMapper mapper = config.CreateMapper(); services.AddSingleton(mapper); var signingConfigurations = new SigningConfigurations(); services.AddSingleton(signingConfigurations); services.AddAuthentication(authOptions => { authOptions.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme; authOptions.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme; }).AddJwtBearer(bearerOptions => { var paramsValidation = bearerOptions.TokenValidationParameters; paramsValidation.IssuerSigningKey = signingConfigurations.Key; paramsValidation.ValidAudience = Environment.GetEnvironmentVariable("AUTH_AUDIENCE"); paramsValidation.ValidIssuer = Environment.GetEnvironmentVariable("AUTH_ISSUER"); paramsValidation.ValidateIssuerSigningKey = true; paramsValidation.ValidateLifetime = true; paramsValidation.ClockSkew = TimeSpan.Zero; }); services.AddAuthorization(auth => { auth.AddPolicy("Bearer", new AuthorizationPolicyBuilder() .AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme) .RequireAuthenticatedUser().Build()); }); services.AddControllers(); services.AddSwaggerGen(s => { s.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme { Description = "Insert JWT Token", Name = "Authorization", In = ParameterLocation.Header, Type = SecuritySchemeType.ApiKey }); s.AddSecurityRequirement(new OpenApiSecurityRequirement { { new OpenApiSecurityScheme { Reference = new OpenApiReference { Id = "Bearer", Type = ReferenceType.SecurityScheme } }, new List <string>() } }); }); }
public async Task <ActionResult <ResultResponse <LoginResponse> > > Login( [FromBody] UserModel usuario, [FromServices] SigningConfigurations signingConfigurations, [FromServices] TokenConfigurations tokenConfigurations) { Stopwatch _stopwatch = Stopwatch.StartNew(); var response = new ResultResponse <LoginResponse>(); response.QueryId = HttpContext.TraceIdentifier; try { ApplicationUser user; LoginResponse loginResponse = new LoginResponse(); if (usuario != null && !string.IsNullOrWhiteSpace(usuario.Email)) { // Retrieve User user = await _userManager.FindByEmailAsync(usuario.Email); // Login User if (user != null) { loginResponse.Authenticated = _signInManager.CheckPasswordSignInAsync(user, usuario.Password, false).Result.Succeeded; } else { throw new BusinessException("Email informado não cadastrado no sistema."); } if (loginResponse.Authenticated) { ClaimsIdentity identity = new ClaimsIdentity( new ClaimsIdentity(new GenericIdentity(usuario.Email, "Login")), new[] { new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")), new Claim(JwtRegisteredClaimNames.UniqueName, usuario.Email), } ); var roles = await _userManager.GetRolesAsync(user); foreach (var role in roles) { identity.AddClaim(new Claim("roles", role)); } DateTime dataCriacao = DateTime.Now; DateTime dataExpiracao = dataCriacao + TimeSpan.FromSeconds(tokenConfigurations.Seconds); var handler = new JwtSecurityTokenHandler(); var securityToken = handler.CreateToken(new SecurityTokenDescriptor { Issuer = tokenConfigurations.Issuer, Audience = tokenConfigurations.Audience, SigningCredentials = signingConfigurations.SigningCredentials, Subject = identity, NotBefore = dataCriacao, Expires = dataExpiracao }); loginResponse.AccessToken = handler.WriteToken(securityToken); loginResponse.Created = dataCriacao.ToString("dd-MM-yyyy HH:mm:ss"); loginResponse.Expiration = dataExpiracao.ToString("dd-MM-yyyy HH:mm:ss"); Console.WriteLine($"[{DateTime.Now} | Login] - Usuário autenticado. " + user.UserName + " : " + loginResponse.AccessToken); response.Result = loginResponse; response.Status = new ResultStatus() { Code = 200, Message = "Ok" }; response.ElapsedMilliseconds = _stopwatch.ElapsedMilliseconds; _stopwatch.Stop(); return(Ok(response)); } else { throw new BusinessException("Usuário ou senha incorretos."); } } else { throw new BusinessException("Dados obrigatórios não informados. Verifique sua requisição e tente novamente."); } } catch (BusinessException ex) { Console.WriteLine($"[{DateTime.Now} | Login] - Falha no login: "******"[{DateTime.Now} | Login] - Falha no login: "******"Erro ao autenticar." }; return(Ok(response)); } }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { MongoDbContext.ConnectionString = Configuration.GetSection("MongoConnection:ConnectionString").Value; MongoDbContext.DatabaseName = Configuration.GetSection("MongoConnection:Database").Value; MongoDbContext.IsSSL = Convert.ToBoolean(this.Configuration.GetSection("MongoConnection:IsSSL").Value); services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1); services.AddTransient <UsuarioJWTDAO>(); var signingConfigurations = new SigningConfigurations(); services.AddSingleton(signingConfigurations); var tokenConfigurations = new TokenConfigurations(); new ConfigureFromConfigurationOptions <TokenConfigurations>( Configuration.GetSection("TokenConfigurations")) .Configure(tokenConfigurations); services.AddSingleton(tokenConfigurations); services.AddAuthentication(authOptions => { authOptions.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme; authOptions.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme; }).AddJwtBearer(bearerOptions => { var paramsValidation = bearerOptions.TokenValidationParameters; paramsValidation.IssuerSigningKey = signingConfigurations.Key; paramsValidation.ValidAudience = tokenConfigurations.Audience; paramsValidation.ValidIssuer = tokenConfigurations.Issuer; // Valida a assinatura de um token recebido paramsValidation.ValidateIssuerSigningKey = true; // Verifica se um token recebido ainda é válido paramsValidation.ValidateLifetime = true; // Tempo de tolerância para a expiração de um token (utilizado // caso haja problemas de sincronismo de horário entre diferentes // computadores envolvidos no processo de comunicação) paramsValidation.ClockSkew = TimeSpan.Zero; }); // Ativa o uso do token como forma de autorizar o acesso // a recursos deste projeto services.AddAuthorization(auth => { auth.AddPolicy("Bearer", new AuthorizationPolicyBuilder() .AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme) .RequireAuthenticatedUser().Build()); }); services.AddSwaggerGen(c => { c.SwaggerDoc("v1", new Info { Title = "API QueroCento", Version = "v1" }); var xmlFile = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml"; var xmlPath = Path.Combine(AppContext.BaseDirectory, xmlFile); c.IncludeXmlComments(xmlPath); var security = new Dictionary <string, IEnumerable <string> > { { "Bearer", new string[] { } }, }; c.AddSecurityDefinition("Bearer", new ApiKeyScheme { Description = "JWT Authorization header using the Bearer scheme. Example: \"Authorization: Bearer {token}\"", Name = "Authorization", In = "header", Type = "apiKey" }); c.AddSecurityRequirement(security); }); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { var connectionString = Environment.GetEnvironmentVariable("DB_CONNECTION_STRING"); services.AddDbContext <UserContext>(options => options.UseNpgsql( connectionString ) ); services.AddCors(); services.AddSwaggerGen(options => { options.DescribeAllEnumsAsStrings(); options.SwaggerDoc("v1", new Info { Title = "Identity Api", Version = "v1" }); // Defina o caminho dos comentários para o Swagger. var xmlFile = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml"; var xmlPath = Path.Combine(AppContext.BaseDirectory, xmlFile); options.IncludeXmlComments(xmlPath); }); var signingConfigurations = new SigningConfigurations(); services.AddSingleton(signingConfigurations); var tokenConfigurations = new TokenConfigurations(); new ConfigureFromConfigurationOptions <TokenConfigurations>( Configuration.GetSection("TokenConfigurations")) .Configure(tokenConfigurations); services.AddSingleton(tokenConfigurations); services.AddAuthentication(authOptions => { authOptions.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme; authOptions.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme; }).AddJwtBearer(bearerOptions => { var paramsValidation = bearerOptions.TokenValidationParameters; paramsValidation.IssuerSigningKey = signingConfigurations.Key; paramsValidation.ValidAudience = tokenConfigurations.Audience; paramsValidation.ValidIssuer = tokenConfigurations.Issuer; // Valida a assinatura de um token recebido paramsValidation.ValidateIssuerSigningKey = true; // Verifica se um token recebido ainda é válido paramsValidation.ValidateLifetime = true; // Tempo de tolerância para a expiração de um token (utilizado // caso haja problemas de sincronismo de horário entre diferentes // computadores envolvidos no processo de comunicação) paramsValidation.ClockSkew = TimeSpan.Zero; }); // Ativa o uso do token como forma de autorizar o acesso // a recursos deste projeto services.AddAuthorization(auth => { auth.AddPolicy("Bearer", new AuthorizationPolicyBuilder() .AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme) .RequireAuthenticatedUser().Build()); }); services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2); services.AddCors(); services.AddDbContext <ReservaContext>( options => options.UseSqlServer(Configuration.GetConnectionString("CnnStr"))); services.AddScoped <ReservaContext, ReservaContext>(); services.AddScoped <ReservaStoreContext, ReservaStoreContext>(); services.AddTransient <IUow, Uow>(); services.AddScoped <TokenConfigurations, TokenConfigurations>(); services.AddScoped <SigningConfigurations, SigningConfigurations>(); services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>(); services.AddScoped <AuthenticatedUser>(); //Service services.AddTransient <IUsuarioService, UsuarioService>(); services.AddTransient <IFilialService, FilialService>(); services.AddTransient <ISalaService, SalaService>(); services.AddTransient <IReservaService, ReservaService>(); //Repository services.AddTransient <IUsuarioRepository, UsuarioRepository>(); services.AddTransient <IFilialRepository, FilialRepository>(); services.AddTransient <ISalaRepository, SalaRepository>(); services.AddTransient <IReservaRepository, ReservaRepository>(); //Hadler services.AddTransient <UsuarioHandler, UsuarioHandler>(); services.AddTransient <FilialHandler, FilialHandler>(); services.AddTransient <SalaHandler, SalaHandler>(); services.AddTransient <ReservaHandler, ReservaHandler>(); //Configurando Token var signingConfigurations = new SigningConfigurations(); services.AddSingleton(signingConfigurations); var tokenConfigurations = new TokenConfigurations(); new ConfigureFromConfigurationOptions <TokenConfigurations>( Configuration.GetSection("TokenConfigurations")) .Configure(tokenConfigurations); services.AddSingleton(tokenConfigurations); services.AddAuthentication(authOptions => { authOptions.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme; authOptions.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme; }).AddJwtBearer(bearerOptions => { var paramsValidation = bearerOptions.TokenValidationParameters; paramsValidation.IssuerSigningKey = signingConfigurations.Key; paramsValidation.ValidAudience = tokenConfigurations.Audience; paramsValidation.ValidIssuer = tokenConfigurations.Issuer; // Valida a assinatura de um token recebido paramsValidation.ValidateIssuerSigningKey = true; // Verifica se um token recebido ainda é válido paramsValidation.ValidateLifetime = true; // Tempo de tolerância para a expiração de um token (utilizado // caso haja problemas de sincronismo de horário entre diferentes // computadores envolvidos no processo de comunicação) paramsValidation.ClockSkew = TimeSpan.Zero; }); services.AddAuthorization(auth => { auth.AddPolicy("Bearer", new AuthorizationPolicyBuilder() .AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme) .RequireAuthenticatedUser().Build()); }); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { var connectionString = _configuration["MySqlConnection:MySqlConnectionString"]; services.AddDbContext <MySQLContext>(options => options.UseMySql(connectionString)); ExecuteMigration(connectionString); //Inicio da execução de login var signigConfiguration = new SigningConfigurations(); services.AddSingleton(signigConfiguration); var tokenConfiguration = new TokenConfiguration(); new ConfigureFromConfigurationOptions <TokenConfiguration>(_configuration.GetSection("TokenConfiguration")) .Configure(tokenConfiguration); services.AddSingleton(tokenConfiguration); services.AddAuthentication(authOptions => { authOptions.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme; authOptions.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme; }).AddJwtBearer(bearerOptions => { var paramsValidation = bearerOptions.TokenValidationParameters; paramsValidation.IssuerSigningKey = signigConfiguration.Key; paramsValidation.ValidAudience = tokenConfiguration.Audience; paramsValidation.ValidAudience = tokenConfiguration.Issuer; paramsValidation.ValidateIssuerSigningKey = true; paramsValidation.ValidateLifetime = true; paramsValidation.ClockSkew = TimeSpan.Zero; }); services.AddAuthorization(auth => { auth.AddPolicy("Bearer", new AuthorizationPolicyBuilder() .AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme) .RequireAuthenticatedUser().Build() ); }); //Fim da execução de login services.AddMvc(options => { options.RespectBrowserAcceptHeader = true; options.FormatterMappings.SetMediaTypeMappingForFormat("xml", MediaTypeHeaderValue.Parse("text/xml")); options.FormatterMappings.SetMediaTypeMappingForFormat("json", MediaTypeHeaderValue.Parse("application/json")); }) .AddXmlSerializerFormatters(); var filtertOptions = new HyperMediaFilterOptions(); filtertOptions.ObjectContentResponseEnricherList.Add(new BookEnricher()); filtertOptions.ObjectContentResponseEnricherList.Add(new PersonEnricher()); services.AddSingleton(filtertOptions); services.AddApiVersioning(option => option.ReportApiVersions = true); services.AddSwaggerGen(c => { c.SwaggerDoc( "v1", new Info { Title = "RESTful API With ASP.NET Core 2.0", Version = "v1" }); }); services.AddScoped <IPersonBusiness, PersonBusinessImpl>(); services.AddScoped <IBookBusiness, BookBusinessImpl>(); services.AddScoped <ILoginBusiness, LoginBusinessImpl>(); services.AddScoped <IFileBusiness, FileBusinessImpl>(); services.AddScoped <IUserRepository, UserRepositoryImpl>(); services.AddScoped <IPersonRepository, PersonRepositoryImpl>(); services.AddScoped <IBookRepository, BookRepositoryImpl>(); services.AddScoped( typeof(IRepository <>), typeof(GenericRepository <>) ); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.AddDbContext <Context>(op => op.UseMySQL(Configuration.GetConnectionString("Atena")) .UseLoggerFactory(loggerFactory) .EnableSensitiveDataLogging() .EnableDetailedErrors()); //services.AddDbContext<Context>(op => op.UseSqlServer(Configuration.GetConnectionString("Atena_SqlServer")) //.LogTo(Console.WriteLine, LogLevel.Information) // .EnableSensitiveDataLogging() // .EnableDetailedErrors()); services = InjecaoDependencia(services); var signingConfigurations = new SigningConfigurations(); services.AddSingleton(signingConfigurations); var tokenConfigurations = new TokenConfigurations(); new ConfigureFromConfigurationOptions <TokenConfigurations>( Configuration.GetSection("TokenConfigurations")) .Configure(tokenConfigurations); services.AddSingleton(tokenConfigurations); services.AddCors(options => { options.AddPolicy(name: MyAllowSpecificOrigins, builder => { builder.WithOrigins("http://localhost:4200", "https://localhost:4200", "https://localhost:5001", "https://bardochiquinho.acmesistemas.com.br", "http://atena.acmesistemas.com.br") .AllowAnyHeader() .AllowAnyMethod(); }); }); services.AddAuthentication(authOptions => { authOptions.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme; authOptions.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme; }).AddJwtBearer(bearerOptions => { var paramsValidation = bearerOptions.TokenValidationParameters; paramsValidation.IssuerSigningKey = signingConfigurations.Key; paramsValidation.ValidAudience = tokenConfigurations.Audience; paramsValidation.ValidIssuer = tokenConfigurations.Issuer; // Valida a assinatura de um token recebido paramsValidation.ValidateIssuerSigningKey = true; // Verifica se um token recebido ainda é válido paramsValidation.ValidateLifetime = true; paramsValidation.SaveSigninToken = true; // Tempo de tolerância para a expiração de um token (utilizado // caso haja problemas de sincronismo de horário entre diferentes // computadores envolvidos no processo de comunicação) paramsValidation.ClockSkew = TimeSpan.Zero; }); services.AddAuthorization(auth => { auth.AddPolicy("Bearer", new AuthorizationPolicyBuilder() .AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme) .RequireAuthenticatedUser().Build()); }); services.AddAutoMapper(AppDomain.CurrentDomain.GetAssemblies()); services.AddControllers() .AddJsonOptions(x => x.JsonSerializerOptions.ReferenceHandler = ReferenceHandler.IgnoreCycles) .AddOData((opt, srv) => { opt.AddRouteComponents(GetEdmModel()).Filter() .Count() .Expand() .OrderBy() .SkipToken() .EnableQueryFeatures() .Select(); srv.CreateScope(); }); services.AddSwaggerGen(c => { c.SwaggerDoc("v1", new OpenApiInfo { Title = "Atena", Version = "v1" }); c.AddSecurityDefinition( "Bearer", new OpenApiSecurityScheme { Name = "Authorization", Type = SecuritySchemeType.ApiKey, Scheme = "Bearer", BearerFormat = "JWT", In = ParameterLocation.Header, Description = "Please enter JWT with Bearer into field" }); c.AddSecurityRequirement(new OpenApiSecurityRequirement() { { new OpenApiSecurityScheme { Reference = new OpenApiReference { Type = ReferenceType.SecurityScheme, Id = "Bearer" }, Scheme = "oauth2", Name = "Bearer", In = ParameterLocation.Header, }, new List <string>() } }); }); }
public object Post( [FromBody] User usuario, [FromServices] UserManager <ApplicationUser> userManager, [FromServices] SignInManager <ApplicationUser> signInManager, [FromServices] SigningConfigurations signingConfigurations, [FromServices] TokenConfigurations tokenConfigurations) { bool credenciaisValidas = false; if (usuario != null && !String.IsNullOrWhiteSpace(usuario.UserID)) { // Verifica a existência do usuário nas tabelas do // ASP.NET Core Identity var userIdentity = userManager .FindByNameAsync(usuario.UserID).Result; if (userIdentity != null) { // Efetua o login com base no Id do usuário e sua senha var resultadoLogin = signInManager .CheckPasswordSignInAsync(userIdentity, usuario.Password, false) .Result; if (resultadoLogin.Succeeded) { // Verifica se o usuário em questão possui // a role Acesso-APIAlturas credenciaisValidas = userManager.IsInRoleAsync( userIdentity, Roles.ROLE_API_ALTURAS).Result; } } } if (credenciaisValidas) { ClaimsIdentity identity = new ClaimsIdentity( new GenericIdentity(usuario.UserID, "Login"), new[] { new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")), new Claim(JwtRegisteredClaimNames.UniqueName, usuario.UserID) } ); DateTime dataCriacao = DateTime.Now; DateTime dataExpiracao = dataCriacao + TimeSpan.FromSeconds(tokenConfigurations.Seconds); var handler = new JwtSecurityTokenHandler(); var securityToken = handler.CreateToken(new SecurityTokenDescriptor { Issuer = tokenConfigurations.Issuer, Audience = tokenConfigurations.Audience, SigningCredentials = signingConfigurations.SigningCredentials, Subject = identity, NotBefore = dataCriacao, Expires = dataExpiracao }); var token = handler.WriteToken(securityToken); return(new { authenticated = true, created = dataCriacao.ToString("yyyy-MM-dd HH:mm:ss"), expiration = dataExpiracao.ToString("yyyy-MM-dd HH:mm:ss"), accessToken = token, message = "OK" }); } else { return(new { authenticated = false, message = "Falha ao autenticar" }); } }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.AddDbContext <ApplicationContext>(options => { options .UseLazyLoadingProxies() .EnableSensitiveDataLogging() .UseNpgsql(Environment.GetEnvironmentVariable("DATABASE_URL").ToConnectionString() ?? Configuration.GetConnectionString("Default")); }); services.AddCors(options => { options.AddDefaultPolicy( builder => { builder.AllowAnyOrigin().AllowAnyHeader().AllowAnyMethod(); }); }); services .AddIdentity <User, IdentityRole <long> >(options => { options.Password.RequireDigit = true; options.Password.RequiredLength = 6; options.Password.RequiredUniqueChars = 0; options.Password.RequireLowercase = true; options.Password.RequireUppercase = false; options.Password.RequireNonAlphanumeric = false; }) .AddEntityFrameworkStores <ApplicationContext>() .AddDefaultTokenProviders(); var signingConfigurations = new SigningConfigurations(); services.AddSingleton(signingConfigurations); var tokenConfiguration = new TokenConfigurations(); new ConfigureFromConfigurationOptions <TokenConfigurations>( Configuration.GetSection(nameof(TokenConfigurations)) ).Configure(tokenConfiguration); services.AddSingleton(tokenConfiguration); services.AddScoped <ILifeService, LifeService>(); services.AddScoped <IFeedbackService, FeedbackService>(); services.AddScoped <IProgressStepsLifeService, ProgressStepsLifeService>(); services.AddAutoMapper(GetType().Assembly); services.AddAuthentication().AddJwtBearer("Bearer", options => { var paramsValidation = options.TokenValidationParameters; paramsValidation.ValidateAudience = true; paramsValidation.ValidAudience = tokenConfiguration.Audience; paramsValidation.ValidateIssuerSigningKey = true; paramsValidation.ValidateIssuer = true; paramsValidation.ValidIssuer = tokenConfiguration.Issuer; paramsValidation.ValidateLifetime = true; paramsValidation.ClockSkew = TimeSpan.Zero; paramsValidation.IssuerSigningKey = signingConfigurations.Key; }); services.AddAuthorization(options => { options.AddPolicy( "Bearer", new AuthorizationPolicyBuilder() .AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme) .RequireAuthenticatedUser() .Build() ); }); services.AddControllers(); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { //habilita cors para comunicação com ionic services.AddCors(o => o.AddPolicy("MyPolicy", builder => { builder.AllowAnyOrigin() .AllowAnyMethod() .AllowAnyHeader(); })); //inicializando o entity framework, definindo ele como uma serviço services.AddDbContext <CadastroContext>(options => options.UseSqlServer(Configuration.GetConnectionString("ConexaoDbCadastro"))); services.AddTransient <User>(); var signingConfigurations = new SigningConfigurations(); services.AddSingleton(signingConfigurations); var tokenConfigurations = new TokenConfiguration(); new ConfigureFromConfigurationOptions <TokenConfiguration>( Configuration.GetSection("ConfiguracaoToken")) .Configure(tokenConfigurations); services.AddSingleton(tokenConfigurations); services.AddAuthentication(authOptions => { authOptions.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme; authOptions.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme; }).AddJwtBearer(bearerOptions => { var paramsValidation = bearerOptions.TokenValidationParameters; paramsValidation.IssuerSigningKey = signingConfigurations.Key; paramsValidation.ValidAudience = tokenConfigurations.Audience; paramsValidation.ValidIssuer = tokenConfigurations.Issuer; // Valida a assinatura de um token recebido paramsValidation.ValidateIssuerSigningKey = true; // Verifica se um token recebido ainda é válido paramsValidation.ValidateLifetime = true; // Tempo de tolerância para a expiração de um token (utilizado // caso haja problemas de sincronismo de horário entre diferentes // computadores envolvidos no processo de comunicação) paramsValidation.ClockSkew = TimeSpan.Zero; }); // Ativa o uso do token como forma de autorizar o acesso // a recursos deste projeto services.AddAuthorization(auth => { auth.AddPolicy("Bearer", new AuthorizationPolicyBuilder() .AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme) .RequireAuthenticatedUser().Build()); }); services.AddSingleton(Configuration.GetSection("ConfiguracaoToken").Get <TokenConfiguration>()); // services.Configure<ConfiguracaoToken>(Configuration.GetSection("ConfiguracaoToken")); services.AddMvc(); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.AddControllers(); ConfigureService.ConfigureDependenciesService(services); ConfigureRepository.ConfigureDependenciesRepository(services); var config = new AutoMapper.MapperConfiguration(cfg => { cfg.AddProfile(new DtoToModelProfile()); cfg.AddProfile(new EntityToDtoProfile()); cfg.AddProfile(new ModelToEntityProfile()); }); IMapper mapper = config.CreateMapper(); services.AddSingleton(mapper); var signingConfigurations = new SigningConfigurations(); services.AddSingleton(signingConfigurations); var tokenConfigurations = new TokenConfigurations(); new ConfigureFromConfigurationOptions <TokenConfigurations>( Configuration.GetSection("TokenConfigurations")) .Configure(tokenConfigurations); services.AddSingleton(tokenConfigurations); services.AddAuthentication(authOptions => { authOptions.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme; authOptions.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme; }).AddJwtBearer(bearerOptions => { var paramsValidation = bearerOptions.TokenValidationParameters; paramsValidation.IssuerSigningKey = signingConfigurations.Key; paramsValidation.ValidAudience = tokenConfigurations.Audience; paramsValidation.ValidIssuer = tokenConfigurations.Issuer; // Valida a assinatura de um token recebido paramsValidation.ValidateIssuerSigningKey = true; // Verifica se um token recebido ainda é válido paramsValidation.ValidateLifetime = true; // Tempo de tolerância para a expiração de um token (utilizado // caso haja problemas de sincronismo de horário entre diferentes // computadores envolvidos no processo de comunicação) paramsValidation.ClockSkew = TimeSpan.Zero; }); // Ativa o uso do token como forma de autorizar o acesso // a recursos deste projeto services.AddAuthorization(auth => { auth.AddPolicy("Bearer", new AuthorizationPolicyBuilder() .AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme) .RequireAuthenticatedUser().Build()); }); services.AddSwaggerGen(c => { c.SwaggerDoc("v1", new OpenApiInfo { Version = "v1", Title = "WebApi AspNetCore", Description = "Arquitetura DDD", TermsOfService = new Uri("http://www.google.com.br"), Contact = new OpenApiContact { Name = "Nome", Email = "*****@*****.**", Url = new Uri("http://www.google.com.br") }, License = new OpenApiLicense { Name = "Termo de Licença de Uso", Url = new Uri("http://www.google.com.br") } }); c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme { Description = "Entre com o Token JWT", Name = "Authorization", In = ParameterLocation.Header, Type = SecuritySchemeType.ApiKey }); c.AddSecurityRequirement(new OpenApiSecurityRequirement { { new OpenApiSecurityScheme { Reference = new OpenApiReference { Id = "Bearer", Type = ReferenceType.SecurityScheme } }, new List <string>() } }); }); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { //services.AddSingleton<DaniQuizContext>(); //var connection = @"Data Source=(LocalDb)\MSSQLLocalDB;Initial Catalog=aspnet-MvcMovie-fefdc1f0-bd81-4ce9-b712-93a062e01031;Integrated Security=SSPI;AttachDBFilename=|DataDirectory|\aspnet-MvcMovie-fefdc1f0-bd81-4ce9-b712-93a062e01031.mdf"; //services.AddDbContext<DaniQuizContext> // (options => options.UseSqlServer(connection)); services.AddDbContext <DaniQuizContext>(options => options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"))); services.AddScoped <IAppUsuarioLogin, AppUsuarioLogin>(); services.AddScoped <IAppCadastrar, AppCadastrar>(); services.AddScoped <IAppEnquete, AppEnquete>(); var signingConfigurations = new SigningConfigurations(); services.AddSingleton(signingConfigurations); var tokenConfigurations = new TokenConfigurations(); new ConfigureFromConfigurationOptions <TokenConfigurations>( Configuration.GetSection("TokenConfigurations")) .Configure(tokenConfigurations); services.AddSingleton(tokenConfigurations); services.AddAuthentication(authOptions => { authOptions.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme; authOptions.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme; }).AddJwtBearer(bearerOptions => { var paramsValidation = bearerOptions.TokenValidationParameters; paramsValidation.IssuerSigningKey = signingConfigurations.Key; paramsValidation.ValidAudience = tokenConfigurations.Audience; paramsValidation.ValidIssuer = tokenConfigurations.Issuer; // Valida a assinatura de um token recebido paramsValidation.ValidateIssuerSigningKey = true; // Verifica se um token recebido ainda é válido paramsValidation.ValidateLifetime = true; // Tempo de tolerância para a expiração de um token (utilizado // caso haja problemas de sincronismo de horário entre diferentes // computadores envolvidos no processo de comunicação) paramsValidation.ClockSkew = TimeSpan.Zero; }); // Ativa o uso do token como forma de autorizar o acesso // a recursos deste projeto services.AddAuthorization(auth => { auth.AddPolicy("Bearer", new AuthorizationPolicyBuilder() .AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme) .RequireAuthenticatedUser().Build()); }); services.AddCors(); services.AddMvc(); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.AddCors(options => { options.AddPolicy("CorsPolicy", builder => builder.AllowAnyOrigin() .AllowAnyMethod() .AllowAnyHeader() .AllowCredentials()); }); services.AddMvc(); // Configure Identity string connectionString = "Data Source=200.98.165.60;UID=sa;PWD=29800f8ce4ea41d2b2b2cee8f71f5d02"; services.AddDbContext <IdentityDbContext>(options => options.UseSqlServer(connectionString, providerOptions => providerOptions.CommandTimeout(60).MigrationsAssembly("Identity.API"))); services.AddIdentity <IdentityUser, IdentityRole>() .AddEntityFrameworkStores <IdentityDbContext>() .AddDefaultTokenProviders(); services.Configure <IdentityOptions>(options => { options.Password.RequireDigit = false; options.Password.RequiredLength = 6; options.Password.RequireLowercase = false; options.Password.RequireNonAlphanumeric = false; options.Password.RequireUppercase = false; }); services.Configure <IdentityOptions>(options => { options.SignIn.RequireConfirmedEmail = true; }); // Messages services.AddTransient <IMessageService, EmailMessageService>(); // Security services.AddTransient <ITokenGenerator, TokenGenerator>(); var signingConfigurations = new SigningConfigurations(); services.AddSingleton(signingConfigurations); var tokenConfigurations = new TokenConfigurations(); new ConfigureFromConfigurationOptions <TokenConfigurations>( Configuration.GetSection("TokenConfigurations")) .Configure(tokenConfigurations); services.AddSingleton(tokenConfigurations); services.AddAuthentication(authOptions => { authOptions.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme; authOptions.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme; }).AddJwtBearer(bearerOptions => { var paramsValidation = bearerOptions.TokenValidationParameters; paramsValidation.IssuerSigningKey = signingConfigurations.Key; paramsValidation.ValidAudience = tokenConfigurations.Audience; paramsValidation.ValidIssuer = tokenConfigurations.Issuer; // Valida a assinatura de um token recebido paramsValidation.ValidateIssuerSigningKey = true; // Verifica se um token recebido ainda é válido paramsValidation.ValidateLifetime = true; // Tempo de tolerância para a expiração de um token (utilizado // caso haja problemas de sincronismo de horário entre diferentes // computadores envolvidos no processo de comunicação) paramsValidation.ClockSkew = TimeSpan.Zero; }); // Ativa o uso do token como forma de autorizar o acesso // a recursos deste projeto services.AddAuthorization(auth => { auth.AddPolicy("Bearer", new AuthorizationPolicyBuilder() .AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme) .RequireAuthenticatedUser().Build()); }); }
public LoginBusinessImpl(IWebUserRepository repository, SigningConfigurations signingConfigurations, TokenConfiguration tokenConfiguration) { _repository = repository; _signingConfigurations = signingConfigurations; _tokenConfigurations = tokenConfiguration; }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { // Injeção de Dependência ConfigureRepository.ConfigureDependenceRepository(services); ConfigureService.ConfigureDependenceInjection(services); var config = new AutoMapper.MapperConfiguration(cfg => { cfg.AddProfile(new DtoToModelProfile()); cfg.AddProfile(new EntitiToDtoProfile()); cfg.AddProfile(new ModelToEntityProfile()); }); IMapper mapper = config.CreateMapper(); services.AddSingleton(mapper); var signingConfiguration = new SigningConfigurations(); services.AddSingleton(signingConfiguration); // Authentication var tokenConfiguration = new TokenConfiguration(); new ConfigureFromConfigurationOptions <TokenConfiguration>(Configuration.GetSection("TokenConfiguration")).Configure(tokenConfiguration); services.AddSingleton(tokenConfiguration); services.AddAuthentication(authOptions => { authOptions.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme; authOptions.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme; }).AddJwtBearer(bearerOptions => { var paramsValidation = bearerOptions.TokenValidationParameters; paramsValidation.IssuerSigningKey = signingConfiguration.Key; paramsValidation.ValidAudience = tokenConfiguration.Audience; paramsValidation.ValidIssuer = tokenConfiguration.Issuer; paramsValidation.ValidateIssuerSigningKey = true; paramsValidation.ValidateLifetime = true; paramsValidation.ClockSkew = TimeSpan.Zero; }); services.AddAuthorization(auth => { auth.AddPolicy("Admin", new AuthorizationPolicyBuilder() .AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme) .RequireAuthenticatedUser() .RequireRole("Admin").Build()); auth.AddPolicy("UserAdmin", new AuthorizationPolicyBuilder() .AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme) .RequireAuthenticatedUser() .RequireRole("UserAdmin", "Admin").Build()); auth.AddPolicy("User", new AuthorizationPolicyBuilder() .AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme) .RequireAuthenticatedUser() .RequireRole("UserAdmin", "Admin", "User").Build()); }); // Swagger services.AddSwaggerGen(c => { c.SwaggerDoc("v1", new Microsoft.OpenApi.Models.OpenApiInfo { Title = "SRJ - Serviço de Doações", Version = "1.0.0", Description = "SRJ Micro Services Version 1.0.0 ", Contact = new Microsoft.OpenApi.Models.OpenApiContact { Name = "SRJ Soluções", Email = "*****@*****.**" } }); c.AddSecurityDefinition("User", new OpenApiSecurityScheme { In = ParameterLocation.Header, Description = "Entre com o Token JWT", Name = "Authorization", Type = SecuritySchemeType.ApiKey }); c.AddSecurityRequirement(new OpenApiSecurityRequirement { { new OpenApiSecurityScheme { Reference = new OpenApiReference { Type = ReferenceType.SecurityScheme, Id = "User" } }, new List <string>() } }); }); // Instalar no IIS services.Configure <IISOptions>(o => { o.ForwardClientCertificate = false; }); services.AddCors(options => { options.AddPolicy(MyAllowSpecificOrigins, builder => builder .AllowAnyOrigin() .AllowAnyMethod() .AllowAnyHeader() //.SetIsOriginAllowed(origin => true) //.AllowCredentials() ); }); services.AddControllers() .AddNewtonsoftJson(); }