public CachingCryptoService(string encryptionKey) { this._cryptoService = new CryptoService(encryptionKey); this._lockObj = new object(); this._encCache = new ConcurrentDictionary<string, string>(); this._decCache = new ConcurrentDictionary<string, string>(); }
public MembershipService(IEntityRepository<User> userRepository, IEntityRepository<Role> roleRepository, IEntityRepository<UserInRole> userInRoleRepository, ICryptoService cryptoService) { _userRepository = userRepository; _roleRepository = roleRepository; _userInRoleRepository = userInRoleRepository; _cryptoService = cryptoService; }
public void Init(HttpApplication context) { cryptoService = DependencyResolver.Current.GetService<ICryptoServiceFactory>().Create(); settingService = DependencyResolver.Current.GetService<ISettingService>(); context.AuthenticateRequest += ContextOnAuthenticateRequest; context.EndRequest += ContextOnEndRequest; }
public LocalFileSystemVolume( Config.IConnectorConfig config, ICryptoService cryptoService, IImageEditorService imageEditorService ) { _config = config; _cryptoService = cryptoService; _imageEditorService = imageEditorService; }
public EntityContextProvider(IEntityProvider entityProvider, IStateProvider stateProvider, ICryptoService cryptoService) { _entityProvider = entityProvider; _entityContext = stateProvider.CookieState("authctx", TimeSpan.Zero, false, true) .Signed(cryptoService, TimeSpan.Zero) .Jsoned<EntityContext>(); }
public virtual void SetPassword(ICryptoService cryptoService, string password) { Guard.AgainstNull(() => cryptoService); Guard.AgainstNullOrWhiteSpaceString(() => password); this.PasswordSalt = cryptoService.GenerateSalt(password); this.PasswordHash = cryptoService.ComputeHash(this.PasswordSalt, password); }
public DefaultMembershipService(IMessangerRepository repository, ICryptoService cryptoServ) { System.Diagnostics.Contracts.Contract.Requires<ArgumentNullException>(repository != null); System.Diagnostics.Contracts.Contract.Requires<ArgumentNullException>(cryptoServ != null); _repository = repository; _crypto = cryptoServ; }
public LogManager(IDatabaseFactory databaseFactory, ICryptoService cryptoService) { _dbContext = databaseFactory.Get() as DiabDbContext; LogCommands = new LogCommands(databaseFactory); ModelReader = new ModelReader(databaseFactory); PersonCommands = new PersonCommands(databaseFactory); FriendCommands = new FriendCommands(databaseFactory); SecurityLinkCommands = new SecurityLinkCommands(databaseFactory, cryptoService); }
public PackageBuilder(ICryptoService cryptoService, IDateTimeService dateTimeService, IGuidGenerator guidGenerator ) { this.cryptoService = cryptoService; this.dateTimeService = dateTimeService; this.guidGenerator = guidGenerator; }
public PoemController(IPoemService poemService, IVerseService verseService, ISignalizerFactory signalizerFactory, ICryptoServiceFactory cryptoServiceFactory, ILogger logger) : base(logger) { this.poemService = poemService; this.verseService = verseService; this.signalizerFactory = signalizerFactory; cryptoService = cryptoServiceFactory.Create(); this.logger = logger; }
public virtual bool Login(ICryptoService cryptoService, string password) { Guard.AgainstNull(() => cryptoService); Guard.AgainstNullOrWhiteSpaceString(() => password); bool loggedIn = cryptoService.VerifyPassword(this.PasswordSalt, this.PasswordHash, password); return loggedIn; }
public AppLicenseManager( ISettingsProvider settingsProvider, ICryptoService cryptoService) { _settingsProvider = settingsProvider; _cryptoService = cryptoService; _licenseSettings = settingsProvider.GetSettings<LicenseSettings>(); Initialize(); }
public PendingClientService( IRepository<PendingClientEntity> pendingClientRepository, IStringEncryptor stringEncryptor, ICryptoService cryptoService, IMapper mapper) { _pendingClientRepository = pendingClientRepository; _stringEncryptor = stringEncryptor; _cryptoService = cryptoService; _mapper = mapper; }
public WebDavPlugin(IStorageAccountService accountService, ICryptoService cryptoService, ISecurityConfiguration securityConfiguration) { AccountService = accountService; CryptoService = cryptoService; SecurityConfiguration = securityConfiguration; ConfigurationProviderReference = new WeakRefHolder<ConfigurationProvider>(() => new ConfigurationProvider(AccountService, CryptoService, SecurityConfiguration)); FolderQueryReference = new WeakRefHolder<FolderQuery>(() => new FolderQuery()); FileStreamQueryReference = new WeakRefHolder<FileStreamQuery>(() => new FileStreamQuery()); }
public SocketConnector(BaseSocketConnectionHost host, string name, IPEndPoint remoteEndPoint, ProxyInfo proxyData, EncryptType encryptType, CompressionType compressionType, ICryptoService cryptoService, int reconnectAttempts, int reconnectAttemptInterval, IPEndPoint localEndPoint) : base(host, name, localEndPoint, encryptType, compressionType, cryptoService, remoteEndPoint) { FReconnectTimer = new Timer(new TimerCallback(ReconnectConnectionTimerCallBack)); FReconnectAttempts = reconnectAttempts; FReconnectAttemptInterval = reconnectAttemptInterval; FReconnectAttempted = 0; FProxyInfo = proxyData; }
public BaseSocketConnectionCreator(BaseSocketConnectionHost host, string name, IPEndPoint localEndPoint, EncryptType encryptType, CompressionType compressionType, ICryptoService cryptoService) { FHost = host; FName = name; FLocalEndPoint = localEndPoint; FCompressionType = compressionType; FEncryptType = encryptType; FCryptoService = cryptoService; }
public SocketListener AddListener(string name, IPEndPoint localEndPoint, EncryptType encryptType, CompressionType compressionType, ICryptoService cryptoService, byte backLog, byte acceptThreads) { SocketListener listener = null; if (!Disposed) { listener = new SocketListener(this, name, localEndPoint, encryptType, compressionType, cryptoService, backLog, acceptThreads); listener.AddCreator(); } return listener; }
public SocketConnector AddConnector(string name, IPEndPoint remoteEndPoint, ProxyInfo proxyData, EncryptType encryptType, CompressionType compressionType, ICryptoService cryptoService, int reconnectAttempts, int reconnectAttemptInterval, IPEndPoint localEndPoint) { SocketConnector result = null; if (!Disposed) { result = new SocketConnector(this, name, remoteEndPoint, proxyData, encryptType, compressionType, cryptoService, reconnectAttempts, reconnectAttemptInterval, localEndPoint); result.AddCreator(); } return result; }
public MsSqlVolume(IConnectorConfig config, IImageEditorService imageEditorService, ICryptoService cryptoService, IUploadFile uploadFile, IKey key, IImageFile imageFile) { _config = config; _imageEditorService = imageEditorService; _cryptoService = cryptoService; _uploadFile = uploadFile; _key = key; _imageFile = imageFile; }
public LoginController( ICryptoServiceFactory cryptoServiceFactory, ILoginService loginService, IUserProfileService userProfileService, IFacebookProfileProxy facebookProfileProxy, ILogger logger) : base(logger) { cryptoService = cryptoServiceFactory.Create(); this.loginService = loginService; this.userProfileService = userProfileService; this.facebookProfileProxy = facebookProfileProxy; }
public MediaFireSessionBroker( ICryptoService cryptoService, MediaFireApiConfiguration configuration, string email, string password, MediaFireRequestController requestController ) { _cryptoService = cryptoService; _configuration = configuration; _email = email; _password = password; _requestController = requestController; }
public BaseSocketConnectionCreator(BaseSocketConnectionHost host, string name, IPEndPoint localEndPoint, EncryptType encryptType, CompressionType compressionType, ICryptoService cryptoService, IPEndPoint remoteEndPoint) { Context = new SocketCreatorContext { CompressionType = compressionType, CryptoService = cryptoService, Host = host, EncryptType = encryptType, Name = name, LocalEndPoint = localEndPoint, RemotEndPoint = remoteEndPoint }; //fWaitCreatorsDisposing = new ManualResetEvent(false); }
public static CurrentStorage Create( string fileName, ICryptoService cryptoService, bool readOnly = false ) { CurrentStorage storage = new CurrentStorage(fileName, readOnly) { CryptoService = cryptoService }; storage.CreateTables(); return storage; }
public MessagesManager(MessagingService messagingService, ConnectionManager connectionManager, IMessageRepository messageRepository, ICryptoService cryptoService, IDeviceInfoProvider deviceInfoProvider) { this.messagingService = messagingService; this.messageRepository = messageRepository; this.cryptoService = cryptoService; this.deviceInfoProvider = deviceInfoProvider; connectionManager.Authenticated += OnAuthenticated; messagingService.DeliveryNotification += OnMessageDelivered; messagingService.IncomingMessage += msg => OnIncomingMessages(new [] { msg }); messagingService.SeenNotification += OnMessageSeen; EncryptionEnabled = true; }
public UserModule(ICryptoService crypto) : base("user") { //Get a list of all the users in the same organization as you. Get["/"] = _ => { if (!IsAuthenticated) { return HttpStatusCode.Unauthorized; } var user = DocumentSession.Load<EmailUser>(Principal.GetUserId()); var users = DocumentSession.Query<EmailUser>() .Where(u => u.Organization.Id == user.Organization.Id) .Select(c => new UserViewModel {Name = c.Name, Organization = c.Organization.Name}).ToList(); return Response.AsJson(users); }; Post["/"] = _ => { //If User is authenticated and is the org admin. if (IsAuthenticated && Principal.HasClaim(EmailRClaimTypes.Admin)) { return HttpStatusCode.Unauthorized; } var user = DocumentSession.Load<EmailUser>(Principal.GetUserId()); var createUser = this.Bind<CreateUserViewModel>(); var salt = crypto.CreateSalt(); var newUser = new EmailUser { Email = createUser.Email, FriendlyName = createUser.FriendlyName, //Id = Guid.NewGuid(), Password = createUser.Password.ToSha256(salt), Salt = salt, LoginType = "Default", Organization = user.Organization, Name = createUser.UserName, IsAdmin = false }; DocumentSession.Store(newUser); return HttpStatusCode.OK; }; }
public void DecryptFrom(ITableRow encryptedRow, ICryptoService cryptoService) { encryptedRow.CopyValues(this); foreach (string encryptedField in EncryptedStringFields) { if (this.TableDefinition.Fields.ContainsKey(encryptedField)) { FieldDefinition def = this.TableDefinition.Fields[encryptedField]; if (def.SqlType == SqlDbType.NVarChar) { string decryptedValue = cryptoService.Decrypt(GetValue<string>(encryptedField)); SetValue(encryptedField, decryptedValue); } } } }
///////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////// // Decrypt and get the auth ticket /// <devdoc> /// <para>Given an encrypted authenitcation ticket as /// obtained from an HTTP cookie, this method returns an instance of a /// FormsAuthenticationTicket class.</para> /// </devdoc> public static FormsAuthenticationTicket Decrypt(string encryptedTicket) { if (String.IsNullOrEmpty(encryptedTicket) || encryptedTicket.Length > MAX_TICKET_LENGTH) { throw new ArgumentException(SR.GetString(SR.InvalidArgumentValue, "encryptedTicket")); } Initialize(); byte[] bBlob = null; if ((encryptedTicket.Length % 2) == 0) // Could be a hex string { try { bBlob = CryptoUtil.HexToBinary(encryptedTicket); } catch { } } if (bBlob == null) { bBlob = HttpServerUtility.UrlTokenDecode(encryptedTicket); } if (bBlob == null || bBlob.Length < 1) { throw new ArgumentException(SR.GetString(SR.InvalidArgumentValue, "encryptedTicket")); } int ticketLength; if (AspNetCryptoServiceProvider.Instance.IsDefaultProvider) { // If new crypto routines are enabled, call them instead. ICryptoService cryptoService = AspNetCryptoServiceProvider.Instance.GetCryptoService(Purpose.FormsAuthentication_Ticket); byte[] unprotectedData = cryptoService.Unprotect(bBlob); ticketLength = unprotectedData.Length; bBlob = unprotectedData; } else { #pragma warning disable 618 // calling obsolete methods // Otherwise call into MachineKeySection routines. if (_Protection == FormsProtectionEnum.All || _Protection == FormsProtectionEnum.Encryption) { // DevDiv Bugs 137864: Include a random IV if under the right compat mode // for improved encryption semantics bBlob = MachineKeySection.EncryptOrDecryptData(false, bBlob, null, 0, bBlob.Length, false, false, IVType.Random); if (bBlob == null) { return(null); } } ticketLength = bBlob.Length; if (_Protection == FormsProtectionEnum.All || _Protection == FormsProtectionEnum.Validation) { if (!MachineKeySection.VerifyHashedData(bBlob)) { return(null); } ticketLength -= MachineKeySection.HashSize; } #pragma warning restore 618 // calling obsolete methods } ////////////////////////////////////////////////////////////////////// // Step 4: Change binary ticket to managed struct // ** MSRC 11838 ** // Framework20 / Framework40 ticket generation modes are insecure. We should use a // secure serialization mode by default. if (!AppSettings.UseLegacyFormsAuthenticationTicketCompatibility) { return(FormsAuthenticationTicketSerializer.Deserialize(bBlob, ticketLength)); } // ** MSRC 11838 ** // If we have reached this point of execution, the developer has explicitly elected // to continue using the insecure code path instead of the secure one. We removed // the Framework40 serialization mode, so everybody using the legacy code path is // forced to Framework20. int iSize = ((ticketLength > MAX_TICKET_LENGTH) ? MAX_TICKET_LENGTH : ticketLength); StringBuilder name = new StringBuilder(iSize); StringBuilder data = new StringBuilder(iSize); StringBuilder path = new StringBuilder(iSize); byte [] pBin = new byte[4]; long [] pDates = new long[2]; int iRet = UnsafeNativeMethods.CookieAuthParseTicket(bBlob, ticketLength, name, iSize, data, iSize, path, iSize, pBin, pDates); if (iRet != 0) { return(null); } DateTime dt1 = DateTime.FromFileTime(pDates[0]); DateTime dt2 = DateTime.FromFileTime(pDates[1]); FormsAuthenticationTicket ticket = new FormsAuthenticationTicket((int)pBin[0], name.ToString(), dt1, dt2, (bool)(pBin[1] != 0), data.ToString(), path.ToString()); return(ticket); }
public UserService(IUserRepository userRepository, ICryptoService cryptoService) { _userRepository = userRepository; _cryptoService = cryptoService; }
public SignupService(DbContextBase db, ICryptoService crypto, IVerificationProvider verificationProvider) { this.db = db; this.crypto = crypto; this.verificationProvider = verificationProvider; }
public override async void ViewDidLoad() { _vaultTimeoutService = ServiceContainer.Resolve <IVaultTimeoutService>("vaultTimeoutService"); _cryptoService = ServiceContainer.Resolve <ICryptoService>("cryptoService"); _deviceActionService = ServiceContainer.Resolve <IDeviceActionService>("deviceActionService"); _stateService = ServiceContainer.Resolve <IStateService>("stateService"); _secureStorageService = ServiceContainer.Resolve <IStorageService>("secureStorageService"); _platformUtilsService = ServiceContainer.Resolve <IPlatformUtilsService>("platformUtilsService"); _biometricService = ServiceContainer.Resolve <IBiometricService>("biometricService"); _keyConnectorService = ServiceContainer.Resolve <IKeyConnectorService>("keyConnectorService"); _accountManager = ServiceContainer.Resolve <IAccountsManager>("accountsManager"); // We re-use the lock screen for autofill extension to verify master password // when trying to access protected items. if (autofillExtension && await _stateService.GetPasswordRepromptAutofillAsync()) { _passwordReprompt = true; _isPinProtected = false; _isPinProtectedWithKey = false; _pinLock = false; _biometricLock = false; } else { (_isPinProtected, _isPinProtectedWithKey) = await _vaultTimeoutService.IsPinLockSetAsync(); _pinLock = (_isPinProtected && await _stateService.GetPinProtectedKeyAsync() != null) || _isPinProtectedWithKey; _biometricLock = await _vaultTimeoutService.IsBiometricLockSetAsync() && await _cryptoService.HasKeyAsync(); _biometricIntegrityValid = await _biometricService.ValidateIntegrityAsync(BiometricIntegrityKey); _usesKeyConnector = await _keyConnectorService.GetUsesKeyConnector(); _biometricUnlockOnly = _usesKeyConnector && _biometricLock && !_pinLock; } if (_pinLock) { BaseNavItem.Title = AppResources.VerifyPIN; } else if (_usesKeyConnector) { BaseNavItem.Title = AppResources.UnlockVault; } else { BaseNavItem.Title = AppResources.VerifyMasterPassword; } BaseCancelButton.Title = AppResources.Cancel; if (_biometricUnlockOnly) { BaseSubmitButton.Title = null; BaseSubmitButton.Enabled = false; } else { BaseSubmitButton.Title = AppResources.Submit; } var descriptor = UIFontDescriptor.PreferredBody; if (!_biometricUnlockOnly) { MasterPasswordCell.Label.Text = _pinLock ? AppResources.PIN : AppResources.MasterPassword; MasterPasswordCell.TextField.SecureTextEntry = true; MasterPasswordCell.TextField.ReturnKeyType = UIReturnKeyType.Go; MasterPasswordCell.TextField.ShouldReturn += (UITextField tf) => { CheckPasswordAsync().GetAwaiter().GetResult(); return(true); }; if (_pinLock) { MasterPasswordCell.TextField.KeyboardType = UIKeyboardType.NumberPad; } MasterPasswordCell.Button.TitleLabel.Font = UIFont.FromName("bwi-font", 28f); MasterPasswordCell.Button.SetTitle(BitwardenIcons.Eye, UIControlState.Normal); MasterPasswordCell.Button.TouchUpInside += (sender, e) => { MasterPasswordCell.TextField.SecureTextEntry = !MasterPasswordCell.TextField.SecureTextEntry; MasterPasswordCell.Button.SetTitle(MasterPasswordCell.TextField.SecureTextEntry ? BitwardenIcons.Eye : BitwardenIcons.EyeSlash, UIControlState.Normal); }; } if (TableView != null) { TableView.BackgroundColor = ThemeHelpers.BackgroundColor; TableView.SeparatorColor = ThemeHelpers.SeparatorColor; TableView.RowHeight = UITableView.AutomaticDimension; TableView.EstimatedRowHeight = 70; TableView.Source = new TableSource(this); TableView.AllowsSelection = true; } base.ViewDidLoad(); if (_biometricLock) { if (!_biometricIntegrityValid) { return; } var tasks = Task.Run(async() => { await Task.Delay(500); NSRunLoop.Main.BeginInvokeOnMainThread(async() => await PromptBiometricAsync()); }); } }
public SocketListener AddListener(string name, IPEndPoint localEndPoint, EncryptType encryptType, CompressionType compressionType, ICryptoService cryptoService, byte backLog, byte acceptThreads) { SocketListener listener = null; if (!Disposed) { listener = new SocketListener(this, name, localEndPoint, encryptType, compressionType, cryptoService, backLog, acceptThreads); AddCreator(listener); } return(listener); }
internal static String Encrypt(FormsAuthenticationTicket ticket, bool hexEncodedTicket) { if (ticket == null) { throw new ArgumentNullException("ticket"); } Initialize(); ////////////////////////////////////////////////////////////////////// // Step 1a: Make it into a binary blob byte[] bBlob = MakeTicketIntoBinaryBlob(ticket); if (bBlob == null) { return(null); } ////////////////////////////////////////////////////////////////////// // Step 1b: If new crypto routines are enabled, call them instead. if (AspNetCryptoServiceProvider.Instance.IsDefaultProvider) { ICryptoService cryptoService = AspNetCryptoServiceProvider.Instance.GetCryptoService(Purpose.FormsAuthentication_Ticket); byte[] protectedData = cryptoService.Protect(bBlob); bBlob = protectedData; } else { #pragma warning disable 618 // calling obsolete methods // otherwise.. ////////////////////////////////////////////////////////////////////// // Step 2: Get the MAC and add to the blob if (_Protection == FormsProtectionEnum.All || _Protection == FormsProtectionEnum.Validation) { byte[] bMac = MachineKeySection.HashData(bBlob, null, 0, bBlob.Length); if (bMac == null) { return(null); } byte[] bAll = new byte[bMac.Length + bBlob.Length]; Buffer.BlockCopy(bBlob, 0, bAll, 0, bBlob.Length); Buffer.BlockCopy(bMac, 0, bAll, bBlob.Length, bMac.Length); bBlob = bAll; } if (_Protection == FormsProtectionEnum.All || _Protection == FormsProtectionEnum.Encryption) { ////////////////////////////////////////////////////////////////////// // Step 3: Do the actual encryption // DevDiv Bugs 137864: Include a random IV if under the right compat mode // for improved encryption semantics bBlob = MachineKeySection.EncryptOrDecryptData(true, bBlob, null, 0, bBlob.Length, false, false, IVType.Random); } #pragma warning restore 618 // calling obsolete methods } if (!hexEncodedTicket) { return(HttpServerUtility.UrlTokenEncode(bBlob)); } else { return(CryptoUtil.BinaryToHex(bBlob)); } }
public MembershipService(IJabbrRepository repository, ICryptoService crypto) { _repository = repository; _crypto = crypto; }
public BaseSocketConnectionCreator(BaseSocketConnectionHost host, string name, IPEndPoint localEndPoint, ICryptoService cryptoService) : this(host, name, localEndPoint, EncryptType.etNone, CompressionType.ctNone, cryptoService, null) { }
/// <summary> /// Sets the crypto service. /// </summary> /// <param name="value">The value.</param> public void SetCryptoService(ICryptoService value) { cryptoServiceOverride = value; }
public ReplaceFileContentCommandTest() { _cryptoServiceMock = new CryptoServiceMock(); _loggerServiceMock = new LoggerServiceMock(); }
public ExternalAuthenticationService(DbContextBase db, ICryptoService crypto, IList <IExternalAuthenticationProvider> providers) { this.db = db; this.crypto = crypto; this.providers = providers; }
public DevInfoService(IEntityRepository <DevInfo, Guid> devInfoRepository, IEntityRepository <DevData, Guid> devDataRepository, IParameterValidateService parameterValidateService, ICryptoService cryptoService) { _devInfoRepository = devInfoRepository; _devDataRepository = devDataRepository; _parameterValidateService = parameterValidateService; _cryptoService = cryptoService; }
public ExchangeSynchronizationProvider(ISynchronizationManager synchronizationManager, ICryptoService crypto) : base(synchronizationManager, new ExchangeSyncService(Constants.AzureExchangeServiceAdress), crypto) { }
public HomogenizingCryptoServiceWrapper(ICryptoService wrapped) { WrappedCryptoService = wrapped; }
public AccountController(UserContext context, ICryptoService cryptoService, ICaptcha captcha) { db = context; this.cryptoService = cryptoService; this.captcha = captcha; }
public AddTemplateCommandTest() { _cryptoServiceMock = new CryptoServiceMock(); _registryServiceMock = new RegistryServiceMock(); _loggerServiceMock = new LoggerServiceMock(); }
public LoginManager(CurrentStorage storage) { this._storage = storage; this._cryptoService = storage.CryptoService; }
public AuthService(UserManager <User> userManager, SignInManager <User> signInManager, IDatabase database, IHttpContextAccessor httpContext, IConfiguration configuration, ICryptoService cryptoService) { this.userManager = userManager; this.signInManager = signInManager; this.database = database; this.httpContext = httpContext; this.cryptoService = cryptoService; this.Configuration = configuration; }
public AuthService( ICryptoService cryptoService, IApiService apiService, IUserService userService, ITokenService tokenService, IAppIdService appIdService, II18nService i18nService, IPlatformUtilsService platformUtilsService, IMessagingService messagingService, IVaultTimeoutService vaultTimeoutService, bool setCryptoKeys = true) { _cryptoService = cryptoService; _apiService = apiService; _userService = userService; _tokenService = tokenService; _appIdService = appIdService; _i18nService = i18nService; _platformUtilsService = platformUtilsService; _messagingService = messagingService; _vaultTimeoutService = vaultTimeoutService; _setCryptoKeys = setCryptoKeys; TwoFactorProviders = new Dictionary <TwoFactorProviderType, TwoFactorProvider>(); TwoFactorProviders.Add(TwoFactorProviderType.Authenticator, new TwoFactorProvider { Type = TwoFactorProviderType.Authenticator, Priority = 1, Sort = 1 }); TwoFactorProviders.Add(TwoFactorProviderType.YubiKey, new TwoFactorProvider { Type = TwoFactorProviderType.YubiKey, Priority = 3, Sort = 2, Premium = true }); TwoFactorProviders.Add(TwoFactorProviderType.Duo, new TwoFactorProvider { Type = TwoFactorProviderType.Duo, Name = "Duo", Priority = 2, Sort = 3, Premium = true }); TwoFactorProviders.Add(TwoFactorProviderType.OrganizationDuo, new TwoFactorProvider { Type = TwoFactorProviderType.OrganizationDuo, Name = "Duo (Organization)", Priority = 10, Sort = 4 }); TwoFactorProviders.Add(TwoFactorProviderType.Fido2WebAuthn, new TwoFactorProvider { Type = TwoFactorProviderType.Fido2WebAuthn, Priority = 4, Sort = 5, Premium = true }); TwoFactorProviders.Add(TwoFactorProviderType.Email, new TwoFactorProvider { Type = TwoFactorProviderType.Email, Priority = 0, Sort = 6, }); }
/// <summary> /// Construct a new instance of SecureDatabase. /// </summary> /// <param name="platform">The platform specific engine of SQLite (ISQLitePlatform)</param> /// <param name="dbfile">The sqlite db file path</param> /*protected SecureDatabase(ISQLitePlatform platform, string dbfile) : this(platform, dbfile, new CryptoService("MY-TEMP-SALT")) * { * }*/ /// <summary> /// Construct a new instance of SecureDatabase. /// This ctor allows you pass an instance of the CryptoService. You could use the one provided by SQLite.Net.Cipher or build and pass your own. /// </summary> /// <param name="platform">The platform specific engine of SQLite (ISQLitePlatform)</param> /// <param name="dbfile">The sqlite db file path</param> /// <param name="cryptoService">An instance of the Crypto Service</param> protected SecureDatabase(ISQLitePlatform platform, string dbfile, ICryptoService cryptoService) : base(platform, dbfile) { _cryptoService = cryptoService; CreateTables(); }
public App(AppOptions appOptions) { _appOptions = appOptions ?? new AppOptions(); _userService = ServiceContainer.Resolve <IUserService>("userService"); _broadcasterService = ServiceContainer.Resolve <IBroadcasterService>("broadcasterService"); _messagingService = ServiceContainer.Resolve <IMessagingService>("messagingService"); _stateService = ServiceContainer.Resolve <IStateService>("stateService"); _lockService = ServiceContainer.Resolve <ILockService>("lockService"); _syncService = ServiceContainer.Resolve <ISyncService>("syncService"); _tokenService = ServiceContainer.Resolve <ITokenService>("tokenService"); _cryptoService = ServiceContainer.Resolve <ICryptoService>("cryptoService"); _cipherService = ServiceContainer.Resolve <ICipherService>("cipherService"); _folderService = ServiceContainer.Resolve <IFolderService>("folderService"); _settingsService = ServiceContainer.Resolve <ISettingsService>("settingsService"); _collectionService = ServiceContainer.Resolve <ICollectionService>("collectionService"); _searchService = ServiceContainer.Resolve <ISearchService>("searchService"); _authService = ServiceContainer.Resolve <IAuthService>("authService"); _platformUtilsService = ServiceContainer.Resolve <IPlatformUtilsService>("platformUtilsService"); _storageService = ServiceContainer.Resolve <IStorageService>("storageService"); _secureStorageService = ServiceContainer.Resolve <IStorageService>("secureStorageService"); _passwordGenerationService = ServiceContainer.Resolve <IPasswordGenerationService>( "passwordGenerationService"); _i18nService = ServiceContainer.Resolve <II18nService>("i18nService") as MobileI18nService; _deviceActionService = ServiceContainer.Resolve <IDeviceActionService>("deviceActionService"); Bootstrap(); _broadcasterService.Subscribe(nameof(App), async(message) => { if (message.Command == "showDialog") { var details = message.Data as DialogDetails; var confirmed = true; var confirmText = string.IsNullOrWhiteSpace(details.ConfirmText) ? AppResources.Ok : details.ConfirmText; Device.BeginInvokeOnMainThread(async() => { if (!string.IsNullOrWhiteSpace(details.CancelText)) { confirmed = await Current.MainPage.DisplayAlert(details.Title, details.Text, confirmText, details.CancelText); } else { await Current.MainPage.DisplayAlert(details.Title, details.Text, confirmText); } _messagingService.Send("showDialogResolve", new Tuple <int, bool>(details.DialogId, confirmed)); }); } else if (message.Command == "locked") { await _stateService.PurgeAsync(); var autoPromptFingerprint = !(message.Data as bool?).GetValueOrDefault(); if (autoPromptFingerprint && Device.RuntimePlatform == Device.iOS) { var lockOptions = await _storageService.GetAsync <int?>(Constants.LockOptionKey); if (lockOptions == 0) { autoPromptFingerprint = false; } } var lockPage = new LockPage(_appOptions, autoPromptFingerprint); Device.BeginInvokeOnMainThread(() => Current.MainPage = new NavigationPage(lockPage)); } else if (message.Command == "lockVault") { await _lockService.LockAsync(true); } else if (message.Command == "logout") { if (Migration.MigrationHelpers.Migrating) { return; } Device.BeginInvokeOnMainThread(async() => await LogOutAsync(false)); } else if (message.Command == "loggedOut") { // Clean up old migrated key if they ever log out. await _secureStorageService.RemoveAsync("oldKey"); } else if (message.Command == "resumed") { if (Device.RuntimePlatform == Device.iOS) { ResumedAsync(); } } else if (message.Command == "migrated") { await Task.Delay(1000); await SetMainPageAsync(); } else if (message.Command == "popAllAndGoToTabGenerator" || message.Command == "popAllAndGoToTabMyVault") { Device.BeginInvokeOnMainThread(async() => { if (Current.MainPage is TabsPage tabsPage) { while (tabsPage.Navigation.ModalStack.Count > 0) { await tabsPage.Navigation.PopModalAsync(false); } if (message.Command == "popAllAndGoToTabMyVault") { _appOptions.MyVaultTile = false; tabsPage.ResetToVaultPage(); } else { _appOptions.GeneratorTile = false; tabsPage.ResetToGeneratorPage(); } } }); } }); }
public UserService(IGenericRepository <User> genericUserRepo, IGenericRepository <WaniKaniUser> genericWKUserRepo, ICryptoService cryServ) { _userRepo = genericUserRepo; _wkUserRepo = genericWKUserRepo; _cryptoService = cryServ; }
public VercorsSynchronizationProvider(ISynchronizationManager synchronizationManager, ICryptoService cryptoService, IVercorsService vercorsService) : base(synchronizationManager, cryptoService) { if (vercorsService == null) { throw new ArgumentNullException("vercorsService"); } this.service = vercorsService; }
public AuthenticationService(IRepository <User> repository, ICryptoService cryptoService) { _cryptoService = cryptoService; _repository = repository; }
public ShowParametersCommandTest() { _cryptoServiceMock = new CryptoServiceMock(); _loggerServiceMock = new LoggerServiceMock(); }
public ReportInfoService(IEntityRepository <SYS_USER, Guid> userRepository, IEntityRepository <Report_Energy, long> report_Energy, IEntityRepository <VT_SYSTEM, Guid> systemRepository, IEntityRepository <SYS_USERSERVICEAREA, Guid> sysUserservicearea, IEntityRepository <Sys_ResellerLicense, long> sys_ResellerLicense, IEntityRepository <Sys_ServicePartnerSn, long> sys_ServicePartnerSn, IEntityRepository <SYS_SN, Guid> snRepository, IEntityRepository <SYS_ROLE, Guid> sys_ROLE, IEntityRepository <SYS_ROLEUSER, Guid> sys_ROLEUSER, IParameterValidateService parameterValidateService, ICryptoService cryptoService, IEntityRepository <SYS_LOG, Guid> sysLogService) { _userRepository = userRepository; _report_Energy = report_Energy; _systemRepository = systemRepository; _sysUserservicearea = sysUserservicearea; _sys_ResellerLicense = sys_ResellerLicense; _sys_ServicePartnerSn = sys_ServicePartnerSn; _snRepository = snRepository; _sys_ROLE = sys_ROLE; _sys_ROLEUSER = sys_ROLEUSER; _parameterValidateService = parameterValidateService; _cryptoService = cryptoService; _sysLogService = sysLogService; }
public TemplateCommandTest() { _cryptoServiceMock = new CryptoServiceMock(); _storedDataService = new StoredDataServiceMock(); _loggerServiceMock = new LoggerServiceMock(); }
public SocketListener AddListener(string name, IPEndPoint localEndPoint, EncryptType encryptType, CompressionType compressionType, ICryptoService cryptoService) { return(AddListener(name, localEndPoint, encryptType, compressionType, cryptoService, 5, 2)); }
public ClientState(ICryptoService cryptoService, IHashCalculationsRepository hashCalculationsRepository) { _cryptoService = cryptoService; _defaultHashCalculation = hashCalculationsRepository.Create(Globals.DEFAULT_HASH); }
public ShowPipelinesCommandTest() { _cryptoServiceMock = new CryptoServiceMock(); _registryServiceMock = new RegistryServiceMock(); _loggerServiceMock = new LoggerServiceMock(); }
public MyDatabase(ISQLitePlatform platform, string dbfile, ICryptoService cryptoService) : base(platform, dbfile, cryptoService) { }
public SocketConnector AddConnector(string name, IPEndPoint remoteEndPoint, ProxyInfo proxyData, EncryptType encryptType, CompressionType compressionType, ICryptoService cryptoService, int reconnectAttempts, int reconnectAttemptInterval) { return(AddConnector(name, remoteEndPoint, proxyData, encryptType, compressionType, cryptoService, reconnectAttempts, reconnectAttemptInterval, new IPEndPoint(IPAddress.Any, 0))); }
public ChatService(IJabbrRepository repository, ICryptoService crypto) { _repository = repository; _crypto = crypto; }
public SocketConnector AddConnector(string name, IPEndPoint remoteEndPoint, ProxyInfo proxyData, EncryptType encryptType, CompressionType compressionType, ICryptoService cryptoService, int reconnectAttempts, int reconnectAttemptInterval, IPEndPoint localEndPoint) { SocketConnector result = null; if (!Disposed) { result = new SocketConnector(this, name, remoteEndPoint, proxyData, encryptType, compressionType, cryptoService, reconnectAttempts, reconnectAttemptInterval, localEndPoint); AddCreator(result); } return(result); }