/// <summary> /// Custom GetRoleClaimHistory Method /// </summary> /// <param name="userRoleClaimId">string</param> /// <param name="cancellationToken">CancellationToken</param> /// <returns>Task<List<AspNetUserRoleClaimHistory>></returns> /// <method>GetRoleClaimHistory(CancellationToken cancellationToken)</method> public async Task <List <AspNetUserRoleClaimHistory> > GetRoleClaimHistory(string userRoleClaimId, CancellationToken cancellationToken) { try { string accessToken = await GetAccessToken(); string jsonString = JsonConvert.SerializeObject(userRoleClaimId.Clean()); string encryptString = AESGCM.Encrypt(jsonString, accessToken); JsonClient jsonClient = new JsonClient(_apiBaseUrl, accessToken); HttpStatusCode statusCode = await jsonClient.SendRequest(HttpMethod.Post, "User/RoleClaimHistory", encryptString); if (!jsonClient.IsResponseSuccess) { _logger.Exception(new Exception(jsonClient.GetResponseString())); throw new Exception(jsonClient.GetResponseString()); } jsonString = AESGCM.Decrypt(jsonClient.GetResponseObject <string>(), accessToken); List <AspNetUserRoleClaimHistory> history = JsonConvert.DeserializeObject <List <AspNetUserRoleClaimHistory> >(jsonString); return(history); } catch (Exception exception) { _logger.Exception(exception); throw; } }
/// <summary> /// Implemented IUserClaimStore GetUsersForClaimAsync Method /// </summary> /// <param name="claim">Claim</param> /// <param name="cancellationToken">CancellationToken</param> /// <returns>Task</returns> /// <method>GetUsersForClaimAsync(Claim claim, CancellationToken cancellationToken)</method> public async Task <IList <ApplicationUser> > GetUsersForClaimAsync(Claim claim, CancellationToken cancellationToken) { try { string accessToken = await GetAccessToken(); string jsonString = JsonConvert.SerializeObject(claim, new JsonSerializerSettings() { ReferenceLoopHandling = ReferenceLoopHandling.Ignore }); string encryptString = AESGCM.Encrypt(jsonString, accessToken); JsonClient jsonClient = new JsonClient(_apiBaseUrl, accessToken); HttpStatusCode statusCode = await jsonClient.SendRequest(HttpMethod.Post, "User/FindByClaim", encryptString); if (!jsonClient.IsResponseSuccess) { _logger.Exception(new Exception(jsonClient.GetResponseString())); throw new Exception(jsonClient.GetResponseString()); } jsonString = AESGCM.Decrypt(jsonClient.GetResponseObject <string>(), accessToken); List <ApplicationUser> users = JsonConvert.DeserializeObject <List <ApplicationUser> >(jsonString); return(users); } catch (Exception exception) { _logger.Exception(exception); throw; } }
/// <summary> /// Implemented IUserEmailStore FindByEmailAsync Method /// </summary> /// <param name="normalizedEmail">string</param> /// <param name="cancellationToken">CancellationToken</param> /// <returns>Task<ApplicationUser></returns> /// <method>FindByEmailAsync(string normalizedEmail, CancellationToken cancellationToken)</method> public async Task <ApplicationUser> FindByEmailAsync(string normalizedEmail, CancellationToken cancellationToken) { try { string accessToken = await GetAccessToken(); string jsonString = JsonConvert.SerializeObject(normalizedEmail.Clean().ToUpper()); string encryptString = AESGCM.Encrypt(jsonString, accessToken); JsonClient jsonClient = new JsonClient(_apiBaseUrl, accessToken); HttpStatusCode statusCode = await jsonClient.SendRequest(HttpMethod.Post, "User/FindByNormalizedEmail", encryptString); if (!jsonClient.IsResponseSuccess) { _logger.Exception(new Exception(jsonClient.GetResponseString())); throw new Exception(jsonClient.GetResponseString()); } jsonString = AESGCM.Decrypt(jsonClient.GetResponseObject <string>(), accessToken); ApplicationUser user = JsonConvert.DeserializeObject <ApplicationUser>(jsonString); return(user); } catch (Exception exception) { _logger.Exception(exception); throw; } }
/// <summary> /// Custom GetApprovedUsersAsync Method /// </summary> /// <param name="roleId">string</param> /// <param name="roleClaimId">int</param> /// <param name="cancellationToken">CancellationToken</param> /// <returns>Task<List<ApplicationUser>></returns> /// <method>GetApprovedUsersAsync(string roleId, int roleClaimId, CancellationToken cancellationToken = default(CancellationToken))</method> public async Task <List <ApplicationUser> > GetApprovedUsersAsync(string roleId, int roleClaimId, CancellationToken cancellationToken = default(CancellationToken)) { try { string accessToken = await GetAccessToken(); string jsonString = JsonConvert.SerializeObject(new KeyValuePair <string, int>(roleId.Clean(), roleClaimId)); string encryptString = AESGCM.Encrypt(jsonString, accessToken); JsonClient jsonClient = new JsonClient(_apiBaseUrl, accessToken); HttpStatusCode statusCode = await jsonClient.SendRequest(HttpMethod.Post, "Role/GetApprovedUsers", encryptString); if (!jsonClient.IsResponseSuccess) { _logger.Exception(new Exception(jsonClient.GetResponseString())); throw new Exception(jsonClient.GetResponseString()); } jsonString = AESGCM.Decrypt(jsonClient.GetResponseObject <string>(), accessToken); List <ApplicationUser> users = JsonConvert.DeserializeObject <List <ApplicationUser> >(jsonString); return(users); } catch (Exception exception) { _logger.Exception(exception); throw; } }
/// <summary> /// Implemented IUserLoginStore FindByLoginAsync Method /// </summary> /// <param name="loginProvider">string</param> /// <param name="providerKey">string</param> /// <param name="cancellationToken">CancellationToken</param> /// <returns>Task<ApplicationUser></returns> /// <method>FindByLoginAsync(string loginProvider, string providerKey, CancellationToken cancellationToken)</method> public async Task <ApplicationUser> FindByLoginAsync(string loginProvider, string providerKey, CancellationToken cancellationToken) { try { IdentityUserLogin <string> input = new IdentityUserLogin <string>(); input.LoginProvider = loginProvider.Clean(); input.ProviderKey = providerKey.Clean(); string accessToken = await GetAccessToken(); string jsonString = JsonConvert.SerializeObject(input); string encryptString = AESGCM.Encrypt(jsonString, accessToken); JsonClient jsonClient = new JsonClient(_apiBaseUrl, accessToken); HttpStatusCode statusCode = await jsonClient.SendRequest(HttpMethod.Post, "User/FindByLogin", encryptString); if (!jsonClient.IsResponseSuccess) { _logger.Exception(new Exception(jsonClient.GetResponseString())); throw new Exception(jsonClient.GetResponseString()); } jsonString = AESGCM.Decrypt(jsonClient.GetResponseObject <string>(), accessToken); ApplicationUser user = JsonConvert.DeserializeObject <ApplicationUser>(jsonString); return(user); } catch (Exception exception) { _logger.Exception(exception); throw; } }
/// <summary> /// Method to save a record in a dictonary of key value records in cookie /// </summary> /// <param name="cookieKey">string</param> /// <param name="key">string</param> /// <param name="value">string</param> /// <exception>Requires HttpRequest and HttpResponse</exception> /// <method>SetValue(string cookiekey, string key, string value)</method> public void SetValue(string cookieKey, string key, string value) { if (_request == null) { throw new Exception("Invalid operation, request cannot be null"); } if (_response == null) { throw new Exception("Invalid operation, response cannot be null"); } Dictionary <string, string> form = new Dictionary <string, string>(); if (_request.Cookies[cookieKey] != null) { var cookieValue = _request.Cookies[cookieKey]; form = JsonConvert.DeserializeObject <Dictionary <string, string> >(cookieValue); } if (form.ContainsKey(key)) { form.Remove(key); } form.Add(key, AESGCM.Encrypt(value)); _response.Cookies.Append(cookieKey, JsonConvert.SerializeObject(form), _cookieOptions); }
public IActionResult Post(object encryptObject) { try { IHeaderDictionary headers = _httpContextAccessor.HttpContext.Request.Headers; string accessToken = headers.Where(x => x.Key == "Authorization").Select(x => x.Value).FirstOrDefault(); if (string.IsNullOrEmpty(accessToken)) { return(BadRequest("Invalid Authorization")); } accessToken = accessToken.Substring(7); string jsonString = AESGCM.Decrypt(encryptObject.ToString(), accessToken); string input = JsonConvert.DeserializeObject <string>(jsonString); ApplicationRole role = _dbContext.Roles .Include("RoleClaims") .Where(x => x.Id == input) .FirstOrDefault(); jsonString = JsonConvert.SerializeObject(role, new JsonSerializerSettings() { ReferenceLoopHandling = ReferenceLoopHandling.Ignore }); string encryptString = AESGCM.Encrypt(jsonString, accessToken); return(new JsonResult(encryptString)); } catch (Exception exception) { _logger.Exception(exception); return(BadRequest(exception)); } }
/// <summary> /// Implemented IRoleStore Method /// </summary> /// <param name="roleId">string</param> /// <param name="cancellationToken">CancellationToken</param> /// <returns>Task<ApplicationRole></returns> /// <method>FindByIdAsync(string roleId, CancellationToken cancellationToken = default(CancellationToken))</method> public async Task <ApplicationRole> FindByIdAsync(string roleId, CancellationToken cancellationToken = default(CancellationToken)) { try { string accessToken = await GetAccessToken(); string jsonString = JsonConvert.SerializeObject(roleId.Clean()); string encryptString = AESGCM.Encrypt(jsonString, accessToken); JsonClient jsonClient = new JsonClient(_apiBaseUrl, accessToken); HttpStatusCode statusCode = await jsonClient.SendRequest(HttpMethod.Post, "Role/FindById", encryptString); if (!jsonClient.IsResponseSuccess) { _logger.Exception(new Exception(jsonClient.GetResponseString())); throw new Exception(jsonClient.GetResponseString()); } jsonString = AESGCM.Decrypt(jsonClient.GetResponseObject <string>(), accessToken); ApplicationRole role = JsonConvert.DeserializeObject <ApplicationRole>(jsonString); return(role); } catch (Exception exception) { _logger.Exception(exception); throw; } }
public byte[] Encrypt(byte[] payload) { var disposablePrivateKey = PrivateKey.Generate(); var aesKey = disposablePrivateKey.ECDH(this); var aes = new AESGCM(aesKey); return(aes.Encrypt(payload, disposablePrivateKey.PublicKey.Format(true))); }
/// <summary> /// Implemented IUserStore DeleteAsync Method /// </summary> /// <param name="user">ApplicationUser</param> /// <param name="cancellationToken">CancellationToken</param> /// <returns>Task<IdentityResult></returns> /// <method>DeleteAsync(ApplicationUser user, CancellationToken cancellationToken)</method> public async Task <IdentityResult> DeleteAsync(ApplicationUser user, CancellationToken cancellationToken) { try { if (user.RevokedDate == (DateTime?)DateTime.MinValue) { throw new Exception("Missing required revoked date"); } if (string.IsNullOrEmpty(user.RevokedById)) { throw new Exception("Missing required revoked by"); } string accessToken = await GetAccessToken(); string jsonString = JsonConvert.SerializeObject(user); string encryptString = AESGCM.Encrypt(jsonString, accessToken); JsonClient jsonClient = new JsonClient(_apiBaseUrl, accessToken); HttpStatusCode statusCode = await jsonClient.SendRequest(HttpMethod.Post, "User/Update", encryptString); if (!jsonClient.IsResponseSuccess) { _logger.Warning(jsonClient.GetResponseString()); return(IdentityResult.Failed( new IdentityError() { Code = jsonClient.StatusCode.ToString(), Description = jsonClient.GetResponseString() } )); } } catch (Exception exception) { _logger.Exception(exception); return(IdentityResult.Failed( new IdentityError { Code = exception.Source, Description = exception.Message } )); } return(IdentityResult.Success); }
public IActionResult Post(object encryptObject) { try { IHeaderDictionary headers = _httpContextAccessor.HttpContext.Request.Headers; string accessToken = headers.Where(x => x.Key == "Authorization").Select(x => x.Value).FirstOrDefault(); if (string.IsNullOrEmpty(accessToken)) { return(BadRequest("Invalid Authorization")); } accessToken = accessToken.Substring(7); string jsonString = AESGCM.Decrypt(encryptObject.ToString(), accessToken); IdentityUserLogin <string> input = JsonConvert.DeserializeObject <IdentityUserLogin <string> >(jsonString); ApplicationUser user = _dbContext.Users .Join(_dbContext.UserLogins, Users => Users.Id, UserLogins => UserLogins.UserId, (Users, UserLogins) => new { Users, UserLogins }) .Where(x => x.UserLogins.ProviderKey == input.ProviderKey) .Where(x => x.UserLogins.LoginProvider == input.LoginProvider) .Select(x => x.Users) .Include("Claims") .Include("Logins") .Include("Tokens") .Include("RoleClaims") //.Include("RoleClaims.User") .Include("RoleClaims.Role") .Include("RoleClaims.RoleClaim") .Include("RoleClaims.History") .Include("RoleClaims.History.ActionBy") //.Include("RoleClaims.History.UserRoleClaim") .FirstOrDefault(); jsonString = JsonConvert.SerializeObject(user, new JsonSerializerSettings() { ReferenceLoopHandling = ReferenceLoopHandling.Ignore }); string encryptString = AESGCM.Encrypt(jsonString, accessToken); return(new JsonResult(encryptString)); } catch (Exception exception) { _logger.Exception(exception); return(BadRequest(exception)); } }
public IActionResult Post() { try { IHeaderDictionary headers = _httpContextAccessor.HttpContext.Request.Headers; string accessToken = headers.Where(x => x.Key == "Authorization").Select(x => x.Value).FirstOrDefault(); if (string.IsNullOrEmpty(accessToken)) { return(BadRequest("Invalid Authorization")); } accessToken = accessToken.Substring(7); List <ApplicationUser> users = _dbContext.Users .Include("Claims") .Include("Logins") .Include("Tokens") .Include("RoleClaims") //.Include("RoleClaims.User") .Include("RoleClaims.Role") .Include("RoleClaims.RoleClaim") .Include("RoleClaims.History") .Include("RoleClaims.History.ActionBy") //.Include("RoleClaims.History.UserRoleClaim") .Where(x => x.RequestDate > (DateTime?)DateTime.MinValue) .Where(x => x.EmailConfirmed == true) .Where(x => x.ApprovedDate == (DateTime?)DateTime.MinValue) .Where(x => x.RevokedDate == (DateTime?)DateTime.MinValue) .OrderBy(x => x.RequestDate) .ToList(); string jsonString = JsonConvert.SerializeObject(users, new JsonSerializerSettings() { ReferenceLoopHandling = ReferenceLoopHandling.Ignore }); string encryptString = AESGCM.Encrypt(jsonString, accessToken); return(new JsonResult(encryptString)); } catch (Exception exception) { _logger.Exception(exception); return(BadRequest(exception)); } }
public IActionResult Post(object encryptObject) { try { IHeaderDictionary headers = _httpContextAccessor.HttpContext.Request.Headers; string accessToken = headers.Where(x => x.Key == "Authorization").Select(x => x.Value).FirstOrDefault(); if (string.IsNullOrEmpty(accessToken)) { return(BadRequest("Invalid Authorization")); } accessToken = accessToken.Substring(7); string jsonString = AESGCM.Decrypt(encryptObject.ToString(), accessToken); KeyValuePair <string, int> input = JsonConvert.DeserializeObject <KeyValuePair <string, int> >(jsonString); List <ApplicationUser> users = _dbContext.Users .Join(_dbContext.UserRoleClaims, Users => Users.Id, UserRoleClaims => UserRoleClaims.UserId, (Users, UserRoleClaims) => new { Users, UserRoleClaims }) .Where(x => x.UserRoleClaims.RoleId == input.Key) .Where(x => x.UserRoleClaims.RoleClaimId == input.Value) .Where(x => x.UserRoleClaims.Status == AspNetUserRoleClaim.RoleClaimStatus.Approved) .Select(x => x.Users) .Include("Claims") .Include("Logins") .Include("Tokens") .Include("RoleClaims") .Include("RoleClaims.Role") .Include("RoleClaims.RoleClaim") .ToList(); jsonString = JsonConvert.SerializeObject(users, new JsonSerializerSettings() { ReferenceLoopHandling = ReferenceLoopHandling.Ignore }); string encryptString = AESGCM.Encrypt(jsonString, accessToken); return(new JsonResult(encryptString)); } catch (Exception exception) { _logger.Exception(exception); return(BadRequest(exception)); } }
/// <summary> /// Implemented IUserStore UpdateAsync Method /// </summary> /// <param name="user">ApplicationUser</param> /// <param name="cancellationToken">CancellationToken</param> /// <returns>Task<IdentityResult></returns> /// <method>UpdateAsync(ApplicationUser user, CancellationToken cancellationToken)</method> public async Task <IdentityResult> UpdateAsync(ApplicationUser user, CancellationToken cancellationToken) { try { string accessToken = await GetAccessToken(); string jsonString = JsonConvert.SerializeObject(user, new JsonSerializerSettings() { ReferenceLoopHandling = ReferenceLoopHandling.Ignore }); string encryptString = AESGCM.Encrypt(jsonString, accessToken); JsonClient jsonClient = new JsonClient(_apiBaseUrl, accessToken); HttpStatusCode statusCode = await jsonClient.SendRequest(HttpMethod.Post, "User/Update", encryptString); if (!jsonClient.IsResponseSuccess) { _logger.Warning(jsonClient.GetResponseString()); return(IdentityResult.Failed( new IdentityError() { Code = jsonClient.StatusCode.ToString(), Description = jsonClient.GetResponseString() } )); } } catch (Exception exception) { _logger.Exception(exception); return(IdentityResult.Failed( new IdentityError { Code = exception.Source, Description = exception.Message } )); } return(IdentityResult.Success); }
/// <summary> /// Method to save a dictonary of key value records in cookie /// </summary> /// <param name="cookieKey">string</param> /// <param name="values">Dictionary<string, string></param> /// <exception>Requires HttpRequest and HttpResponse</exception> /// <method>SetAllValues(string cookiekey, Dictionary<string, string>)</method> public void SetAllValues(string cookieKey, Dictionary <string, string> values) { if (_request == null) { throw new Exception("Invalid operation, request cannot be null"); } if (_response == null) { throw new Exception("Invalid operation, response cannot be null"); } Dictionary <string, string> form = new Dictionary <string, string>(); foreach (var item in values) { form.Add(item.Key, AESGCM.Encrypt(item.Value)); } _response.Cookies.Append(cookieKey, JsonConvert.SerializeObject(form), _cookieOptions); }
/// <summary> /// Method to store encrypted object in Http Session /// </summary> /// <param name="session">ISession</param> /// <param name="key">string</param> /// <param name="value">T</param> /// <method>Encrypt<T>(this ISession session, string key, T value)</method> public static async void Encrypt <T>(this ISession session, string key, T value) { session.SetString(key, AESGCM.Encrypt(JsonSerializer.Serialize(value))); await session.CommitAsync(); }