예제 #1
0
        public IActionResult Login()
        {
            IdentityViewModel identityViewModel = new IdentityViewModel();

            identityViewModel.invalid = false;
            return(View(identityViewModel));
        }
예제 #2
0
        public async Task <IActionResult> Token([FromBody] IdentityViewModel model)
        {
            SignInResult result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, true, false);

            if (!result.Succeeded)
            {
                return(Unauthorized());
            }

            ApplicationUser user = await _userManager.FindByEmailAsync(model.Email);

            CurrentUserId = user.Id;

            List <Claim> claims = new List <Claim>
            {
                new Claim(ClaimsIdentity.DefaultNameClaimType, model.Email),
            };

            DateTime         now = DateTime.UtcNow;
            JwtSecurityToken jwt = new JwtSecurityToken(
                issuer: AuthOptions.ISSUER,
                audience: AuthOptions.AUDIENCE,
                notBefore: now,
                claims: claims,
                expires: now.Add(TimeSpan.FromMinutes(AuthOptions.LIFETIME)),
                signingCredentials: new SigningCredentials(AuthOptions.GetSymmetricSecurityKey(),
                                                           SecurityAlgorithms.HmacSha256));
            string encodedJwt = new JwtSecurityTokenHandler().WriteToken(jwt);

            return(Ok(encodedJwt));
        }
        public async Task TestLogOnLogOffWhenLoggedOn()
        {
            LogOnIdentity passphrase = new LogOnIdentity("p");

            LogOnIdentity id = passphrase;

            Resolve.FileSystemState.KnownPassphrases.Add(id.Passphrase);
            await Resolve.KnownIdentities.SetDefaultEncryptionIdentity(id);

            bool wasLoggingOn     = false;
            IdentityViewModel ivm = new IdentityViewModel(Resolve.FileSystemState, Resolve.KnownIdentities, Resolve.UserSettings, Resolve.SessionNotify);

            ivm.LoggingOnAsync = (e) =>
            {
                wasLoggingOn = true;
                return(Task.FromResult <object>(null));
            };

            Assert.That(Resolve.KnownIdentities.IsLoggedOn, Is.True);

            await ivm.LogOnLogOff.ExecuteAsync(null);

            Assert.That(wasLoggingOn, Is.False);
            Assert.That(Resolve.KnownIdentities.IsLoggedOn, Is.False);
        }
