public void ChangePassword()
        {
            if (!CanChangePassword)
            {
                return;
            }

            var password84 = _passwordBase as TLPassword84;

            if (password84 == null)
            {
                return;
            }

            var newAlgo = password84.NewAlgo as TLPasswordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow;

            if (newAlgo == null)
            {
                return;
            }

            Utils.Password.AddClientSalt(newAlgo);

            //var newPasswordHash = SRP.GetX(new TLString(_password), newAlgo);
            //var newPasswordInputHash = SRP.GetVBytes(new TLString(_password), newAlgo);
            //Utils.Password.GetHash(newSalt, new TLString(_password));

            var inputSettings = new TLPasswordInputSettings83
            {
                Flags           = new TLInt(0),
                NewAlgo         = newAlgo,
                NewPasswordHash = null,
                Hint            = TLString.Empty,
                NewPassword     = _password
            };

            // reencrypt secure_secret
            var passwordSecret = _passwordBase as IPasswordSecret;

            if (passwordSecret != null)
            {
                TLPasswordSettings83 passwordSettings = null;
                var password = _passwordBase as TLPassword81;
                if (password != null)
                {
                    passwordSettings = password.Settings as TLPasswordSettings83;
                }
                if (passwordSettings == null || passwordSettings.SecureSettings == null)
                {
                    Utils.Password.AddRandomSecureSecret(inputSettings, passwordSecret, new TLString(_password));
                }
                else
                {
                    var secret = Utils.Passport.DecryptSecureSecret(passwordSettings.SecureSettings.SecureSecret, new TLString(PasswordViewModel.Password), passwordSettings.SecureSettings.SecureAlgo);
                    Utils.Password.AddSecureSecret(secret, inputSettings, passwordSecret, new TLString(_password));
                }
            }

            PasswordViewModel.TempNewPassword = Password;

            StateService.Password            = _passwordBase;
            StateService.NewPasswordSettings = inputSettings;
            StateService.RemoveBackEntry     = true;
            StateService.AuthorizationForm   = _authorizationForm;
            StateService.SecureValues        = _secureValues;
            NavigationService.UriFor <ChangePasswordHintViewModel>().Navigate();

            return;
        }
        protected static bool SetSecretAndDecryptSecureValues(TLPasswordSettings83 passwordSettings, TLString password, IList <TLSecureValue> values)
        {
            if (passwordSettings == null)
            {
                return(false);
            }

            var secureSettings = passwordSettings.SecureSettings;

            if (secureSettings == null)
            {
                return(false);
            }

            var secureAlgo = secureSettings.SecureAlgo;

            if (secureAlgo == null)
            {
                return(false);
            }

            Secret = Utils.Passport.DecryptSecureSecret(
                secureSettings.SecureSecret,
                password,
                secureAlgo);

            // cannot decrypt secureSecret, corrupt data
            if (Secret == null)
            {
                return(false);
            }

            if (values == null)
            {
                return(true);
            }

            foreach (var value in values)
            {
                try
                {
                    if (value.Data != null)
                    {
                        var decryptedData = Utils.Passport.DecryptSecureValue(value, Secret);

                        if (!TLString.IsNullOrEmpty(decryptedData))
                        {
                            if (ResidentialAddressViewModel.IsValidDataType(value.Type))
                            {
                                value.Data.DecryptedData = JsonUtils.FromJSON <ResidentialAddressRootObject>(decryptedData.Data);
                            }
                            else if (PersonalDetailsViewModel.IsValidProofType(value.Type))
                            {
                                value.Data.DecryptedData = JsonUtils.FromJSON <PersonalDetailsDocumentRootObject>(decryptedData.Data);
                            }
                            else if (PersonalDetailsViewModel.IsValidDataType(value.Type))
                            {
                                value.Data.DecryptedData = JsonUtils.FromJSON <PersonalDetailsRootObject>(decryptedData.Data);
                            }
                            else
                            {
                                value.Data.DecryptedData = decryptedData;
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    Telegram.Api.Helpers.Execute.ShowDebugMessage(ex.ToString());
                }
            }

            return(true);
        }