public string GetCaptchaAnswer(byte[] captchaImage)
 {
     using var dialog = new CaptchaDialog(captchaImage);
     if (ShowDialog(dialog))
     {
         return(dialog.Answer);
     }
     return(null);
 }
Example #2
0
 public string GetCaptchaAnswer(byte[] captchaImage)
 {
     using var dialog = new CaptchaDialog(captchaImage);
     if (dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK)
     {
         return(dialog.Answer);
     }
     return(null);
 }
Example #3
0
        private string ShowCaptchaDialog(HttpHandler httpHandler)
        {
            var captchaDialog = new CaptchaDialog(httpHandler, _proxy, _useProxy);
            var captcha       = string.Empty;

            if (captchaDialog.ShowDialog() == DialogResult.OK)
            {
                captcha = captchaDialog.Text;
                //MessageBox.Show(captcha);
            }
            captchaDialog.Dispose();
            return(captcha);
        }
Example #4
0
        public IWebElement OverrideNavigation(IWebDriver driver, string url)
        {
            IWebElement result = null;

            driver.Navigate().GoToUrl(url);

            while (driver.Url.Contains("showcaptcha"))
            {
                IWebElement   captcha       = driver.FindElement(By.XPath("//div[@class='captcha__image']"));
                string        captchaSrc    = captcha.FindElement(By.XPath("//img")).GetAttribute("src");
                CaptchaDialog captchaDialog = null;
                Application.Current.Dispatcher.Invoke((Action) delegate {
                    captchaDialog = new CaptchaDialog(captchaSrc);
                    captchaDialog.ShowDialog();
                });


                if (captchaDialog.CaptchaInput == null)
                {
                    throw new Exception("Captcha was not solved.");
                }

                IWebElement inputBox = driver.FindElement(By.XPath("//input[@class='input-wrapper__content']"));
                inputBox.SendKeys(captchaDialog.CaptchaInput);
                inputBox.Submit();
                Thread.Sleep(500);
            }

            //Wait for result to be available
            WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(1));

            result = wait.Until(ResultIsNotEmpty);


            return(result);
        }
        private bool CheckData()
        {
            var errors = new StringBuilder();

            // проверить заполнение полей
            if (string.IsNullOrEmpty(tbEmail.Text))
            {
                errors.AppendLine(Localizer.GetString("MessageEmailErrorEmpty"));
            }
            else
            {
                try
                {
                    new MailAddress(tbEmail.Text);
                }
                catch (FormatException)
                {
                    errors.AppendLine(Localizer.GetString("MessageEmailErrorWrongFormat"));
                }
            }
            var login = tbLogin.Text;

            if (login.Length < PlatformUser.LoginLenMin)
            {
                errors.AppendLine(string.Format(Localizer.GetString("MessageUserNameErrorShortFmt"), PlatformUser.LoginLenMin));
            }
            else
            if (login.Length > PlatformUser.LoginLenMax)
            {
                errors.AppendLine(string.Format(Localizer.GetString("MessageUserNameErrorLongFmt"),
                                                PlatformUser.LoginLenMax));
            }

            if (!PlatformUser.CheckLoginSpelling(login))
            {
                errors.AppendLine(Localizer.GetString("MessageUserNameErrorBadSymbols"));
            }

            if (mode == UserControlMode.New)
            {
                // проверить размер депо
                var depoSz = cbDepoSize.Text.Replace(" ", "").ToIntSafe();
                if (!depoSz.HasValue)
                {
                    errors.AppendLine(Localizer.GetString("MessageDepoVolumeMustBeInt"));
                }

                var depoVolume = depoSz ?? 1000;
                if (depoVolume < 1000)
                {
                    errors.AppendLine(Localizer.GetString("MessageDepoVolumeMustBe1000"));
                }
                else if (depoVolume > 5000000)
                {
                    errors.AppendLine(Localizer.GetString("MessageDepoVolumeMustBe5000"));
                }
            }

            if (mode == UserControlMode.Edit || EnablePasswordOnRegistration)
            {
                // проверить пароль
                if (tbPassword.Text.Length < 8)
                {
                    errors.AppendLine(
                        string.Format(Localizer.GetString("MessagePasswordTooShortFmt"), 8));
                }
                else if (tbPassword.Text.Length > 25)
                {
                    errors.AppendLine(string.Format(Localizer.GetString("MessagePasswordTooLongFmt"), 25));
                }
            }

            if (errors.Length > 0)
            {
                MessageBox.Show(errors.ToString(),
                                Localizer.GetString("TitleError"),
                                MessageBoxButtons.OK, MessageBoxIcon.Error);
                return(false);
            }

            // проверить капчу
            var dlg = new CaptchaDialog(Localizer.GetString("MessageEnterConfirmationCode"),
                                        true, false, 4);

            if (dlg.ShowDialog() != DialogResult.OK)
            {
                return(false);
            }
            return(true);
        }