예제 #4
0
        public async Task <IActionResult> Token([FromBody] IdentityViewModel request)
        {
            //Добавить проверку срока жизни PIN-кода
            if (!ValidateUser(request))
            {
                return(Unauthorized());
            }

            var claims = new List <Claim>
            {
                new Claim(ClaimsIdentity.DefaultNameClaimType, request.Login),
            };
            var identity = new ClaimsIdentity(claims, "Token", ClaimsIdentity.DefaultNameClaimType, ClaimsIdentity.DefaultRoleClaimType);

            var now = DateTime.UtcNow;
            var jwt = new JwtSecurityToken(
                issuer: "FamilIntegrationService",
                audience: "IntegrationUser",
                notBefore: now,
                claims: identity.Claims,
                expires: now.Add(TimeSpan.FromHours(24)),
                signingCredentials: new SigningCredentials(new SymmetricSecurityKey(Encoding.ASCII.GetBytes("gfdiog40-]kgf-043uo")), SecurityAlgorithms.HmacSha256));
            var encodedJwt = new JwtSecurityTokenHandler().WriteToken(jwt);

            return(Ok(encodedJwt));
        }
        public async Task <IActionResult> Login(string returnUrl, string confirmed, string invalid)
        {
            IdentityViewModel identityViewModel = new IdentityViewModel();

            //identityViewModel.invalid = false;
            if (!string.IsNullOrEmpty(confirmed))
            {
                identityViewModel.confirmed = confirmed;
            }
            if (!string.IsNullOrEmpty(invalid))
            {
                if (invalid == "upw")
                {
                    identityViewModel.invalid = "Username and password combination wrong";
                }
                else
                {
                    identityViewModel.invalid = "Email not confirmed yet";
                }
            }

            identityViewModel.login.ReturnUrl      = returnUrl;
            identityViewModel.login.ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();

            return(View(identityViewModel));
        }
        public async Task AskForNewLogOnPassphraseWithKnownIdentity()
        {
            Passphrase passphrase = new Passphrase("aaa");
            Passphrase id         = passphrase;

            Resolve.FileSystemState.KnownPassphrases.Add(id);

            IdentityViewModel ivm = new IdentityViewModel(Resolve.FileSystemState, Resolve.KnownIdentities, Resolve.UserSettings, Resolve.SessionNotify);

            ivm.LoggingOnAsync = (e) =>
            {
                if (!e.IsAskingForPreviouslyUnknownPassphrase)
                {
                    e.IsAskingForPreviouslyUnknownPassphrase = true;
                }
                e.Passphrase = new Passphrase("aaa");
                return(Task.FromResult <object>(null));
            };

            await ivm.AskForLogOnPassphrase.ExecuteAsync(null);

            Assert.That(ivm.LogOnIdentity.Passphrase.Text, Is.EqualTo("aaa"));
            Assert.That(Resolve.KnownIdentities.DefaultEncryptionIdentity.Passphrase.Thumbprint, Is.EqualTo(passphrase.Thumbprint));
            Assert.That(Resolve.FileSystemState.KnownPassphrases.Count(), Is.EqualTo(1));
        }
        public async Task AskForNewLogOnPassphrase()
        {
            Passphrase defaultPassphrase = null;

            Resolve.FileSystemState.KnownPassphrases.Add(Passphrase.Empty);
            IdentityViewModel ivm = new IdentityViewModel(Resolve.FileSystemState, Resolve.KnownIdentities, Resolve.UserSettings, Resolve.SessionNotify);

            ivm.LoggingOnAsync = (e) =>
            {
                if (!e.IsAskingForPreviouslyUnknownPassphrase)
                {
                    e.IsAskingForPreviouslyUnknownPassphrase = true;
                    e.Passphrase = new Passphrase("xxx");
                    return(Task.FromResult <object>(null));
                }
                defaultPassphrase = e.Passphrase;
                e.Passphrase      = new Passphrase("aaa");
                return(Task.FromResult <object>(null));
            };

            await ivm.AskForLogOnPassphrase.ExecuteAsync(null);

            Assert.That(defaultPassphrase, Is.EqualTo(new Passphrase("xxx")));
            Assert.That(ivm.LogOnIdentity.Passphrase.Text, Is.EqualTo("aaa"));
            Assert.That(Resolve.KnownIdentities.DefaultEncryptionIdentity.Passphrase.Thumbprint, Is.EqualTo(new Passphrase("aaa").Thumbprint));

            Passphrase id = Resolve.FileSystemState.KnownPassphrases.FirstOrDefault(i => i.Thumbprint == new Passphrase("aaa").Thumbprint);

            Assert.That(id.Thumbprint, Is.EqualTo(Resolve.KnownIdentities.DefaultEncryptionIdentity.Passphrase.Thumbprint));
        }
예제 #8
0
        public async Task <IActionResult> Token([FromBody] IdentityViewModel model)
        {
            var identity = await GetIdentity(model.Username, model.Password);

            if (identity == null)
            {
                return(Unauthorized());
            }

            var now = DateTime.UtcNow;
            // создаем JWT-токен
            var jwt = new JwtSecurityToken(
                issuer: AuthOptions.ISSUER,
                audience: AuthOptions.AUDIENCE,
                notBefore: now,
                claims: identity.Claims,
                expires: now.Add(TimeSpan.FromMinutes(AuthOptions.LIFETIME)),
                signingCredentials: new SigningCredentials(AuthOptions.GetSymmetricSecurityKey(), SecurityAlgorithms.HmacSha256));
            var encodedJwt = new JwtSecurityTokenHandler().WriteToken(jwt);

            var response = new
            {
                access_token = encodedJwt,
                username     = identity.Name
            };

            return(Ok(response));
        }
        public async Task <IActionResult> LoginIn(IdentityViewModel identityViewModel, string ReturnUrl)
        {
            identityViewModel.login.ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();

            if (ModelState.IsValid)
            {
                var user = await _userManager.FindByEmailAsync(identityViewModel.login.LoginEmail);

                if (user != null && !user.EmailConfirmed &&
                    (await _userManager.CheckPasswordAsync(user, identityViewModel.login.LoginPassword)))
                {
                    return(RedirectToAction("login", new { invalid = "enc" }));
                }

                return(RedirectToAction("SendSms", "Twilio", new { userId = user.Id, isPersistent = identityViewModel.login.RememberMe }));
                //var result = await _signInManager.PasswordSignInAsync(identityViewModel.login.LoginEmail, identityViewModel.login.LoginPassword, identityViewModel.login.RememberMe, false);

                //if (result.Succeeded)
                //{
                //    if (!string.IsNullOrEmpty(ReturnUrl))
                //    {
                //        return Redirect(ReturnUrl);
                //    }
                //    else
                //    {
                //        return RedirectToAction("Index", "Home", new { Area = "Client" });
                //    }
                //}
            }
            return(RedirectToAction("login", new { invalid = "upw" }));
        }
