示例#1
0
    def handle_captcha(self):
        solvemedia  = SolveMedia(self.pyfile)
        captcha_key = solvemedia.detect_key()

        if captcha_key:
            self.captcha = solvemedia
            response, challenge = solvemedia.challenge(captcha_key)
            self.data = self.load("http://www.mediafire.com/?" + self.info['pattern']['ID'],
                                  post={'adcopy_challenge': challenge,
                                        'adcopy_response' : response})
            return

        recaptcha   = ReCaptcha(self.pyfile)
        captcha_key = recaptcha.detect_key()

        if captcha_key:
            url, inputs = self.parse_html_form('name="form_captcha"')
            self.log_debug(("form_captcha url:%s inputs:%s") % (url, inputs))

            if url:
                self.captcha = recaptcha
                response, challenge = recaptcha.challenge(captcha_key)

                inputs['g-recaptcha-response'] = response
                self.data = self.load(self.fixurl(url), post=inputs)

            else:
                self.fail("ReCaptcha form not found")
示例#2
0
    def handle_captcha(self, inputs):
        m = re.search(self.CAPTCHA_PATTERN, self.data)
        if m is not None:
            captcha_url = m.group(1)
            inputs['code'] = self.captcha.decrypt(captcha_url)
            return

        m = re.search(self.CAPTCHA_BLOCK_PATTERN, self.data, re.S)
        if m is not None:
            captcha_div = m.group(1)
            numerals    = re.findall(r'<span.*?padding-left\s*:\s*(\d+).*?>(\d)</span>', html_unescape(captcha_div))

            self.log_debug(captcha_div)

            inputs['code'] = "".join(a[1] for a in sorted(numerals, key=operator.itemgetter(0)))

            self.log_debug("Captcha code: %s" % inputs['code'], numerals)
            return

        recaptcha = ReCaptcha(self.pyfile)
        try:
            captcha_key = re.search(self.RECAPTCHA_PATTERN, self.data).group(1)

        except Exception:
            captcha_key = recaptcha.detect_key()

        else:
            self.log_debug("ReCaptcha key: %s" % captcha_key)

        if captcha_key:
            self.captcha = recaptcha
            inputs['recaptcha_response_field'], inputs['recaptcha_challenge_field'] = recaptcha.challenge(captcha_key)
            return

        solvemedia = SolveMedia(self.pyfile)
        try:
            captcha_key = re.search(self.SOLVEMEDIA_PATTERN, self.data).group(1)

        except Exception:
            captcha_key = solvemedia.detect_key()

        else:
            self.log_debug("SolveMedia key: %s" % captcha_key)

        if captcha_key:
            self.captcha = solvemedia
            inputs['adcopy_response'], inputs['adcopy_challenge'] = solvemedia.challenge(captcha_key)
示例#3
0
    def handle_captcha(self):
        solvemedia  = SolveMedia(self)
        captcha_key = solvemedia.detect_key()

        if captcha_key:
            response, challenge = solvemedia.challenge(captcha_key)
            self.html = self.load("http://www.mediafire.com/?" + self.info['pattern']['ID'],
                                  post={'adcopy_challenge': challenge,
                                        'adcopy_response' : response})
            return

        recaptcha   = ReCaptcha(self)
        captcha_key = recaptcha.detect_key()

        if captcha_key:
            response, challenge = recaptcha.challenge(captcha_key)
            self.html = self.load(self.pyfile.url,
                                  post={'g-recaptcha-response': response})
示例#4
0
    def handle_free(self, pyfile):
        #: Search for Download URL
        m = re.search(self.LINK_FREE_PATTERN, self.data)
        if m is None:
            self.error(_("LINK_FREE_PATTERN not found"))

        self.link = m.group(1)

        #: Set Timer - may be obsolete
        m = re.search(self.WAIT_PATTERN, self.data)
        if m is not None:
            self.wait(m.group(1))

        #: Load.to is using solvemedia captchas since ~july 2014:
        solvemedia  = SolveMedia(self)
        captcha_key = solvemedia.detect_key()

        if captcha_key:
            response, challenge = solvemedia.challenge(captcha_key)
            self.download(self.link,
                          post={'adcopy_challenge': challenge,
                                'adcopy_response' : response,
                                'returnUrl'       : pyfile.url})
