Esempio n. 1
0
 public HandleSignOnCommand(IProcessQueries queries, IProcessCommands commands, IWriteEntities entities, IAuthenticate authenticator)
 {
     _queries       = queries;
     _commands      = commands;
     _entities      = entities;
     _authenticator = authenticator;
 }
 public AuthenticationRepository()
 {
     if (_repos == null)
     {
         _repos = new RcAuthenticationService();
     }
 }
Esempio n. 3
0
        private async Task <object> AuthenticateUser(IClientContext context, IUserAccount user, string sessionSalt,
                                                     IAuthenticate authenticateRequest)
        {
            object response;

            if (user.IsLocked)
            {
                response = _authenticationMessageFactory.CreateAuthenticationResult(AuthenticateReplyState.Locked, null);
            }
            else
            {
                var serverHash = _passwordHasher.HashPassword(user.HashedPassword, sessionSalt);
                if (_passwordHasher.Compare(serverHash, authenticateRequest.AuthenticationToken))
                {
                    context.ChannelData["Principal"] = await PrincipalFactory.CreatePrincipalAsync(user);

                    var proof = _passwordHasher.HashPassword(user.HashedPassword, authenticateRequest.ClientSalt);
                    response = _authenticationMessageFactory.CreateAuthenticationResult(AuthenticateReplyState.Success,
                                                                                        proof);
                }
                else
                {
                    response =
                        _authenticationMessageFactory.CreateAuthenticationResult(AuthenticateReplyState.IncorrectLogin,
                                                                                 null);
                }
            }
            return(response);
        }
 public SurveyController(ISurveyRoot _surveyRoot, ISurveyQuestions _surveyQuestionRoot, IMemoryCache _memoryCache, IAuthenticate authContext) : base(_memoryCache, authContext)
 {
     surveyRoot            = _surveyRoot;
     surveyQuestionRoot    = _surveyQuestionRoot;
     authenticationContext = authContext;
     memoryCache           = _memoryCache;
 }
Esempio n. 5
0
 public AuthenticationController(IMapper mapper, IAuthenticate IAuthenticate, IConfiguration IConfiguration)
 {
     _response       = new Response();
     _mapper         = mapper;
     _IAuthenticate  = IAuthenticate;
     _IConfiguration = IConfiguration;
 }
        public void AuthenticationShouldSucceed()
        {
            const string testBaseUri        = "https://127.0.0.1";
            const string expectedRequestUrl = testBaseUri + "/v15/access_tokens";

            const string testClientId         = "1a2b3c4d5e6f7g8h9i0j";
            const string testMerchantUsername = "******";
            const string testMerchantPassword = "******";

            string expectedRequestbody = string.Format("{{\"access_token\": {{" +
                                                       "\"api_key\": \"{0}\"" +
                                                       ",\"username\": \"{1}\"" +
                                                       ",\"password\": \"{2}\"" +
                                                       "}}}}",
                                                       testClientId,
                                                       testMerchantUsername,
                                                       testMerchantPassword);

            // This response format does not matter for this test.
            RestResponse expectedResponse = new RestResponse
            {
                StatusCode = HttpStatusCode.OK,
            };

            IAuthenticate auth =
                ClientModuleFunctionalTestingUtilities.GetMockedLevelUpModule <IAuthenticate, AccessTokenRequest>(
                    expectedResponse,
                    expectedRequestbody,
                    expectedAccessToken: null,
                    expectedRequestUrl: expectedRequestUrl,
                    environmentToUse: new LevelUpEnvironment(testBaseUri));

            var token = auth.Authenticate(testClientId, testMerchantUsername, testMerchantPassword);
        }