예제 #10
0
        public async Task <IActionResult> Token([FromBody] IdentityViewModel request)
        {
            if (!ValidateUser(request))
            {
                return(Unauthorized());
            }

            var claims = new List <Claim>
            {
                new Claim(ClaimsIdentity.DefaultNameClaimType, request.Login),
            };
            var identity = new ClaimsIdentity(claims, "Token", ClaimsIdentity.DefaultNameClaimType, ClaimsIdentity.DefaultRoleClaimType);

            var now = DateTime.UtcNow;
            var jwt = new JwtSecurityToken(
                issuer: "MonitoringHelperService",
                audience: "MonitoringUser",
                notBefore: now,
                claims: identity.Claims,
                expires: now.Add(TimeSpan.FromHours(24)),
                signingCredentials: new SigningCredentials(new SymmetricSecurityKey(Encoding.ASCII.GetBytes("nr490jf390353hj9")), SecurityAlgorithms.HmacSha256));
            var encodedJwt = new JwtSecurityTokenHandler().WriteToken(jwt);

            return(Ok(encodedJwt));
        }
예제 #11
0
        private bool ValidateUser(IdentityViewModel request)
        {
            CreateTableIfNotExists();
            var passwordHash = GetPasswordHash(request.Password);

            using (var conn = new NpgsqlConnection(DBProvider.GetConnectionString()))
            {
                conn.Open();
                return((Int64) new NpgsqlCommand(String.Format(@"Select COUNT(1) from ""public"".""User"" Where ""Login"" = '{0}' and ""Password"" = '{1}'", request.Login, passwordHash), conn).ExecuteScalar() > 0);
            }
        }
        public async Task <IActionResult> IsEmailInUse(IdentityViewModel identityViewModel)
        {
            var user = await _userManager.FindByEmailAsync(identityViewModel.signup.CustomerEmail);

            if (user == null)
            {
                return(Json(true));
            }
            else
            {
                return(Json("Email is already in use"));
            }
        }
예제 #13
0
        public void Edit_Valid()
        {
            //Arrange
            IdentityViewModel model = new IdentityViewModel()
            {
                GUID = "test"
            };

            //Act
            var result = (ViewResult)controllerWEB.Edit(model);

            //Assert
            Assert.AreEqual("", result.ViewName);
        }
예제 #14
0
 public ActionResult Edit(IdentityViewModel model, HttpPostedFileBase filedata = null)
 {
     if (ModelState.IsValid && filedata != null)
     {
         var user = service.GetSimple(model.ID);
         user.Picture = service.SaveImage(filedata, user.Picture);
         service.Edit(user);
         return(RedirectToAction("Index"));
     }
     else
     {
         return(View(model));
     }
 }
예제 #15
0
        public ActionResult Edit(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            IdentityViewModel model = (IdentityViewModel)service.GetSimple(id);

            if (model != null)
            {
                return(View(model));
            }
            return(HttpNotFound());
        }