示例#5
0
    def unlock_captcha_protection(self):
        m = re.search(self.CIRCLE_CAPTCHA_PATTERN, self.data)
        if m:
            self.log_debug("Request circle captcha resolving")
            captcha_id = m.group(1)

            coords = self.captcha.decrypt(self.CIRCLE_CAPTCHA_IMG_URL, get={'id': captcha_id}, input_type="png", output_type='positional')  # , ocr="CircleCaptcha")
            self.log_debug("Captcha resolved, coords (%s,%s)" % (coords[0], coords[1]))

            post_data = {'button.x'    : coords[0],
                         'button.y'    : coords[1],
                         'captcha_id'  : captcha_id,
                         'captcha_type': "RelinkCircle",
                         'captcha'     : "submit"}

        else:
            solvemedia = SolveMedia(self.pyfile)
            captcha_key = solvemedia.detect_key()
            if captcha_key:
                self.log_debug(_("Request SolveMedia captcha resolving"))
                response, challenge = solvemedia.challenge()

                post_data = {'adcopy_response' : response,
                             'adcopy_challenge': challenge,
                             'captcha_type'    : "Solvemedia",
                             'submit'          : "Continue",
                             'captcha'         : "submit"}

            else:
                self.log_error(_("Unknown captcha type detected"))
                self.fail(_("Unknown captcha type"))

        self.data = self.load(self.CAPTCHA_SUBMIT_URL,
                              ref=False,# ref=self.CAPTCHA_SUBMIT_URL + "&id=" + self.file_id,
                              get={'id': self.file_id},
                              post=post_data)
    def handle_captcha(self):
        if re.search(self.CAPTCHA_PATTERN, self.data):
            m1  = re.search(self.INTERNAL_CAPTCHA_PATTERN, self.data)
            m2 = re.search(self.CIRCLE_CAPTCHA_PATTERN, self.data)
            m3 = re.search(self.SOLVE_MEDIA_PATTERN, self.data)
            m4 = re.search(self.KEY_CAPTCHA_PATTERN, self.data)

            if m1:  #: Normal captcha
                self.log_debug("Internal Captcha URL: %s" % urlparse.urljoin(self.pyfile.url, m1.group(1)))

                captcha_code = self.captcha.decrypt(urlparse.urljoin(self.pyfile.url, m1.group(1)),
                                                    ref=True, input_type="gif")

                self.site_with_links = self.load(self.pyfile.url,
                                                 post={'recaptcha_response_field': captcha_code})

            elif m2:  #: Circle captcha
                self.log_debug("Circle Captcha URL: %s" % urlparse.urljoin(self.pyfile.url, m2.group(1)))

                captcha_code = self.captcha.decrypt(urlparse.urljoin(self.pyfile.url, m2.group(1)),
                                                    input_type="png", output_type='positional')

                self.site_with_links = self.load(self.pyfile.url,
                                                 post={'button.x': captcha_code[0],
                                                       'button.y': captcha_code[1]})

            elif m3:  #: Solvemedia captcha
                self.log_debug("Solvemedia Captcha URL: %s" % urlparse.urljoin(self.pyfile.url, m3.group(1)))

                solvemedia  = SolveMedia(self)
                captcha_key = solvemedia.detect_key()

                if captcha_key:
                    response, challenge = solvemedia.challenge(captcha_key)
                    self.site_with_links  = self.load(self.pyfile.url,
                                                      post={'adcopy_response'  : response,
                                                            'adcopy_challenge' : challenge})

            elif m4:  #: Keycaptcha captcha
                self.log_debug("Keycaptcha Captcha URL: %s unsupported, retrying" % m4.group(1))
                self.retry()

            else:
                recaptcha   = ReCaptcha(self)
                captcha_key = recaptcha.detect_key()

                if captcha_key:
                    try:
                        response, challenge = recaptcha.challenge(captcha_key)

                    except Exception:
                        self.retry_captcha()

                    self.site_with_links  = self.load(self.pyfile.url,
                                                      post={'g-recaptcha-response': response})
                else:
                    self.log_info(_("Unknown captcha found, retrying"))
                    self.retry()

            if re.search(self.CAPTCHA_PATTERN, self.site_with_links):
                self.retry_captcha()

        else:
            self.log_info(_("No captcha found"))
            self.site_with_links = self.data