/// <summary>
/// Registrar os servicos referentes a autenticacao da aplicacao
/// </summary>
/// <param name="services"></param>
/// <param name="configuration"></param>
public static void Registrar(IServiceCollection services, IConfiguration configuration)
{
_configuracaoToken = new ConfiguracaoToken();
new ConfigureFromConfigurationOptions <ConfiguracaoToken>(
configuration.GetSection(nameof(ConfiguracaoToken)))
.Configure(_configuracaoToken);
services.AddSingleton(_configuracaoToken);
services
.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
.AddJwtBearer(bearrerOptions =>
{
var parametrosValidacao = bearrerOptions.TokenValidationParameters;
parametrosValidacao.ValidateIssuerSigningKey = true;
parametrosValidacao.ValidateLifetime = true;
parametrosValidacao.ValidateActor = true;
parametrosValidacao.ValidateAudience = true;
parametrosValidacao.ValidAudience = _configuracaoToken.Audience;
parametrosValidacao.ValidIssuer = _configuracaoToken.Issuer;
parametrosValidacao.ClockSkew = TimeSpan.Zero;
parametrosValidacao.IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuracaoToken.SigningKey));
});
services.AddAuthorization(auth =>
{
auth.AddPolicy("Bearer", new AuthorizationPolicyBuilder()
.AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme)
.RequireAuthenticatedUser().Build());
});
services.AddMemoryCache();
}
public IActionResult Post([FromBody] VisaoModeloUsuario usuario,
[FromServices] SegurancaJWT signingConfigurations,
[FromServices] ConfiguracaoToken tokenConfigurations)
{
try
{
_autorizarUsuarioVisaoModelo.ValidarUsuarioAutorizado(usuario.Login, usuario.Senha);
return(Ok(GetToken(usuario, signingConfigurations, tokenConfigurations)));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc();
services.AddCors();
services.AddSingleton <string>(Configuration.GetConnectionString("LiteDB"));
services.AddSingleton(typeof(CrudService <>), typeof(CrudService <>));
services.AddTransient <UsuarioService>();
services.AddTransient <EventoService>();
var configuracaoAcesso = new ConfiguracaoAcesso();
services.AddSingleton(configuracaoAcesso);
var configuracaoToken = new ConfiguracaoToken();
new ConfigureFromConfigurationOptions <ConfiguracaoToken>
(Configuration.GetSection("ConfiguracaoToken")).Configure(configuracaoToken);
services.AddSingleton(configuracaoToken);
services.AddAuthentication(opcoes =>
{
opcoes.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
opcoes.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(bearer =>
{
var parametrosValidacao = bearer.TokenValidationParameters;
parametrosValidacao.IssuerSigningKey = configuracaoAcesso.Key;
parametrosValidacao.ValidAudience = configuracaoToken.Audience;
parametrosValidacao.ValidIssuer = configuracaoToken.Issuer;
parametrosValidacao.ValidateIssuerSigningKey = true;
parametrosValidacao.ValidateLifetime = true;
parametrosValidacao.ClockSkew = TimeSpan.Zero;
});
services.AddAuthorization(auth => {
auth.AddPolicy("Bearer", new AuthorizationPolicyBuilder()
.AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme)
.RequireAuthenticatedUser().Build());
});
Database.Configuration.Configure(Configuration.GetConnectionString("LiteDB"));
}
protected object GetToken([FromBody] VisaoModeloUsuario usuario,
[FromServices] SegurancaJWT signingConfigurations,
[FromServices] ConfiguracaoToken tokenConfigurations)
{
try
{
ClaimsIdentity identity = new ClaimsIdentity(
new GenericIdentity(usuario.Login, "login"),
new[] {
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")),
new Claim(JwtRegisteredClaimNames.UniqueName, usuario.Login)
}
);
DateTime dataCriacao = DateTime.Now;
DateTime dataExpiracao = dataCriacao +
TimeSpan.FromMinutes(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
});
}
catch (Exception ex)
{
throw ex;
}
}
private static void RegistrarChavesAppSettings(IServiceCollection service, IConfiguration configuration)
{
_configuracaoConexao = new ConfiguracaoConexao();
var conexaoConfig = configuration.GetSection(ConfiguracaoConexao);
new ConfigureFromConfigurationOptions <ConfiguracaoConexao>(conexaoConfig).Configure(_configuracaoConexao);
service.AddSingleton(_configuracaoConexao);
_configuracaoToken = new ConfiguracaoToken();
var configuracaoToken = configuration.GetSection(ConfiguracaoToken);
new ConfigureFromConfigurationOptions <ConfiguracaoToken>(configuracaoToken).Configure(_configuracaoToken);
service.AddSingleton(_configuracaoToken);
}
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Latest);
services.AddDbContext <ContextDb>(options =>
options.UseSqlServer(Configuration.GetSection("ConnectionDevelopment").Value));
services.AddIdentity <UsuarioAplicativo, IdentityRole>()
.AddEntityFrameworkStores <ContextDb>()
.AddDefaultTokenProviders();
var configuracoesAssinatura = new ConfiguracoesAssinatura();
services.AddSingleton(configuracoesAssinatura);
var tokenConfigurations = new ConfiguracaoToken();
new ConfigureFromConfigurationOptions <ConfiguracaoToken>(
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 = configuracoesAssinatura.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());
});
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new Info
{
Title = "PalmSoft Swagger",
Version = "v1",
});
c.AddSecurityDefinition("Bearer", new ApiKeyScheme
{
Description = "Utilizar a autenticação para geração do token em Token/Get e adicionar a chave conforme exemplo Example: Bearer {chave gerada pelo endpoint token/get}",
Name = "Authorization",
In = "header",
Type = "apiKey"
});
c.AddSecurityRequirement(new Dictionary <string, IEnumerable <string> >
{
{
"Bearer", Enumerable.Empty <string>()
}
});
var xmlFile = Path.ChangeExtension(typeof(Startup).Assembly.Location, ".xml");
c.IncludeXmlComments(xmlFile);
});
services.AddMvc();
}
public UsuarioController(UsuarioService servico, ConfiguracaoToken configToken, ConfiguracaoAcesso configAcesso) : base(servico)
{
ConnectionString = servico.ConnectionString;
Token = configToken;
Acesso = configAcesso;
}
public object Post([FromBody] Usuario usuario, [FromServices] UserManager <UsuarioAplicativo> userManager,
[FromServices] SignInManager <UsuarioAplicativo> signInManager,
[FromServices] ConfiguracoesAssinatura signingConfigurations,
[FromServices] ConfiguracaoToken tokenConfigurations)
{
bool credenciaisValidas = false;
if (usuario != null && !String.IsNullOrWhiteSpace(usuario.Email))
{
var userIdentity = userManager.FindByNameAsync(usuario.Email).Result;
if (userIdentity != null)
{
var resultadoLogin = signInManager.CheckPasswordSignInAsync(userIdentity, usuario.Senha, false).Result;
if (resultadoLogin.Succeeded)
{
credenciaisValidas = userManager.IsInRoleAsync(userIdentity, Funcoes.Role_Fotos).Result;
}
}
}
if (credenciaisValidas)
{
ClaimsIdentity identity = new ClaimsIdentity(
new GenericIdentity(usuario.Email, "Login"),
new[] {
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")),
new Claim(JwtRegisteredClaimNames.UniqueName, usuario.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
{
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"
});
}
}