예제 #16
0
        private async void WebView_ScriptNotifyAsync(object sender, NotifyEventArgs e)
        {
            bool validUri = false;

            switch (e.CallingUri.LocalPath.ToString())
            {
            case "/PacFORMS/XSC_ICS-213_Message_v070628.html":
                validUri = true;
                break;

            case "/PacFORMS/XSC_EOC-213RR_v1708.html":
                validUri = true;
                break;

            case "/PacFORMS/XSC_OA_MuniStatus_v20130101.html":
                validUri = true;
                break;
                //case default:  use C# 7.1
                //    // Unauthorized page
                //    return;
            }
            if (!validUri)
            {
                return;
            }

            // open payload in SimpleMessage in FormsPage. Fill in To and send
            string payload = e.Value;

            IdentityViewModel viewModel     = IdentityViewModel.Instance;
            PacketMessage     packetMessage = new PacketMessage()
            {
                //ReceivedTime = DateTime.Parse(messageReceivedTime.Text),
                MessageFrom   = viewModel.UseTacticalCallsign ? viewModel.TacticalCallsign : viewModel.UserCallsign,
                MessageNumber = Utilities.GetMessageNumberPacket(),
                MessageBody   = payload,
                //TNCName = "E-Mail-" + Singleton<TNCSettingsViewModel>.Instance.CurrentMailAccount.MailUserName,
            };

            string folderPath = SharedData.UnsentMessagesFolder.Path;

            //CommunicationsService communicationsService = CommunicationsService.CreateInstance();
            //await communicationsService.CreatePacketMessageFromMessageAsync(packetMessage);
            await CreatePacketMessageFromMessageAsync(packetMessage, folderPath);

            string packetMessagePath = Path.Combine(folderPath, packetMessage.FileName);

            NavigationService.Navigate(typeof(CountyFormsPage), packetMessagePath);
        }
예제 #17
0
        public void Edit_Invalid()
        {
            //Arrange
            IdentityViewModel model = new IdentityViewModel()
            {
            };

            controllerWEB.ModelState.AddModelError("Error", "Что-то пошло не так");

            //Act
            var result = (ViewResult)controllerWEB.Edit(model);

            //Assert
            Assert.AreEqual("", result.ViewName);
        }
        public SendFormDataControl()
        {
            InitializeComponent();

            ScanControls(messageInfo);

            //(string bbs, string tnc, string from) = Utilities.GetProfileDataBBSStatusChecked();
            ViewModel.MessageBBS = Utilities.GetSenderBBSStatusChecked();
            ViewModel.MessageTNC = PacketSettingsViewModel.Instance.CurrentProfile.TNC;
            ViewModel.MessageTo  = PacketSettingsViewModel.Instance.CurrentProfile.SendTo;
            IdentityViewModel instance = IdentityViewModel.Instance;

            ViewModel.MessageFrom = instance.UseTacticalCallsign ? instance.TacticalCallsign : instance.UserCallsign;

            ViewModelBase = ViewModel;
        }
        public async Task <IActionResult> Index()
        {
            var user = await _context.Users.Where(x => x.UserName == User.Identity.Name).FirstOrDefaultAsync();

            if (user == null)
            {
                return(View(new IdentityViewModel()));
            }

            var model = new IdentityViewModel()
            {
                UserId = user.Id
            };

            return(View(model));
        }