Esempio n. 7
0
 public AuthController(
     IAuthenticate login,
     IRegister register
     )
 {
     _login    = login;
     _register = register;
 }
 public FacilityReservationController(IFacilityReservationService facilityReservationService, IPublicArea publicArea,
                                      IGuestService guestService, IAuthenticate authenticator)
 {
     _facilityReservationService = facilityReservationService;
     _publicArea    = publicArea;
     _guestService  = guestService;
     _authenticator = authenticator;
 }
 public SwaggerAuthentication(RequestDelegate next, IHostingEnvironment environment, IAuthenticate authenticate,
                              IOptions <AppSettingModel> options)
 {
     _next         = next;
     _environment  = environment;
     _authenticate = authenticate;
     _options      = options;
 }
 /// <summary>
 /// Creates a new instance of <see cref="BearerAuthenticationHandler"/>
 /// </summary>
 /// <param name="options">Configuration options</param>
 /// <param name="logger">Logger</param>
 /// <param name="encoder">Url encoder</param>
 /// <param name="clock">System clock</param>
 /// <param name="authService">Authentication service</param>
 public BearerAuthenticationHandler(
     IOptionsMonitor <BearerAuthenticationOptions> options,
     ILoggerFactory logger,
     UrlEncoder encoder,
     ISystemClock clock,
     IAuthenticate authService) : base(options, logger, encoder, clock)
 {
     _authService = authService;
 }
Esempio n. 11
0
 public bool CloseDoor(int user_id, int door_id)
 {
     authentication = new Authenticate();
     if (authentication.IsAuthenticated(user_id, door_id))
     {
         return(simulation.GetBuilding(0).CloseDoor(user_id, door_id));
     }
     return(false);
 }
Esempio n. 12
0
            static UserAccessTokenHolder()
            {
                IAuthenticate auth  = GetSandboxedLevelUpModule <IAuthenticate>();
                var           token = auth.Authenticate(LevelUpTestConfiguration.Current.ClientId,
                                                        LevelUpTestConfiguration.Current.ConsumerUsername,
                                                        LevelUpTestConfiguration.Current.ConsumerPassword);

                SandboxedLevelUpUserAccessToken = token.Token;
            }
Esempio n. 13
0
        /// <summary>
        /// Reads an ICU data header, checks the data format, and returns the data version.
        /// </summary>
        /// <remarks>
        /// Assumes that the <see cref="ByteBuffer"/> position is 0 on input.
        /// <para/>
        /// The buffer byte order is set according to the data.
        /// The buffer position is advanced past the header (including UDataInfo and comment).
        /// <para/>
        /// See C++ ucmndata.h and unicode/udata.h.
        /// </remarks>
        /// <returns>dataVersion</returns>
        /// <exception cref="IOException">If this is not a valid ICU data item of the expected dataFormat.</exception>
        public static int ReadHeader(ByteBuffer bytes, int dataFormat, IAuthenticate authenticate)
        {
            Debug.Assert(bytes != null && bytes.Position == 0);
            byte magic1 = bytes.Get(2);
            byte magic2 = bytes.Get(3);

            if (magic1 != MAGIC1 || magic2 != MAGIC2)
            {
                throw new IOException(MAGIC_NUMBER_AUTHENTICATION_FAILED_);
            }

            byte isBigEndian   = bytes.Get(8);
            byte charsetFamily = bytes.Get(9);
            byte sizeofUChar   = bytes.Get(10);

            if (isBigEndian < 0 || 1 < isBigEndian ||
                charsetFamily != CHAR_SET_ || sizeofUChar != CHAR_SIZE_)
            {
                throw new IOException(HEADER_AUTHENTICATION_FAILED_);
            }
            bytes.Order = isBigEndian != 0 ? ByteOrder.BIG_ENDIAN : ByteOrder.LITTLE_ENDIAN;

            int headerSize      = bytes.GetChar(0);
            int sizeofUDataInfo = bytes.GetChar(4);

            if (sizeofUDataInfo < 20 || headerSize < (sizeofUDataInfo + 4))
            {
                throw new IOException("Internal Error: Header size error");
            }
            // TODO: Change Authenticate to take int major, int minor, int milli, int micro
            // to avoid array allocation.
            byte[] formatVersion = new byte[] {
                bytes.Get(16), bytes.Get(17), bytes.Get(18), bytes.Get(19)
            };
            if (bytes.Get(12) != (byte)(dataFormat >> 24) ||
                bytes.Get(13) != (byte)(dataFormat >> 16) ||
                bytes.Get(14) != (byte)(dataFormat >> 8) ||
                bytes.Get(15) != (byte)dataFormat ||
                (authenticate != null && !authenticate.IsDataVersionAcceptable(formatVersion)))
            {
                // "; data format %02x%02x%02x%02x, format version %d.%d.%d.%d"

                throw new IOException(HEADER_AUTHENTICATION_FAILED_ +
                                      string.Format("; data format {0:x2}{1:x2}{2:x2}{3:x2}, format version {4}.{5}.{6}.{7}",
                                                    bytes.Get(12), bytes.Get(13), bytes.Get(14), bytes.Get(15),
                                                    formatVersion[0] & 0xff, formatVersion[1] & 0xff,
                                                    formatVersion[2] & 0xff, formatVersion[3] & 0xff));
            }

            bytes.Position = headerSize;
            return  // dataVersion
                   ((bytes.Get(20) << 24) |
                    ((bytes.Get(21) & 0xff) << 16) |
                    ((bytes.Get(22) & 0xff) << 8) |
                    (bytes.Get(23) & 0xff));
        }