Example #6
0
        public Captcha.CaptchaSolution SolveCaptcha(Action <string> updateStatus, Models.CaptchaSolvingConfig captchaConfig)
        {
            Logger.Debug("Getting captcha...");
            updateStatus?.Invoke("Getting captcha...");

            //Store captcha ID
            SetConfig(JoinUri, Method.GET);
            var response = _client.Execute(_request);

            try
            {
                _captchaGid = CaptchaRegex.Matches(response.Content)[0].Groups[1].Value;
            }
            catch (Exception e)
            {
                Logger.Error("Captcha error.", e);
                updateStatus($"Captcha error: {e.Message}");
                return(new Captcha.CaptchaSolution(true, $"{e}\n\n{response.ResponseStatus}", captchaConfig));
            }

            //download and return captcha image
            SetConfig($"{CaptchaUri}{_captchaGid}", Method.GET);
            var captchaPayload = string.Empty;

            for (int i = 0; i < 3; i++)
            {
                try
                {
                    Logger.Debug($"Downloading captcha: Try {i + 1}/3");
                    updateStatus($"Downloading captcha: Try {i + 1}/3");

                    var _captchaResp = _client.DownloadData(_request);
                    captchaPayload = GetBase64FromImage(_captchaResp);

                    break;
                }
                catch (Exception ex)
                {
                    Logger.Error("Downloading captcha error.", ex);
                    captchaPayload = string.Empty;
                }
            }

            // recognize captcha
            Logger.Debug("Recognizing captcha...");
            updateStatus("Recognizing captcha...");
            switch (captchaConfig.Service)
            {
            case Enums.CaptchaService.Captchasolutions:
            {
                Logger.Debug("Recognizing captcha via Captchasolutions...");
                var _resp = Captchasolutions("solve",
                                             new Dictionary <string, object>()
                    {
                        { "p", "base64" },
                        { "captcha", $"data:image/jpg;base64,{captchaPayload}" },
                        { "key", captchaConfig.CaptchaSolutions.ApiKey },
                        { "secret", captchaConfig.CaptchaSolutions.ApiSecret },
                        { "out", "txt" },
                    });

                if (Regex.IsMatch(_resp, @"Error:\s(.+)", RegexOptions.IgnoreCase))
                {
                    Logger.Warn($"Captchasolutions error:\n{_resp}\n====== END ======");
                    return(new Captcha.CaptchaSolution(true, _resp, captchaConfig));
                }

                var solution = Regex.Replace(_resp, @"\t|\n|\r", "");
                Logger.Debug($"Captchasolutions: {solution}");
                return(new Captcha.CaptchaSolution(solution, null, captchaConfig));
            }

            case Enums.CaptchaService.RuCaptcha:
            {
                Logger.Debug("Recognizing captcha via TwoCaptcha/RuCaptcha");
                var _captchaIdResponse = TwoCaptcha("in.php",
                                                    new Dictionary <string, object>()
                    {
                        { "key", captchaConfig.RuCaptcha.ApiKey },
                        { "body", $"data:image/jpg;base64,{captchaPayload}" },
                        { "method", "base64" },
                        { "soft_id", "2370" },
                        { "json", "0" },
                    });

                var _captchaStatus = _captchaIdResponse?.FirstOrDefault()?.ToUpper() ?? "UNKNOWN";
                Logger.Debug($"TwoCaptcha/RuCaptcha image upload response: {_captchaStatus}");
                switch (_captchaStatus)
                {
                case "OK":
                    break;

                case "ERROR_NO_SLOT_AVAILABLE":
                    Thread.Sleep(6000);
                    return(new Captcha.CaptchaSolution(true, _captchaStatus, captchaConfig));

                default:
                    return(new Captcha.CaptchaSolution(false, _captchaStatus, captchaConfig));
                }

                var _captchaId = _captchaIdResponse.ElementAt(1);
                Logger.Debug($"TwoCaptcha/RuCaptcha ID: {_captchaId}");

                Thread.Sleep(TimeSpan.FromSeconds(20));

                var solution = string.Empty;
                for (int i = 0; i < 3; i++)
                {
                    Logger.Debug($"TwoCaptcha/RuCaptcha requesting solution... Try {i} of 3");
                    var _captchaResponse = TwoCaptcha("res.php",
                                                      new Dictionary <string, object>()
                        {
                            { "key", captchaConfig.RuCaptcha.ApiKey },
                            { "action", "get" },
                            { "id", _captchaId },
                            { "json", "0" },
                        });

                    var _status = _captchaResponse?.FirstOrDefault()?.ToUpper() ?? "UNKNOWN";
                    Logger.Debug($"TwoCaptcha/RuCaptcha solving status: {_status}");
                    switch (_status)
                    {
                    case "OK":
                    {
                        var _solution = new Captcha.CaptchaSolution(_captchaResponse.ElementAt(1), _captchaId, captchaConfig);
                        Logger.Debug($"TwoCaptcha/RuCaptcha solution: {_solution.Solution}");
                        return(_solution);
                    }

                    case "CAPCHA_NOT_READY":
                    case "ERROR_NO_SLOT_AVAILABLE":
                        Thread.Sleep(6000);
                        continue;

                    default:
                        return(new Captcha.CaptchaSolution(true, _status, captchaConfig));
                    }
                }
            }
                Logger.Debug("TwoCaptcha/RuCaptcha somethig went wrong.");
                return(new Captcha.CaptchaSolution(true, "Something went wrong", captchaConfig));

            default:
            {
                using (var dialog = new CaptchaDialog(this, updateStatus, captchaConfig))
                {
                    if (dialog.ShowDialog() == DialogResult.OK)
                    {
                        return(dialog.Solution);
                    }
                }
            }
                return(new Captcha.CaptchaSolution(false, "Can't solve captcha!", captchaConfig));
            }
        }