예제 #20
0
        public async Task <IActionResult> Login(IdentityViewModel identityViewModel)
        {
            if (ModelState.IsValid)
            {
                var result = await _signInManager.PasswordSignInAsync(identityViewModel.login.LoginEmail, identityViewModel.login.LoginPassword, identityViewModel.login.RememberMe, false);

                if (result.Succeeded)
                {
                    return(RedirectToAction("Index", "Home", new { Area = "Client" }));
                }

                ModelState.AddModelError("invalid", "Tài khoản hoặc mật khẩu không đúng");
                identityViewModel.invalid = true;
            }
            return(View(identityViewModel));
        }
        public async Task AskForLogOnOrDecryptPassphraseActionNotActiveFile()
        {
            IdentityViewModel ivm = new IdentityViewModel(Resolve.FileSystemState, Resolve.KnownIdentities, Resolve.UserSettings, Resolve.SessionNotify);
            LogOnIdentity     id  = null;

            ivm.LoggingOnAsync = (e) =>
            {
                id           = e.Identity;
                e.Passphrase = new Passphrase("p");
                return(Task.FromResult <object>(null));
            };

            await ivm.AskForDecryptPassphrase.ExecuteAsync(@"C:\Folder\File1-txt.axx");

            Assert.That(ivm.LogOnIdentity.Passphrase.Text, Is.EqualTo("p"));
            Assert.That(id.Passphrase.Thumbprint, Is.EqualTo(Passphrase.Empty.Thumbprint));
        }
        public async Task TestLogOnLogOffWhenLoggedOffAndNoIdentitiesWithCancel()
        {
            IdentityViewModel ivm = new IdentityViewModel(Resolve.FileSystemState, Resolve.KnownIdentities, Resolve.UserSettings, Resolve.SessionNotify);

            ivm.LoggingOnAsync = (e) =>
            {
                e.Cancel = true;
                return(Task.FromResult <object>(null));
            };

            ivm.LogOnIdentity = new LogOnIdentity("testing");
            await ivm.LogOnLogOff.ExecuteAsync(null);

            Assert.That(Resolve.KnownIdentities.IsLoggedOn, Is.False, "Not logged on.");
            Assert.That(Resolve.FileSystemState.KnownPassphrases.Count(), Is.EqualTo(0));
            Assert.That(ivm.LogOnIdentity == LogOnIdentity.Empty);
        }
예제 #23
0
        public IActionResult GetToken([FromBody] IdentityViewModel model)
        {
            var user = _repository.GetUser(model.UserName, model.Password);

            if (user == null)
            {
                return(Unauthorized());
            }

            // Todo: разнести код
            ClaimsIdentity identity = null;
            var            claims   = new List <Claim>
            {
                new Claim(ClaimsIdentity.DefaultNameClaimType, user.Name),
                new Claim(ClaimsIdentity.DefaultRoleClaimType, EnumHelper.RoleToString(user.Role))
            };

            identity = new ClaimsIdentity(
                claims,
                "Token",
                ClaimsIdentity.DefaultNameClaimType,
                ClaimsIdentity.DefaultRoleClaimType);


            var dateTime = DateTime.Now;
            var token    = new JwtSecurityToken(
                issuer: AuthOptions.Issuer,
                audience: AuthOptions.Audience,
                notBefore: dateTime,
                claims: identity.Claims,
                expires: dateTime.Add(TimeSpan.FromMinutes(AuthOptions.Lifetime)),
                signingCredentials: new SigningCredentials(
                    AuthOptions.GetSymmetricSecurityKey(),
                    SecurityAlgorithms.HmacSha256));

            var encodedToken = new JwtSecurityTokenHandler().WriteToken(token);

            var result = new
            {
                token    = encodedToken,
                username = identity.Name
            };

            return(Ok(result));
        }