Esempio n. 14
0
 public LoginPageViewModel(IAuthenticate authenticate,
                           INavigationService navigationService,
                           IPageDialogService pageDialogService,
                           ISecuredStorageWrapper securedStorageWrapper,
                           IDeviceService deviceService) :
     base(navigationService, pageDialogService, deviceService)
 {
     _authenticate          = authenticate;
     _securedStorageWrapper = securedStorageWrapper;
 }
Esempio n. 15
0
        public AuthController(IConfiguration configuration, IAuthenticate authenticate, ILogger logger)
        {
            //_logger = UnityHelper.Container.Resolve<ILogger>();
            _logger        = logger;
            _configuration = configuration;
            var appSettingsSection = _configuration.GetSection("AppSettings");

            appSettings   = appSettingsSection.Get <AppSettings>();
            _authenticate = authenticate;
        }
        public void SetUp()
        {
            _httpClientWrapper = Substitute.For <IHttpClientWrapper>();
            _authenticate      = Substitute.For <IAuthenticate>();

            _configuration = Substitute.For <IConfiguration>();

            _configuration.GetValue <string>("ApiMediaType").Returns("test-media-string");

            _sut = new ApiClient(_httpClientWrapper, _authenticate, _configuration);
        }
Esempio n. 17
0
 public UserController(
     IAuthenticate authenticate,
     ILoggerManager log,
     IToken <IUser> token,
     IEncryption aESSecurity)
 {
     this._authenticate = authenticate;
     this._aES          = aESSecurity;
     this._log          = log;
     this._token        = token;
 }
 public AccountController(IAppSetting setting,
                          IAuthenticate authenticate,
                          IEncryption encryption,
                          ILoggerManager logger,
                          IToken <IUser> token)
 {
     this._authenticate = authenticate;
     this._encryption   = encryption;
     this._logger       = logger;
     this._token        = token;
 }
 public LoginService(
     IOptions <AuthHeaderClientConfig> clientConfig,
     IOptions <AuthenticationConfig> authConfig,
     IAuthenticatedHttpClientWithHeader client,
     IAuthenticate authenticator,
     HttpLoggerService logger)
 {
     _clientConfig         = clientConfig;
     _authConfig           = authConfig;
     _client               = client;
     _client.Authenticator = authenticator;
     _logger               = logger;
 }
        public void AuthenticationShouldFailForErrorCode404NotFound()
        {
            const string testClientId         = "1212whatsinthestew34noonesreallysure";
            const string testMerchantUsername = "******";
            const string testMerchantPassword = "******";

            RestResponse expected = new RestResponse {
                StatusCode = HttpStatusCode.NotFound
            };
            IAuthenticate auth = ClientModuleUnitTestingUtilities.GetMockedLevelUpModule <IAuthenticate>(expected);

            // Should throw exception for non-200 [OK] response
            auth.Authenticate(testClientId, testMerchantUsername, testMerchantPassword);
        }
        public void GivenALogInRequest()
        {
            _authenticationObject = new Authenticate();

            _loginWindowThread = new Thread(new ThreadStart(() =>
            {
                _authenticationResult = _authenticationObject.AuthenticateUser();
            }));

            _loginWindowThread.SetApartmentState(ApartmentState.STA);
            _loginWindowThread.Start();

            _loginWindowObject = GetDialogWindowObjectFromHandle();
        }
