public EditVenueModel(UserManager <Employee> userManager, RoleManager <EmployeeRole> roleManager, ICoordinatesService coordinates, CompanyRepository companies, VenueRepository venues, TagRepository tags, ImageRepository images, ISettings settings, DocumentRepository documents, VenueDocumentRepository venueDocuments, IMessagePublisher messagePublisher, Constants constants, ICryptoHelper cryptoHelper, VenueOpeningTimeRepository venueOpeningTimes) { this.coordinates = coordinates; this.userManager = userManager; this.roleManager = roleManager; this.venues = venues; this.tags = tags; this.images = images; this.settings = settings; this.documents = documents; this.venueDocuments = venueDocuments; this.companies = companies; this.messagePublisher = messagePublisher; this.constants = constants; this.cryptoHelper = cryptoHelper; this.venueOpeningTimes = venueOpeningTimes; }
public async Task Invoke(HttpContext context) { try { IHeaderDictionary headers = context.Request.Headers; ICookieHelper _cookieHelper = context.GetInstanceFromContext <ICookieHelper>(); IJWTHelper _JWTHelper = context.GetInstanceFromContext <IJWTHelper>(); ICryptoHelper _cryptoHelper = context.GetInstanceFromContext <ICryptoHelper>(); string cookie = _cookieHelper.GetCookie(_cookieHelper.GetCookieName()); // Get JWT from request header. string hdrJWT = _JWTHelper.getBearerHeaderValue(headers); // If header doesn't have a JWT but the cookie does, add the cookie's JWT to the header. if (String.IsNullOrEmpty(hdrJWT) && !String.IsNullOrEmpty(cookie)) { string decryptedJWTToken = _cryptoHelper.decrypt(cookie); _JWTHelper.setClaimsFromCookie(decryptedJWTToken); string bearerToken = string.Format("Bearer {0}", cookie); headers.SetCommaSeparatedValues("Authorization", bearerToken); } } catch (Exception ex) { Console.WriteLine(ex.Message); } finally { await _next.Invoke(context); } }
public ApiController(IConfiguration configuration, ICookieHelper cookieHelper, IJWTHelper JWTHelper, ICryptoHelper cryptoHelper) { _configuration = configuration; _cookieHelper = cookieHelper; _JWTHelper = JWTHelper; _cryptoHelper = cryptoHelper; }
public virtual void Setup() { try { _testDataDirectory = Path.Combine(Path.GetDirectoryName(Path.GetDirectoryName(Path.GetDirectoryName(TestContext.CurrentContext.TestDirectory))), "TestData"); _sampleUser = JsonConvert.DeserializeObject <User>(File.ReadAllText(Path.Combine(_testDataDirectory, "sampleUser.json"))); _cyrptoHelper = new CryptoHelper(); _sampleUser.Password = _cyrptoHelper.Hash(_sampleUser.Password); _mapper = new MapperConfiguration(mc => { mc.AddProfile(new MappingProfile(_cyrptoHelper)); }).CreateMapper(); _userClaims = new ClaimsPrincipal(new ClaimsIdentity(new Claim[] { new Claim(ClaimTypes.NameIdentifier, Guid.NewGuid().ToString()), new Claim(ClaimTypes.Sid, _sampleUser.Id.ToString()), new Claim(ClaimTypes.Email, _sampleUser.Email) }, "mock")); } catch { // Ignored } }
public async Task Invoke(HttpContext context) { try { IHeaderDictionary headers = context.Request.Headers; ICookieHelper _cookieHelper = context.GetInstanceFromContext <ICookieHelper>(); IJWTHelper _JWTHelper = context.GetInstanceFromContext <IJWTHelper>(); ICryptoHelper _cryptoHelper = context.GetInstanceFromContext <ICryptoHelper>(); string cookieName = _cookieHelper.GetCookieName(); if (!_cookieHelper.isCookieDeleted(cookieName)) { string updatedToken = _JWTHelper.updateJWTToken(); string encryptedToken = _cryptoHelper.encrypt(updatedToken); _cookieHelper.UpdateCookie(encryptedToken); } } catch (Exception ex) { Console.WriteLine(ex.Message); } finally { await _next.Invoke(context); } }
public AuthenHelper(ISessionHelper sessionHelper, ICryptoHelper cryptoHelper, IServiceHelper serviceHelper, ICacheHelper cacheHelper) { _httpContext = HttpContext.Current; _sessionHelper = sessionHelper; _cryptoHelper = cryptoHelper; _serviceHelper = serviceHelper; _cacheHelper = cacheHelper; }
public CardService(ICardRepository cardRepository, ISmsService smsService, ICardHelper cardHelper, ICryptoHelper cryptoHelper) { _cardRepository = cardRepository; _smsService = smsService; _cardHelper = cardHelper; _cryptoHelper = cryptoHelper; }
public ValidateExpiredTokenFilter(IConfiguration configuration, ILogger <ValidateUnAttendanceFilter> logger, ICryptoHelper cryptoHelper, ConfigSettings configSettings) { _configuration = configuration; _cryptoHelper = cryptoHelper; _configSettings = configSettings; _logger = logger; }
public Handler(IUnitOfWork unitOfWork, IJwtGenerator jwtGenerator, UtilFactory utilFactory, IMapperHelper mapperHelper) { _unitOfWork = unitOfWork; _jwtGenerator = jwtGenerator; _cryptoHelper = utilFactory.CryptoHelper; _mapperHelper = mapperHelper; }
public MoneyTransactionController( IAccountService accountService, ITransactionService transactionService, ICryptoHelper cryptoHelper) { _accountService = accountService; _transactionService = transactionService; _cryptoHelper = cryptoHelper; }
public TransactionController(IAccountService accountService, ICurrencyService currencyService, ITransactionService transactionService, ICryptoHelper cryptoHelper, ICardHelper cardHelper) { _accountService = accountService; _currencyService = currencyService; _transactionService = transactionService; _cryptoHelper = cryptoHelper; _cardHelper = cardHelper; }
public void RijndaelEncrypt() { ICryptoHelper crytographyHelper = CryptoFactory.Create(CryptographyAlgorithm.Rijndael); crytographyHelper.Entropy = ENCRYPTION_VALID_PASSWORD; string encryptedString = crytographyHelper.Encrypt(ENCRYPTION_TEST_STRING, StringEncodingType.Hex); Assert.IsFalse(StringHelper.Match(encryptedString, ENCRYPTION_TEST_STRING, true), "Encrypted String Equals String Passed In"); }
public UsersController(IUserRepository userRepository, ICryptoHelper cryptoHelper, IMapper mapper, IOptions <JwtIssuerOptions> jwtOptions) { _userRepository = userRepository; _cryptoHelper = cryptoHelper; _mapper = mapper; _jwtOptions = jwtOptions.Value; }
public AccountService(IAccountRepository accountRepository, ICardRepository cardRepository, IAccountHelper accountHelper, ICardHelper cardHelper, ISmsService smsService, ICryptoHelper cryptoHelper) { _accountRepository = accountRepository; _cardRepository = cardRepository; _accountHelper = accountHelper; _cardHelper = cardHelper; _cryptoHelper = cryptoHelper; _smsService = smsService; }
private void CreateHelper(CryptographyAlgorithm algorithm, string key) { if (key.Trim().Length == 0) { helper = CryptoFactory.Create(algorithm); } else { helper = CryptoFactory.Create(algorithm, key); } }
public UserService( IUserRepository userRepository, ITokenService tokenService, ICryptoHelper crypoHelper, IMovementRepository movementeRepository) { _userRepository = userRepository; _tokenService = tokenService; _crypoHelper = crypoHelper; _movementRepository = movementeRepository; }
public UserController ( IUserService userService, IConfiguration configuration, PermissionCachingManager cache, ICryptoHelper cryptoHelper ) { _userService = userService; _configuration = configuration; _cache = cache; _cryptoHelper = cryptoHelper; }
public void RijndaelDecryptValidPassword() { ICryptoHelper crytographyHelper = CryptoFactory.Create(CryptographyAlgorithm.Rijndael); crytographyHelper.Entropy = ENCRYPTION_VALID_PASSWORD; string encryptedString = crytographyHelper.Encrypt(ENCRYPTION_TEST_STRING, StringEncodingType.Hex); ICryptoHelper crytographyHelper2 = CryptoFactory.Create(CryptographyAlgorithm.Rijndael); crytographyHelper2.Entropy = ENCRYPTION_VALID_PASSWORD; string decriptedString = crytographyHelper2.Decrypt(encryptedString, StringEncodingType.Hex); Assert.AreEqual(ENCRYPTION_TEST_STRING, decriptedString); }
/// <summary> /// Recreates the specified current. /// </summary> /// <param name="current">The current.</param> /// <param name="cryptoType">Type of the crypto.</param> /// <param name="privateKeyPath">The private key path.</param> /// <param name="privateKeyPassword">The private key password.</param> /// <param name="publicKeyPath">The public key path.</param> /// <returns>Implementation of crypto helper.</returns> public static ICryptoHelper Recreate(ref ICryptoHelper current, CryptoType cryptoType, string privateKeyPath, string privateKeyPassword, string publicKeyPath) { if ((current == null) || (current.Type != cryptoType)) { current = CreateRSA(cryptoType, privateKeyPath, privateKeyPassword, publicKeyPath); } return current; }
/// <summary> /// Recreates the specified current. /// </summary> /// <param name="current">The current.</param> /// <param name="cryptoType">Type of the crypto.</param> /// <param name="privateKeyPath">The private key path.</param> /// <param name="privateKeyPassword">The private key password.</param> /// <param name="publicKeyPath">The public key path.</param> /// <returns>Implementation of crypto helper.</returns> public static ICryptoHelper Recreate(ref ICryptoHelper current, CryptoType cryptoType, string privateKeyPath, string privateKeyPassword, string publicKeyPath) { if ((current == null) || (current.Type != cryptoType)) { current = CreateRSA(cryptoType, privateKeyPath, privateKeyPassword, publicKeyPath); } return(current); }
public AuthoriseController(EmployeeRepository employees, EmployeeSessionRepository employeeSessions, UserRepository users, UserSessionRepository userSessions, TokenUtil tokenUtil, ISettings settings, IBillingManager billingManager, ICryptoHelper crypto) { this.employees = employees; this.employeeSessions = employeeSessions; this.users = users; this.userSessions = userSessions; this.tokenUtil = tokenUtil; this.settings = settings; this.billingManager = billingManager; this.crypto = crypto; }
public MappingProfile(ICryptoHelper cryptoHelper) { // viewmodel -> entity CreateMap <NewUserRequest, User>().ForMember(dest => dest.Password, src => src.MapFrom(x => cryptoHelper.Hash(x.Password))); CreateMap <ProjectTaskCreateViewModel, ProjectTask>().ReverseMap(); CreateMap <ProjectTaskViewModel, ProjectTask>().ReverseMap(); CreateMap <ProjectCreateViewModel, Project>().ReverseMap(); CreateMap <ProjectViewModel, Project>().ReverseMap(); CreateMap <ProjectAndTasksViewModel, Project>().ReverseMap(); // entity -> viewmodel CreateMap <User, UserViewModel>(); }
public UserService ( IUserRepository userRepo, ICryptoHelper crypytoHelper, IJWTokenHelper tokenHelper, IRoleAssignmentRepository roleAssignmentRepo, IPermissionRepository permissionRepo ) { _userRepo = userRepo; _crypytoHelper = crypytoHelper; _tokenHelper = tokenHelper; _roleAssignmentRepo = roleAssignmentRepo; _permissionRepo = permissionRepo; }
public AuthenticationManager( ILogger <AuthenticationManager> logger, VkAppConfig vkAppConfig, ICryptoHelper cryptoHelper, ISecurityManager securityManager, IAsyncRepository <AuthenticationAccount> accountsRepo, IAsyncRepository <User> usersRepo) { this.logger = logger; this.vkAppConfig = vkAppConfig; this.cryptoHelper = cryptoHelper; this.securityManager = securityManager; this.accountsRepo = accountsRepo; this.usersRepo = usersRepo; }
public SessionManager( // Providers. IEntityProvider <Session> sessionProvider, IEntityProvider <User> userProvider, // Helpers. ICryptoHelper cryptoHelper, IDateTimeHelper dateTimeHelper) { SessionProvider = sessionProvider; UserProvider = userProvider; CryptoHelper = cryptoHelper; DateTimeHelper = dateTimeHelper; ApiSecret = Environment.GetEnvironmentVariable("WEBCHAT_API_SECRET"); }
public static IConfiguration Decrypt(this IConfiguration config, ICryptoHelper crypto) { string key; string foundVal; string decryptedVal; List <ConfigSetting> configList = config.GetConfigSettings(); string encPrefix = config["ConfigOptions:Cryptography:EncValPrefix"]; for (int i = 0; i < configList.Count; i++) { foundVal = configList[i].SettingValue; if (foundVal.StartsWith(encPrefix) && foundVal != encPrefix) { key = configList[i].SettingKey; decryptedVal = crypto.Unprotect(key, foundVal, encPrefix); config[key] = decryptedVal; } } return(config); }
public PaymentOAuthCallbackController(CompanyRepository companies, EmployeeRepository employees, EmployeeRoleRepository roles, Constants constants, ISettings settings, ICryptoHelper cryptoHelper, IDistributedCache cache, IMessagePublisher messagePublisher, ILoggerFactory loggerFactory) { this.companies = companies; this.employees = employees; this.roles = roles; this.constants = constants; this.settings = settings; this.cryptoHelper = cryptoHelper; this.cache = cache; this.messagePublisher = messagePublisher; this.logger = loggerFactory.CreateLogger(nameof(PaymentOAuthCallbackController)); }
public static void Main(string[] args) { Console.ForegroundColor = ConsoleColor.Green; var serviceCollection = new ServiceCollection(); // build a local configuration that contains the plain-text encryption configuration settings. config = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build(); // use the settings in the initial configuration to initialize Microsoft DPAPI // This can also be done in Startup.ConfigureServices using the standard Configuration from DI serviceCollection.AddDataProtectionServices(config); var serviceProvider = serviceCollection.BuildServiceProvider(); crypto = serviceProvider.GetRequiredService <ICryptoHelper>(); // create an instance of StringEncryptor using the service provider and Encryption Prefix string var instance = ActivatorUtilities.CreateInstance <StringEncryptor>(serviceProvider, config["ConfigOptions:Cryptography:EncValPrefix"], crypto); instance.UserLoop(); }
public void ConfigureServices(IServiceCollection services) { // Add Data Protection Services using the configuration loaded from DI. // This is required to add Microsoft Data Protection services to DI, and to create a service for ICryptoHelper which performs the cryptography tasks. // The configuration must have section ConfigOptions:Cryptography with plain text values for ClientScope, EncValPrefix, and KeyStore. // These configuration values are required to initialize encyrption services, so they must be in plain text. services.AddDataProtectionServices(Configuration); // Get the DPAPI Service provider which a dependency of CryptoHelper var serviceProvider = services.BuildServiceProvider(); //Add ICryptoHelper, with its dependency, to DI ICryptoHelper crypto = serviceProvider.GetRequiredService <ICryptoHelper>(); // DECRYPT the configuration values - Setting values will be decrypted if they begin with the Encrypted Value Prefix (EncValPrefix) Configuration.Decrypt(crypto); // Use decrypted configuration to initialize other services like data access, authentication, and authorization // other services... services.AddRazorPages(); }
public UserRepository(IConfiguration configuration, ICryptoHelper cryptoHelper, ILogger <UserRepository> logger) : base(configuration) { this.configuration = configuration; this.cryptoHelper = cryptoHelper; this.logger = logger; }
public AuthComponent(ICryptoHelper cryptoHelper) { this.cryptoHelper = cryptoHelper; }
public WebUserStore(EmployeeRepository accountRepository, EmployeeRoleRepository roles, ICryptoHelper cryptoHelper) { _accountRepository = accountRepository; _cryptoHelper = cryptoHelper; this.roles = roles; }
public TokenComponent(ICryptoHelper cryptoHelper) { this.cryptoHelper = cryptoHelper; }
public CaptchaHelper() { cryptoHelper = new MD5CryptoHelper(); }