private AccountResponse AccountFromMobileServiceUser(MobileServiceUser user)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
IDictionary <string, string> claims = JwtUtility.GetClaims(user.MobileServiceAuthenticationToken);
var account = new AccountResponse();
account.Success = true;
account.User = new User
{
//Id = Guid.Parse(user.UserId),
Id = Guid.Parse(claims[JwtClaimNames.Subject]),
FirstName = claims[JwtClaimNames.GivenName],
LastName = claims[JwtClaimNames.FamilyName],
Email = claims[JwtClaimNames.Email],
Role = claims[JwtClaimNames.Role],
};
account.Token = user.MobileServiceAuthenticationToken;
return(account);
}
private static void Main(string[] args)
{
JwtHeader head = new JwtHeader();
TokenPayload payload = new TokenPayload()
{
Username = "******",
IssuedAt = 1422979638,
BusinessUserID = 1,
BusinessID = 2,
AssignedBusinessIDs = new List <int>()
{
3, 4, 6
}
};
JwtUtility <JwtHeader, TokenPayload> jwtUtil = new JwtUtility <JwtHeader, TokenPayload>(head, payload);
string token = jwtUtil.ToString();
Log4netLogger.Info(MethodBase.GetCurrentMethod().DeclaringType, token);
Console.WriteLine();
Log4netLogger.Warn(MethodBase.GetCurrentMethod().DeclaringType, Validate(token));
Console.ReadLine();
}
public IActionResult Login([FromBody] LoginViewModel value)
{
try
{
User user = userRepository.Get(value.username).Copy();
if (Utilities.Pbkdf2Utility.ValidatePassword(value.password, user.Password))
{
user.Password = string.Empty;
string jwt = JwtUtility.GenerateJwt(user);
LoggedInViewModel loggedInViewModel = new LoggedInViewModel()
{
JWT = jwt,
User = user
};
return(Ok(loggedInViewModel));
}
}
catch { }
return(BadRequest("Invalid Username or Password"));
}
public async Task <IActionResult> Login([FromBody] LoginDto loginDto)
{
var user = await _userService.Login(loginDto.Username, loginDto.Password);
var sessionDto = _mapper.Map <SessionDto>(user);
var idToken = JwtUtility.CreateJwtToken(AppSettings, sessionDto);
Request.HttpContext.Response.Headers.Add(Constants.AccessToken, idToken);
return(Ok(user));
}
public void TestJwtEncode()
{
var name = "mauricio";
var dt1 = DateTime.Now;
var dt2 = DateTime.Now.AddMinutes(30);
var hash = JwtUtility.Encode(Guid.NewGuid(), UnixDateUtility.ConvertToUnixTimestamp(dt2), UnixDateUtility.ConvertToUnixTimestamp(dt1));
var decode = JwtUtility.Decode(hash);
}
protected Guid GetUserIdByToken(string token)
{
try{
var jsonToken = JwtUtility.Decode(token);
var tokenInfo = JsonUtility.Deserialize <Dictionary <string, object> >(jsonToken);
Guid userId;
Guid.TryParse(tokenInfo["userId"].ToString(), out userId);
return(userId);
}catch {
throw new SessionExpiredException(invalidSessionError);
}
}
public async Task JwtUtility_GenerateJwt_FncConnectGenerateJwtBehavior()
{
//Arrange
var fncConnectGenerateJwtBehavior = new FncConnectGenerateJwtBehavior(new HttpUtility(), TestHelper.GetConfigurationSettings());
var jwtUtility = new JwtUtility(null, fncConnectGenerateJwtBehavior);
//Act
var generateJwtResult = await jwtUtility.GenerateJwtAsync().ConfigureAwait(false);
//Assert
Assert.AreEqual(Status.Success, generateJwtResult.Status);
Assert.IsTrue(!string.IsNullOrEmpty(generateJwtResult.Result.Jwt));
}
public async Task <IActionResult> Register([FromBody] RegisterDto registerDto)
{
_userService.Validate(registerDto);
await _userService.Register(registerDto);
var user = _mapper.Map <UserDto>(registerDto);
var sessionDto = _mapper.Map <SessionDto>(user);
var idToken = JwtUtility.CreateJwtToken(AppSettings, sessionDto);
Request.HttpContext.Response.Headers.Add(Constants.AccessToken, idToken);
return(Ok(user));
}
public static string GetUsername(this HttpContextBase httpContext)
{
string username = null;
JwtUtility <JwtHeader, PayloadIdentity> jwtUtil = new JwtUtility <JwtHeader, PayloadIdentity>(new JwtHeader(), new PayloadIdentity());
string token = httpContext.GetAuthToken();
if (token != null)
{
PayloadIdentity payloadIdentity = jwtUtil.GetPayload(token);
username = payloadIdentity.Username;
}
return(username);
}
public void TestWrongUser()
{
User user = new User()
{
Id = 837,
Username = "******",
Password = "******"
};
string jwt = JwtUtility.GenerateJwt(user);
int?userId = JwtUtility.ReadJwt(jwt);
Assert.AreNotEqual(400, userId);
}
public async Task JwtUtility_HealthCheck_FncConnectBehaviors()
{
//Arrange
var fncConnectGenerateJwtBehavior = new FncConnectGenerateJwtBehavior(new HttpUtility(), TestHelper.GetConfigurationSettings());
var fncConnectValidateJwtBehavior = new FncConnectValidateJwtBehavior(new HttpUtility(), TestHelper.GetConfigurationSettings());
var jwtUtility = new JwtUtility(fncConnectValidateJwtBehavior, fncConnectGenerateJwtBehavior);
var healthcheckNotifierUtility = new Mock <IHealthCheckNotifierUtility>();
//Act
var healthCheckUtility = new HealthCheckUtility(new List <IHealthCheckable>()
{
jwtUtility
}, healthcheckNotifierUtility.Object, TestHelper.GetConfigurationSettings());
//Assert
Assert.AreEqual(HealthStatus.Active, (await healthCheckUtility.GetHealthCheckResultAsync().ConfigureAwait(false)).Status);
}
public async Task JwtUtlity_GenerateJwt_ReturnsGenerateJwtBehaviorResult()
{
//Arrange
var generateJwtBehaviorResult = new GenerateJwtResult("jwt");
var jwtGenerateBehaviorMock = new Mock <IGenerateJwtBehavior>();
jwtGenerateBehaviorMock.Setup(x => x.GenerateJwtAsync(It.IsAny <int>(), It.IsAny <IEnumerable <KeyValuePair <string, string> > >()))
.Returns(Task.FromResult(HttpFragileOperationResult <GenerateJwtResult> .CreateSuccessfulResult(generateJwtBehaviorResult, HttpStatusCode.OK, "")));
var jwtUtility = new JwtUtility(null, jwtGenerateBehaviorMock.Object);
//Act
var result = await jwtUtility.GenerateJwtAsync().ConfigureAwait(false);
//Assert
Assert.AreEqual(generateJwtBehaviorResult.Jwt, result.Result.Jwt);
}
public async Task JwtUtlity_GenerateJwt_ReturnsValidateJwtBehaviorResult()
{
//Arrange
var validateJwtBehaviorResult = new ValidateJwtResult(true, "123");
var jwtValidateBehavior = new Mock <IValidateJwtBehavior>();
jwtValidateBehavior.Setup(x => x.ValidateJwtAsync(It.IsAny <string>())).Returns(Task.FromResult(HttpFragileOperationResult <ValidateJwtResult> .CreateSuccessfulResult(validateJwtBehaviorResult, HttpStatusCode.OK, "")));
var jwtUtility = new JwtUtility(jwtValidateBehavior.Object, null);
//Act
var result = await jwtUtility.ValidateJwtAsync("AnyJwt").ConfigureAwait(false);
//Assert
Assert.AreEqual(validateJwtBehaviorResult.ClientId, "123");
Assert.IsTrue(validateJwtBehaviorResult.IsValid);
Assert.AreEqual(0, result.ErrorMessages.Count());
}
public async Task FileUtility_FileVaultGetPublicUrlAsync_ReturnsErrorResult_WhenJwtGenerationErrors()
{
//Arrange
var jwtValidateBehavior = new Mock <IValidateJwtBehavior>();
var jwtGenerateBehaviorMock = new Mock <IGenerateJwtBehavior>();
jwtGenerateBehaviorMock.Setup(x => x.GenerateJwtAsync(It.IsAny <int>(), It.IsAny <IEnumerable <KeyValuePair <string, string> > >())).Returns(Task.FromResult(HttpFragileOperationResult <GenerateJwtResult> .CreateErrorResult(HttpStatusCode.InternalServerError, "", "ErrorMessage")));
var jwtUtility = new JwtUtility(jwtValidateBehavior.Object, jwtGenerateBehaviorMock.Object);
var fileUtility = new FileUtility(new Mock <IGetFileBehavior>().Object, new Mock <IStoreFileBehavior>().Object, new FileVaultGetPublicUrlBehavior(jwtUtility, TestHelper.GetConfigurationSettings()));
//Act
var result = await fileUtility.GetPublicUrlAsync(Guid.NewGuid().ToString()).ConfigureAwait(false);
//Assert
Assert.AreEqual(Status.Error, result.Status);
}
Invoke(Microsoft.AspNetCore.Http.HttpContext context, Application.Services.IUserService userService)
{
var requestHeaders =
context.Request.Headers["Authorization"];
var token =
requestHeaders
.FirstOrDefault()
?.Split(" ")
.Last();
if (token != null)
{
JwtUtility.AttachUserToContext(context: context,
userService: userService, token: token, secretKey: MainSettings.SecretKey);
}
await Next(context);
}
private bool AuthenticateCaptchaToken(string token, string secret)
{
try
{
var payload = JwtUtility.TryDecode(token, secret, _logger);
string nonce = payload.SelectToken("data.nonce")?.Value <string>();
if (nonce == CaptchaNonce)
{
return(true);
}
_logger.LogWarning("Could not match expected captcha {Nonce} in {Payload}", CaptchaNonce, payload.ToString());
return(false);
}
catch
{
return(false);
}
}
public IHttpActionResult Login([FromBody] Login login)
{
var existingUser = userService.GetUserByUsername(login.Username);
if (existingUser == null)
{
return(Unauthorized());
}
var isAuthenticated = Crypto.VerifyHashedPassword(existingUser.PasswordHash, login.Password);
if (!isAuthenticated)
{
return(Unauthorized());
}
var token = JwtUtility.CreateToken(existingUser);
var user = AuthMapper.LoginMap(existingUser, token);
return(Ok(user));
}
public static void SetAuthorizationCookie(this HttpContextBase httpContext, string username)
{
string key = Settings.InitSetting.Instance.AuthCookieName;
DateTime utcNow = DateTime.UtcNow;
PayloadIdentity identity = new PayloadIdentity()
{
IssuedAt = DateGenerator.ToUnixTimeStamp(utcNow),
ExpireAt = DateGenerator.ToUnixTimeStamp(utcNow) + Settings.InitSetting.Instance.AuthorizationTokenLifeSpanInSecond,
Username = username
};
JwtUtility <JwtHeader, PayloadIdentity> jwtUtil = new JwtUtility <JwtHeader, PayloadIdentity>(new JwtHeader(), identity);
string token = jwtUtil.ToString();
HttpCookie cookie = new HttpCookie(key);
cookie.HttpOnly = false;
cookie.Value = token;
cookie.Expires = DateTime.Now.AddSeconds(Settings.InitSetting.Instance.AuthorizationTokenLifeSpanInSecond);
httpContext.Response.Cookies.Add(cookie);
AddTokenIssued(username, token, DateGenerator.ZeroUnixTimestamp.AddSeconds(identity.IssuedAt), DateGenerator.ZeroUnixTimestamp.AddSeconds(identity.ExpireAt));
}
public async Task JwtUtlityHealthCheck_GetHealth_ReturnsWarningHealthCheckResult_WhenGenerateBehaviorResultsInError()
{
//Arrange
var validateJwtBehaviorResult = new ValidateJwtResult(true, "123");
var jwtValidateBehavior = new Mock <IValidateJwtBehavior>();
jwtValidateBehavior.Setup(x => x.ValidateJwtAsync(It.IsAny <string>())).Returns(Task.FromResult(HttpFragileOperationResult <ValidateJwtResult> .CreateSuccessfulResult(validateJwtBehaviorResult, HttpStatusCode.OK, "")));
var jwtGenerateBehaviorMock = new Mock <IGenerateJwtBehavior>();
jwtGenerateBehaviorMock.Setup(x => x.GenerateJwtAsync(It.IsAny <int>(), It.IsAny <IEnumerable <KeyValuePair <string, string> > >())).Returns(Task.FromResult(HttpFragileOperationResult <GenerateJwtResult> .CreateErrorResult(HttpStatusCode.InternalServerError, "", "TestMessage")));
var jwtUtility = new JwtUtility(jwtValidateBehavior.Object, jwtGenerateBehaviorMock.Object);
//Act
var result = await jwtUtility.GetHealthAsync().ConfigureAwait(false);
//Assert
Assert.AreEqual(HealthStatus.Warning, result.Status);
}
public async Task JwtUtlityHealthCheck_GetHealth_ReturnsCriticalHealthCheckResult_WhenValidateBehaviorResultIsFailed()
{
//Arrange
var jwtValidateBehavior = new Mock <IValidateJwtBehavior>();
jwtValidateBehavior.Setup(x => x.ValidateJwtAsync(It.IsAny <string>())).Returns(Task.FromResult(HttpFragileOperationResult <ValidateJwtResult> .CreateFailedResult(HttpStatusCode.BadRequest, "", "TestMessage")));
var generateJwtBehaviorResult = new GenerateJwtResult("jwt");
var jwtGenerateBehaviorMock = new Mock <IGenerateJwtBehavior>();
jwtGenerateBehaviorMock.Setup(x => x.GenerateJwtAsync(It.IsAny <int>(), It.IsAny <IEnumerable <KeyValuePair <string, string> > >())).Returns(Task.FromResult(HttpFragileOperationResult <GenerateJwtResult> .CreateSuccessfulResult(generateJwtBehaviorResult, HttpStatusCode.OK, "")));
var jwtUtility = new JwtUtility(jwtValidateBehavior.Object, jwtGenerateBehaviorMock.Object);
//Act
var result = await jwtUtility.GetHealthAsync().ConfigureAwait(false);
//Assert
Assert.AreEqual(HealthStatus.Critical, result.Status);
}
private AccountResponse AccountFromMobileServiceUser(MobileServiceUser user, string email = null)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
IDictionary <string, string> claims = JwtUtility.GetClaims(user.MobileServiceAuthenticationToken);
if (!claims.ContainsKey(JwtClaimNames.Subject) && !string.IsNullOrWhiteSpace(email))
{
claims.Add(JwtClaimNames.Subject, email);
}
var account = new AccountResponse();
account.Success = true;
account.User = new User(claims);
return(account);
}
public static bool IsAuthorized(string token, bool extendToken)
{
JwtUtility <JwtHeader, PayloadIdentity> jwtUtil = new JwtUtility <JwtHeader, PayloadIdentity>(new JwtHeader(), new PayloadIdentity());
PayloadIdentity payloadIdentity = null;
try
{
if (token != null)
{
payloadIdentity = jwtUtil.GetPayload(token);
}
}
catch (Exception) { }
bool isAuthorized = (token != null && jwtUtil.IsValid(token) && payloadIdentity != null && !payloadIdentity.isTokenExpired());
if (isAuthorized && extendToken)
{
ExtendTokenIssued(payloadIdentity.Username, token);
}
return(isAuthorized);
}
public async Task <IActionResult> Login([FromBody] AuthenticationModel authenticationModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(authenticationModel));
}
var login = await _userRepository.LoginAsync(authenticationModel);
if (login == null)
{
return((IActionResult) new NotAcceptableObjectResult(new JsonResult(Usernotfound)));
}
else
{
var httpConnectionFeature = HttpContext.Features.Get <IHttpConnectionFeature>();
var localIpAddress = httpConnectionFeature?.LocalIpAddress;
if (localIpAddress != null)
{
var jwtSettings = new JwtSettings
{
Issuer = localIpAddress.ToString(),
Audience = localIpAddress.ToString(),
ExpirationTime = 30,
JwtId = new Guid().ToString(),
NotBefore = new DateTime(),
Tenant = login.TenantGuid.ToString()
};
return(new OkObjectResult(
new JwtSecurityTokenHandler().WriteToken(JwtUtility.BuildToken(login, _config["Jwt:Key"],
jwtSettings))));
}
else
{
return(BadRequest());
}
}
}
public async Task JwtUtlityHealthCheck_GetHealth_ReturnsActiveHealthCheckResult_WhenAllGood()
{
//Arrange
var validateJwtBehaviorResult = new ValidateJwtResult(true, "123");
var jwtValidateBehavior = new Mock <IValidateJwtBehavior>();
jwtValidateBehavior.Setup(x => x.ValidateJwtAsync(It.IsAny <string>())).Returns(Task.FromResult(HttpFragileOperationResult <ValidateJwtResult> .CreateSuccessfulResult(validateJwtBehaviorResult, HttpStatusCode.OK, "")));
var generateJwtBehaviorResult = new GenerateJwtResult("jwt");
var jwtGenerateBehaviorMock = new Mock <IGenerateJwtBehavior>();
jwtGenerateBehaviorMock.Setup(x => x.GenerateJwtAsync(It.IsAny <int>(), It.IsAny <IEnumerable <KeyValuePair <string, string> > >())).Returns(Task.FromResult(HttpFragileOperationResult <GenerateJwtResult> .CreateSuccessfulResult(generateJwtBehaviorResult, HttpStatusCode.OK, "")));
var jwtUtility = new JwtUtility(jwtValidateBehavior.Object, jwtGenerateBehaviorMock.Object);
//Act
var result = await jwtUtility.GetHealthAsync().ConfigureAwait(false);
//Assert
Assert.AreEqual(HealthStatus.Active, result.Status);
Assert.AreEqual("JWT Generate/Validate", result.Description);
Assert.AreEqual(2, result.Vitals.Count);
}
protected void GenerateUserToken()
{
var token = JwtUtility.Encode(user.Id, UnixDateUtility.ConvertToUnixTimestamp(user.GetExpiration()), UnixDateUtility.ConvertToUnixTimestamp(user.LastLogon));
user.SetToken(token);
}