Esempio n. 22
0
        public async Task <MobileServiceUser> LoginAsync()
        {
            IAuthenticate     auth = DependencyService.Get <IAuthenticate>();
            MobileServiceUser user = await auth.Authenticate(_client, MobileServiceAuthenticationProvider.Facebook);

            if (user == null)
            {
                Device.BeginInvokeOnMainThread(async() =>
                {
                    await Application.Current.MainPage.DisplayAlert("Ops!", "Problema no Login", "Ok");
                });
            }

            return(user);
        }
Esempio n. 23
0
 public StoreManager(INotificationStore notificationStore, ICategoryStore categoryStore, IFavoriteStore favoriteStore, ISessionStore sessionStore, ISpeakerStore speakerStore, IEventStore eventStore, ISponsorStore sponsorStore, IFeedbackStore feedbackStore, IAuthenticate authenticator, IWorkshopStore workshopStore, IApplicationDataStore applicationDataStore)
 {
     _notificationStore    = notificationStore;
     _categoryStore        = categoryStore;
     _favoriteStore        = favoriteStore;
     _sessionStore         = sessionStore;
     _speakerStore         = speakerStore;
     _eventStore           = eventStore;
     _sponsorStore         = sponsorStore;
     _feedbackStore        = feedbackStore;
     _authenticator        = authenticator;
     _workshopStore        = workshopStore;
     _applicationDataStore = applicationDataStore;
     Task.Run(async() => { await InitializeAsync().ConfigureAwait(false); }).Wait();
 }
Esempio n. 24
0
        public customerController(
            IAuthenticate authenticate,
            IGarageRepository garageRepository,
            IServiceRepository serviceRepository,
            ICustomerRepository customerRepository,
            ILogtimeRepository logtimeRepository)
        {
            this.authenticate       = authenticate;
            this.customerRepository = customerRepository;
            this.serviceRepository  = serviceRepository;
            this.garageRepository   = garageRepository;
            this.logtimeRepository  = logtimeRepository;

            ah = new authenticateHandler(this.authenticate, this.logtimeRepository);
            sh = new serviceHandler(this.serviceRepository, this.garageRepository);
            ch = new CustomerHandler(this.customerRepository);
        }
        public systemAdminController(
            IAuthenticate authenticate,
            IServiceRepository serviceRepository,
            ISysAdminRepository sysAdminRepository,
            IGarageRepository garageRepository,
            ILogtimeRepository logtimeRepository)
        {
            this.authenticate       = authenticate;
            this.sysAdminRepository = sysAdminRepository;
            this.serviceRepository  = serviceRepository;
            this.garageRepository   = garageRepository;
            this.logtimeRepository  = logtimeRepository;

            ah  = new authenticateHandler(this.authenticate, this.logtimeRepository);
            sh  = new serviceHandler(this.serviceRepository, this.garageRepository);
            sah = new systemAdminHandler(this.sysAdminRepository);
        }
        /// <summary>
        /// Performs the Authenticate(...) call to retrieve the access token that will be required for most of the
        /// subsequent requests you make to the LevelUp platform.
        /// </summary>
        private static string Authenticate(string merchantUserName, string merchantPassword, string apiKey)
        {
            try
            {
                IAuthenticate authenticator = LevelUpClientFactory.Create <IAuthenticate>(LuIdentifier, LuEnvironment);

                AccessToken tokenObj = authenticator.Authenticate(apiKey, merchantUserName, merchantPassword);

                return(tokenObj.Token);
            }
            catch (LevelUpApiException ex)
            {
                Console.WriteLine(string.Format("There was an error authenticating your user.  Are the credentials " +
                                                "correct? {0}{0}Exception Details: {1}", Environment.NewLine, ex.Message));
                return(null);
            }
        }