Example #7
0
        private void _ParseResponse(string response)
        {
            try
            {
                if (response == null)
                {
                    _successHandler(null);
                }
                else if (response.Contains("\"error\":"))
                {
                    Debug.WriteLine("Error in response...");

                    // Error
                    var errorResponse = SerializeHelper.Deserialise <APIError>(response);

                    App.Current.APIErrorHandler.SaveError(errorResponse);

                    // Special case for captcha
                    if (errorResponse != null &&
                        !string.IsNullOrEmpty(errorResponse.ErrorDescription.captcha_img) &&
                        !string.IsNullOrEmpty(errorResponse.ErrorDescription.captcha_sid) &&
// TODO This is shit. But time..time... Need to re-design to handle possible cross-process operations:
// for ex. use collection of happened errors and generate GUIDs for every called method to divide its errors and get them.
// For now it should be used ONLY for showing messages and handling Captcha's.
                        !App.Current.APIErrorHandler.IsHandled)
                    {
                        Deployment.Current.Dispatcher.BeginInvoke(() =>
                        {
// TODO UI
                            try
                            {
                                Debug.WriteLine("Poping up captcha...");

                                Popup popup            = new Popup();
                                popup.Height           = 480;
                                popup.Width            = 480;
                                popup.VerticalOffset   = 100;
                                popup.HorizontalOffset = 100;
                                CaptchaDialog control  = new CaptchaDialog();
                                popup.Child            = control;
                                popup.IsOpen           = true;

                                control.OkButton.Click += (s, args) =>
                                {
                                    popup.IsOpen = false;
                                    string code  = control.CaptchaTextBox.Text;

                                    AddParameter("captcha_sid", App.Current.APIErrorHandler.LastCaptchaSid);
                                    AddParameter("captcha_key", code);

                                    Execute();
                                };
                            }
                            catch (Exception ex)
                            {
                                Debug.WriteLine("_UpdatePhoto failed on GlobalSearchPage: " + ex.Message);
                            }
                        });
                    }
                    else
                    {
                        _successHandler(null);
                    }
                }
                else
                {
                    Debug.Assert(!response.Contains("\"error\":"));
                    Debug.Assert(response.Contains("\"response\":"));

                    // Ok
                    _successHandler(response);
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine("Parse response from APIRequest failed." + ex.Message);
                _successHandler(null);
            }
        }
Example #8
0
        private async void SignIn(String login, String password, long?captchaSid = null, string captchaKey = null)
        {
            var app = App.Current as App;

            try
            {
                await app.SignInAsync(LoginTextBox.Text, PasswordBox.Password, captchaSid, captchaKey);
            }
            catch (VkApiAuthorizationException exception)
            {
                await Dispatcher.RunAsync(
                    Windows.UI.Core.CoreDispatcherPriority.Normal,
                    () => { Authenticating = false; }
                    );

                // TODO: Вывести куда-нибудь сообщения
                var alert = new ContentDialog()
                {
                    Title             = "Не удается войти",
                    Content           = "Проверьте правильность логина и пароля",
                    PrimaryButtonText = "OK"
                };
                Debug.WriteLine(exception.Message);
                await alert.ShowAsync();

                return;
            }
            catch (CaptchaNeededException exception)
            {
                await Dispatcher.RunAsync(
                    Windows.UI.Core.CoreDispatcherPriority.Normal,
                    () => { Authenticating = false; }
                    );

                // TODO: Заменить диалог на что-нибудь более приятное
                CaptchaImage.Source = new BitmapImage(exception.Img);
                var result = await CaptchaDialog.ShowAsync();

                if (result == ContentDialogResult.Primary)
                {
                    SignIn(
                        LoginTextBox.Text,
                        PasswordBox.Password,
                        exception.Sid,
                        CaptchaTextBox.Text);
                }
                return;
            }
            catch (VkApiException exception)
            {
                await Dispatcher.RunAsync(
                    Windows.UI.Core.CoreDispatcherPriority.Normal,
                    () => { Authenticating = false; }
                    );

                // TODO: Вывести куда-нибудь сообщения
                var alert = new ContentDialog()
                {
                    Title             = "Ошибка",
                    Content           = exception.Message,
                    PrimaryButtonText = "OK"
                };
                Debug.WriteLine(exception.Message);
                await alert.ShowAsync();

                return;
            }
            catch (Exception exception)
            {
                await Dispatcher.RunAsync(
                    Windows.UI.Core.CoreDispatcherPriority.Normal,
                    () => { Authenticating = false; }
                    );

                // TODO: Вывести куда-нибудь сообщения
                var alert = new ContentDialog()
                {
                    Title             = "Ошибка",
                    Content           = exception.Message,
                    PrimaryButtonText = "OK"
                };
                Debug.WriteLine(exception.Message);
                await alert.ShowAsync();

                return;
            }
            await Dispatcher.RunAsync(
                Windows.UI.Core.CoreDispatcherPriority.Normal,
                () => { Authenticating = false; }
                );

            // TODO: Добавить плавности
            Frame.Navigate(typeof(MainPage), null, new DrillInNavigationTransitionInfo());
        }