예제 #24
0
        public async Task ShouldSaveIdentity()
        {
            var expectedIdentity = new IdentityViewModel
            {
                Id             = Guid.NewGuid(),
                Name           = "New identity",
                Token          = "Secret",
                ExpirationDate = DateTime.UtcNow
            };

            SetupCreateOrUpdate <Identity, IdentityViewModel>(expectedIdentity);

            await _handler.Handle(new SaveIdentity
            {
                Identity = expectedIdentity
            });

            RepositoryMock.VerifyAll();
        }
        public async Task AskForLogOnPassphraseActionWithCancel()
        {
            LogOnIdentity key = new LogOnIdentity("ppp");

            LogOnIdentity id = key;

            IdentityViewModel ivm = new IdentityViewModel(Resolve.FileSystemState, Resolve.KnownIdentities, Resolve.UserSettings, Resolve.SessionNotify);

            ivm.LoggingOnAsync = (e) =>
            {
                e.Cancel = true;
                return(Task.FromResult <object>(null));
            };

            await ivm.AskForLogOnPassphrase.ExecuteAsync(id);

            Assert.That(ivm.LogOnIdentity == LogOnIdentity.Empty);
            Assert.That(Resolve.KnownIdentities.DefaultEncryptionIdentity == LogOnIdentity.Empty);
        }
        public async Task AskForLogOnPassphraseAction()
        {
            LogOnIdentity key = new LogOnIdentity("ppp");

            LogOnIdentity id = key;

            IdentityViewModel ivm = new IdentityViewModel(Resolve.FileSystemState, Resolve.KnownIdentities, Resolve.UserSettings, Resolve.SessionNotify);

            ivm.LoggingOnAsync = (e) =>
            {
                e.Passphrase = new Passphrase("ppp");
                e.IsAskingForPreviouslyUnknownPassphrase = true;
                return(Task.FromResult <object>(null));
            };

            await ivm.AskForLogOnPassphrase.ExecuteAsync(id);

            Assert.That(ivm.LogOnIdentity.Passphrase.Text, Is.EqualTo("ppp"));
            Assert.That(Resolve.KnownIdentities.DefaultEncryptionIdentity.Passphrase.Thumbprint, Is.EqualTo(id.Passphrase.Thumbprint));
        }
        public async Task AskForLogOnPassphraseWithKnownIdentityButWrongPassphraseEntered()
        {
            Passphrase passphrase = new Passphrase("aaa");
            Passphrase id         = passphrase;

            Resolve.FileSystemState.KnownPassphrases.Add(id);

            IdentityViewModel ivm = new IdentityViewModel(Resolve.FileSystemState, Resolve.KnownIdentities, Resolve.UserSettings, Resolve.SessionNotify);

            ivm.LoggingOnAsync = (e) =>
            {
                e.Passphrase = new Passphrase("bbb");
                return(Task.FromResult <object>(null));
            };

            await ivm.AskForLogOnPassphrase.ExecuteAsync(null);

            Assert.That(ivm.LogOnIdentity == LogOnIdentity.Empty);
            Assert.That(Resolve.FileSystemState.KnownPassphrases.Count(), Is.EqualTo(1));
        }
예제 #28
0
        public async Task <ServiceResult> RateDrink(IdentityViewModel viewModel, RateType rateType)
        {
            var result = await drinkService.GetSingle(viewModel);

            if (result.IsValid)
            {
                if (rateType == RateType.Like)
                {
                    result.Data.Like++;
                }
                if (rateType == RateType.Unlike)
                {
                    result.Data.Unlike++;
                }

                return(await drinkService.Update(result.Data));
            }

            return(result);
        }
        public async Task TestLogOnExistingIdentity()
        {
            Passphrase passphrase = new Passphrase("p");

            Passphrase id = passphrase;

            Resolve.FileSystemState.KnownPassphrases.Add(id);

            IdentityViewModel ivm = new IdentityViewModel(Resolve.FileSystemState, Resolve.KnownIdentities, Resolve.UserSettings, Resolve.SessionNotify);

            ivm.LoggingOnAsync = (e) =>
            {
                e.Passphrase = new Passphrase("p");
                return(Task.FromResult <object>(null));
            };

            await ivm.LogOnLogOff.ExecuteAsync(null);

            Assert.That(Resolve.KnownIdentities.IsLoggedOn);
        }
        public async Task AskForNewLogOnPassphraseAutomaticallyBecauseNoIdentitiesExists()
        {
            Resolve.FileSystemState.KnownPassphrases.Add(Passphrase.Create("aaa"));
            IdentityViewModel ivm = new IdentityViewModel(Resolve.FileSystemState, Resolve.KnownIdentities, Resolve.UserSettings, Resolve.SessionNotify);

            ivm.LoggingOnAsync = (e) =>
            {
                e.Passphrase = new Passphrase("aaa");
                e.Name       = "New User Passphrase";
                return(Task.FromResult <object>(null));
            };

            await ivm.AskForLogOnPassphrase.ExecuteAsync(LogOnIdentity.Empty);

            Assert.That(ivm.LogOnIdentity.Passphrase.Text, Is.EqualTo("aaa"));
            Assert.That(Resolve.KnownIdentities.DefaultEncryptionIdentity.Passphrase.Thumbprint, Is.EqualTo(new Passphrase("aaa").Thumbprint));

            Passphrase id = Resolve.FileSystemState.KnownPassphrases.FirstOrDefault(i => i.Thumbprint == new Passphrase("aaa").Thumbprint);

            Assert.That(id.Thumbprint, Is.EqualTo(Resolve.KnownIdentities.DefaultEncryptionIdentity.Passphrase.Thumbprint));
        }