Esempio n. 27
0
        /// <summary>
        /// Cria um novo usuário no sistema.
        /// </summary>
        /// <param name="username">Nome do usuário.</param>
        /// <param name="password">Senha de acesso.</param>
        /// <param name="email">Email associado com o usuário.</param>
        /// <param name="passwordQuestion">Pergunta para a senha.</param>
        /// <param name="passwordAnswer">Resposta da pergunta para a recuperação da senha.</param>
        /// <param name="isApproved">Identifica se o usuário é aprovado.</param>
        /// <param name="identityProvider">Nome do provedor de identidade do usuário.</param>
        /// <param name="userKey">Chave que identifica o usuário.</param>
        /// <param name="ignoreCaptcha">Indica se o usuário irá ignorar o controle por captcha</param>
        /// <param name="status">Situação do usuário.</param>
        /// <param name="fullname">Nome do usuário</param>
        /// <param name="parameters">Parametros adicionais para a criação do usuário</param>
        /// <returns></returns>
        public virtual Security.IUser CreateUser(string username, string password, string fullname, string email, string passwordQuestion, string passwordAnswer, bool isApproved, string identityProvider, string userKey, bool ignoreCaptcha, out UserCreateStatus status, params SecurityParameter[] parameters)
        {
            IIdentityProviderManager providerFlow = Microsoft.Practices.ServiceLocation.ServiceLocator.Current.GetInstance <IIdentityProviderManager>();
            var result = GetUser(username, false) as Security.Authentication.IAutheticableUser;

            if ((result != null) && (!String.IsNullOrEmpty(result.UserKey)))
            {
                status = UserCreateStatus.DuplicateUserName;
                result = null;
            }
            else
            {
                result.UserName                = username;
                result.Email                   = email;
                result.FullName                = fullname;
                result.IdentityProvider        = identityProvider;
                result.LastPasswordChangedDate = ServerData.GetDateTime();
                result.PasswordAnswer          = passwordAnswer;
                result.PasswordQuestion        = passwordQuestion;
                result.UserName                = username;
                result.IdentityProviderId      = providerFlow.GetProviderByName(identityProvider).IdentityProviderId;
                if (InsertUser(result))
                {
                    status = UserCreateStatus.Success;
                    result = GetUser(username, false) as Security.Authentication.IAutheticableUser;
                    IAuthenticate provider = Activator.CreateInstance((providerFlow.GetProviderByName(identityProvider).Type)) as IAuthenticate;
                    if (provider.CanCreateUser)
                    {
                        if (provider.CreateNewUser(result, password, parameters).Success)
                        {
                            status = UserCreateStatus.Success;
                        }
                        else
                        {
                            status = UserCreateStatus.DuplicateProviderUserKey;
                        }
                    }
                }
                else
                {
                    status = UserCreateStatus.ProviderError;
                }
            }
            return(result);
        }
Esempio n. 28
0
        public AuthenticateResultDTO Authenticate(Credentials credentials)
        {
            AuthenticateResultDTO result       = new AuthenticateResultDTO();
            IAuthenticate         authenticate = BusinessFactory.GetAuthentication();

            if (authenticate.IsValid(credentials))
            {
                result.IsAuthenticated = true;
                result.UserId          = BusinessFactory.GetUserProcess().GetUser(credentials).UserId;
                result.Token           = authenticate.BuildToken(credentials);
            }
            else
            {
                result.IsAuthenticated = false;
                result.ErrorMessage    = "Invalid username or password.";
            }
            return(result);
        }
