private AccessDataDTO GenerateToken(string userID, SigningConfigurationsDTO signingConfigurations, TokenConfigurationsDTO tokenConfigurations, IDistributedCache cache)
{
ClaimsIdentity identity = new ClaimsIdentity(
new GenericIdentity(userID, "IDUsuario"),
new[] {
new Claim("IDUsuario", userID)
}
);
DateTime dataCriacao = DateTime.Now;
DateTime dataExpiracao = dataCriacao + TimeSpan.FromSeconds(tokenConfigurations.Seconds);
// Calcula o tempo máximo de validade do refresh token
// (o mesmo será invalidado automaticamente pelo Redis)
TimeSpan finalExpiration = TimeSpan.FromSeconds(tokenConfigurations.FinalExpiration);
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);
AccessDataDTO resultado = new AccessDataDTO();
resultado.AccessToken = token;
resultado.RefreshToken = Guid.NewGuid().ToString().Replace("-", String.Empty);
resultado.Created = dataCriacao.ToString("yyyy-MM-dd HH:mm:ss");
resultado.Expiration = dataExpiracao.ToString("yyyy-MM-dd HH:mm:ss");
// Armazena o refresh token em cache através do Redis
var refreshTokenData = new RefreshTokenDataDTO();
refreshTokenData.RefreshToken = resultado.RefreshToken;
refreshTokenData.IDUsuario = userID;
DistributedCacheEntryOptions opcoesCache = new DistributedCacheEntryOptions();
opcoesCache.SetAbsoluteExpiration(finalExpiration);
cache.SetString(resultado.RefreshToken, JsonConvert.SerializeObject(refreshTokenData), opcoesCache);
return(resultado);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddTransient <UsuariosDAO>();
services.AddTransient <TreinosDAO>();
services.AddMvc().SetCompatibilityVersion(Microsoft.AspNetCore.Mvc.CompatibilityVersion.Version_2_1);
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new Microsoft.OpenApi.Models.OpenApiInfo
{
Version = "v1",
Title = "Treino API",
Description = ""
});
});
string conn = @"Data Source=Lucas-PC;Initial Catalog=Treino;User ID=USR_Treino;Password=081991@RAtm";
services.AddDistributedSqlServerCache(opt =>
{
opt.ConnectionString = conn;
opt.SchemaName = "dbo";
opt.TableName = "SQLCache";
});
var signingConfigurations = new SigningConfigurationsDTO();
services.AddSingleton(signingConfigurations);
var tokenConfigurations = new TokenConfigurationsDTO();
new ConfigureFromConfigurationOptions <TokenConfigurationsDTO>(
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(options =>
{
options.AddPolicy(MyAllowSpecificOrigins,
builder =>
{
builder.WithOrigins("*")
.AllowAnyHeader()
.AllowAnyMethod();
});
});
services.Configure <MvcOptions>(options =>
{
options.Filters.Add(new CorsAuthorizationFilterFactory("AllowOthersOrigins"));
});
services.AddMvc(config =>
{
var policy = new AuthorizationPolicyBuilder()
.RequireAuthenticatedUser()
.Build();
config.Filters.Add(new AuthorizeFilter(policy));
});
services.AddMvc();
}
public IActionResult PostLogin([FromBody] LoginDTO login,
[FromServices] UsuariosDAO usuariosDAO,
[FromServices] SigningConfigurationsDTO signingConfigurations,
[FromServices] TokenConfigurationsDTO tokenConfigurations,
[FromServices] IDistributedCache cache)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
bool credenciaisValidas = false;
var _IDUsuario = string.Empty;
AccessDataDTO _accessData = new AccessDataDTO();
try
{
if (login.Grant_Type == "password")
{
var _usuario = usuariosDAO.SelectUsuarioPorCredenciais(login.Email, login.Password);
credenciaisValidas = (_usuario != null);
if (credenciaisValidas)
{
if (_usuario.Ativo == false)
{
return(BadRequest("Usuário bloqueado! Entre em contato com o administrador."));
}
_IDUsuario = _usuario.IDUsuario.ToString();
}
}
else if (login.Grant_Type == "refresh_token")
{
RefreshTokenDataDTO refreshTokenBase = null;
string strTokenArmazenado = cache.GetString(login.RefreshToken);
if (!String.IsNullOrWhiteSpace(strTokenArmazenado))
{
refreshTokenBase = JsonConvert.DeserializeObject <RefreshTokenDataDTO>(strTokenArmazenado);
}
credenciaisValidas = (refreshTokenBase != null && login.RefreshToken == refreshTokenBase.RefreshToken);
// Elimina o token de refresh já que um novo será gerado
if (credenciaisValidas)
{
_IDUsuario = refreshTokenBase.IDUsuario;
cache.Remove(login.RefreshToken);
}
}
else
{
return(BadRequest("Invalid grant_type"));
}
if (!credenciaisValidas)
{
return(BadRequest("Usuário ou senha inválidos. Caso não se lembre, clique em esqueci minha senha!"));
}
_accessData = GenerateToken(_IDUsuario, signingConfigurations, tokenConfigurations, cache);
SaveSessao(_IDUsuario, login, _accessData);
}
catch (Exception ex)
{
return(BadRequest(ex));
}
return(Ok(_accessData));
}