Esempio n. 29
0
        public mechanicController(
            IApplicationRepository applicationRepository,
            IAuthenticate authenticate,
            IServiceRepository serviceRepository,
            IMechanicRepository mechanicRepository,
            IGarageRepository garageRepository,
            ILogtimeRepository logtimeRepository)
        {
            this.authenticate          = authenticate;
            this.mechanicRepository    = mechanicRepository;
            this.serviceRepository     = serviceRepository;
            this.applicationRepository = applicationRepository;
            this.garageRepository      = garageRepository;
            this.logtimeRepository     = logtimeRepository;

            ah = new authenticateHandler(this.authenticate, this.logtimeRepository);
            sh = new serviceHandler(this.serviceRepository, this.garageRepository);
            mh = new MechanicHandler(this.mechanicRepository, this.garageRepository, this.applicationRepository);
        }
        public ActionResult Index(AuthenticationModel userDetails)
        {
            if (ModelState.IsValid)
            {
                IAuthenticate authenticationService = AuthenticationFactory.getAuthService();
                bool          authenticated         = authenticationService.Authenticate(userDetails.Username, userDetails.Password);

                if (authenticated)
                {
                    FormsAuthentication.SetAuthCookie(userDetails.Username, false);

                    // Forward User to Application Home Page
                    return(RedirectToAction("Index", "Home"));
                }
            }

            // Forward user to Not Authenticated Alert page
            return(View("NotAuthenticated"));
        }
Esempio n. 31
0
        public garageController(
            IApplicationRepository applicationRepository,
            IAuthenticate authenticate,
            IServiceRepository serviceRepository,
            IGarageRepository garageRepository,
            ILogtimeRepository logtimeRepository,
            ILocationRepository locationRepository)
        {
            this.locationRepository    = locationRepository;
            this.authenticate          = authenticate;
            this.serviceRepository     = serviceRepository;
            this.garageRepository      = garageRepository;
            this.applicationRepository = applicationRepository;
            this.logtimeRepository     = logtimeRepository;

            ah = new authenticateHandler(this.authenticate, this.logtimeRepository);
            sh = new serviceHandler(this.serviceRepository, this.garageRepository);
            gh = new GarageHandler(this.applicationRepository, this.garageRepository, this.locationRepository);
        }
 private async Task<object> AuthenticateUser(IClientContext context, IUserAccount user, string sessionSalt,
     IAuthenticate authenticateRequest)
 {
     object response;
     if (user.IsLocked)
         response = _authenticationMessageFactory.CreateAuthenticationResult(AuthenticateReplyState.Locked, null);
     else
     {
         var serverHash = _passwordHasher.HashPassword(user.HashedPassword, sessionSalt);
         if (_passwordHasher.Compare(serverHash, authenticateRequest.AuthenticationToken))
         {
             context.ChannelData["Principal"] = await PrincipalFactory.CreatePrincipalAsync(user);
             var proof = _passwordHasher.HashPassword(user.HashedPassword, authenticateRequest.ClientSalt);
             response = _authenticationMessageFactory.CreateAuthenticationResult(AuthenticateReplyState.Success,
                 proof);
         }
         else
             response =
                 _authenticationMessageFactory.CreateAuthenticationResult(AuthenticateReplyState.IncorrectLogin,
                     null);
     }
     return response;
 }
Esempio n. 33
0
		public App()
		{
			AuthenticationProvider = new AuthenticationProvider();
			MainPage = new NavigationPage(new LoginPage());
		}
Esempio n. 34
0
		public static void Init (IAuthenticate authenticator)
		{
			Authenticator = authenticator;
		}
 /// <summary>
 /// Constructor to establish this class' dependencies.  Since the 
 /// class is not "complete" (can't operate) without an authentication
 /// provider, we require an object up front.
 /// </summary>
 /// <param name="authProvider"></param>
 public MyClassWithDependencyInjection(IAuthenticate authProvider)
 {
     if (authProvider == null)
         throw new ArgumentNullException("authProvider");
     _authenticationProvider = authProvider;
 }
Esempio n. 36
0
 public AuthorizationFilter(IAuthenticate authenticator)
 {
     Check.NotNull(authenticator, "authenticator");
     this.authenticator = authenticator;
     Check.InjectedMembers(this);
 }
Esempio n. 37
0
		public App()
		{
			Authenticator = DependencyService.Get<IAuthenticate>();
			MainPage = new NavigationPage(new LoginPage());
		}
 public AccountController()
 {
     _authenticator = new DatabaseAuthentication();
     _userRepository = new NHUserRepository();
 }