Beispiel #1
0
    def handleFree(self, pyfile):
        # Click the "free user" button and wait
        a = self.load(pyfile.url, post={'downloadLink': "wait"}, decode=True)
        self.logDebug(a)

        self.wait(30)

        # Make the recaptcha appear and show it the pyload interface
        b = self.load(pyfile.url, post={'checkDownload': "check"}, decode=True)
        self.logDebug(b)  #: Expected output: {"success":"showCaptcha"}

        recaptcha = ReCaptcha(self)

        response, challenge = recaptcha.challenge(self.RECAPTCHA_KEY)

        # Submit the captcha solution
        self.load("http://www.uploadable.ch/checkReCaptcha.php",
                  post={
                      'recaptcha_challenge_field': challenge,
                      'recaptcha_response_field': response,
                      'recaptcha_shortencode_field': self.info['pattern']['ID']
                  },
                  decode=True)

        self.wait(3)

        # Get ready for downloading
        self.load(pyfile.url, post={'downloadLink': "show"}, decode=True)

        self.wait(3)

        # Download the file
        self.download(pyfile.url,
                      post={'download': "normal"},
                      disposition=True)
Beispiel #2
0
    def handleCaptcha(self):
        post_data = {'free'               : 1,
                     'freeDownloadRequest': 1,
                     'uniqueId'           : self.fid,
                     'yt0'                : ''}

        m = re.search(r'id="(captcha\-form)"', self.html)
        self.logDebug("captcha-form found %s" % m)

        m = re.search(self.CAPTCHA_PATTERN, self.html)
        self.logDebug("CAPTCHA_PATTERN found %s" % m)
        if m:
            captcha_url = urlparse.urljoin("http://keep2s.cc/", m.group(1))
            post_data['CaptchaForm[code]'] = self.decryptCaptcha(captcha_url)
        else:
            recaptcha = ReCaptcha(self)
            response, challenge = recaptcha.challenge()
            post_data.update({'recaptcha_challenge_field': challenge,
                              'recaptcha_response_field' : response})

        self.html = self.load(self.pyfile.url, post=post_data)

        if 'verification code is incorrect' not in self.html:
            self.correctCaptcha()
        else:
            self.invalidCaptcha()
Beispiel #3
0
    def get_download_options(self):
        re_envelope = re.search(
            r".*?value=\"Free\sDownload\".*?\n*?(.*?<.*?>\n*)*?\n*\s*?</form>",
            self.html).group(0)  # get the whole request
        to_sort = re.findall(
            r"<input\stype=\"hidden\"\svalue=\"(.*?)\"\sname=\"(.*?)\"\s\/>",
            re_envelope)
        request_options = dict((n, v) for (v, n) in to_sort)

        herewego = self.load(self.pyfile.url, None,
                             request_options)  # the actual download-Page

        to_sort = re.findall(
            r"<input\stype=\".*?\"\svalue=\"(\S*?)\".*?name=\"(\S*?)\"\s.*?\/>",
            herewego)
        request_options = dict((n, v) for (v, n) in to_sort)

        challenge = re.search(r"http://api\.recaptcha\.net/challenge\?k=(\w+)",
                              herewego)

        if challenge:
            re_captcha = ReCaptcha(self)
            (request_options['recaptcha_challenge_field'],
             request_options['recaptcha_response_field']
             ) = re_captcha.challenge(challenge.group(1))

        return request_options
    def handleFree(self, pyfile):
        self.html = self.load(pyfile.url, post={'gateway_result': "1"})

        self.checkErrors()

        m = re.search(r"var fid = '(\w+)';", self.html)
        if m is None:
            self.retry(wait_time=5)
        params = {'fid': m.group(1)}
        self.logDebug("FID: %s" % params['fid'])

        self.checkErrors()

        recaptcha = ReCaptcha(self)
        captcha_key = recaptcha.detect_key()
        if captcha_key is None:
            return

        self.html = self.load("https://dfiles.eu/get_file.php", get=params)

        if '<input type=button value="Continue" onclick="check_recaptcha' in self.html:
            params['response'], params['challenge'] = recaptcha.challenge(captcha_key)
            self.html = self.load("https://dfiles.eu/get_file.php", get=params)

        m = re.search(self.LINK_FREE_PATTERN, self.html)
        if m:
            self.link = urllib.unquote(m.group(1))
Beispiel #5
0
    def solveCaptcha(self):
        for _i in xrange(5):
            m = re.search(self.LIMIT_WAIT_PATTERN, self.html)
            if m:
                wait_time = int(m.group(1))
                self.wait(wait_time, wait_time > 60)
                self.retry()

            action, inputs = self.parseHtmlForm("action='#'")
            if not inputs:
                self.error(_("Captcha form not found"))
            self.logDebug(inputs)

            if inputs['captcha_type'] == 'recaptcha':
                recaptcha = ReCaptcha(self)
                inputs['recaptcha_response_field'], inputs[
                    'recaptcha_challenge_field'] = recaptcha.challenge()
            else:
                m = re.search(self.CAPTCHA_PATTERN, self.html)
                if m is None:
                    self.error(_("captcha"))
                captcha_url = m.group(1)
                inputs['captcha_response'] = self.decryptCaptcha(captcha_url)

            self.logDebug(inputs)
            self.html = self.load(self.url, post=inputs)

            if '<div class="captcha-error">Incorrect, try again!<' in self.html:
                self.invalidCaptcha()
            else:
                self.correctCaptcha()
                break
        else:
            self.fail(_("Invalid captcha"))
Beispiel #6
0
    def handleFree(self, pyfile):
        url = 'http://datei.to/ajax/download.php'
        data = {'P': 'I', 'ID': self.info['pattern']['ID']}
        recaptcha = ReCaptcha(self)

        for _i in xrange(10):
            self.logDebug("URL", url, "POST", data)
            self.html = self.load(url, post=data)
            self.checkErrors()

            if url.endswith('download.php') and 'P' in data:
                if data['P'] == 'I':
                    self.doWait()

                elif data['P'] == 'IV':
                    break

            m = re.search(self.DATA_PATTERN, self.html)
            if m is None:
                self.error(_("data"))
            url = 'http://datei.to/' + m.group(1)
            data = dict(x.split('=') for x in m.group(2).split('&'))

            if url.endswith('recaptcha.php'):
                data['recaptcha_response_field'], data[
                    'recaptcha_challenge_field'] = recaptcha.challenge()
        else:
            self.fail(_("Too bad..."))

        self.link = self.html
Beispiel #7
0
    def handleFree(self, pyfile):
        rep = self.load(
            r"http://luckyshare.net/download/request/type/time/file/" +
            self.info['pattern']['ID'],
            decode=True)

        self.logDebug("JSON: " + rep)

        json = self.parseJson(rep)
        self.wait(json['time'])

        recaptcha = ReCaptcha(self)

        for _i in xrange(5):
            response, challenge = recaptcha.challenge()
            rep = self.load(
                r"http://luckyshare.net/download/verify/challenge/%s/response/%s/hash/%s"
                % (challenge, response, json['hash']),
                decode=True)
            self.logDebug("JSON: " + rep)
            if 'link' in rep:
                json.update(self.parseJson(rep))
                self.correctCaptcha()
                break
            elif 'Verification failed' in rep:
                self.invalidCaptcha()
            else:
                self.error(_("Unable to get downlaod link"))

        if not json['link']:
            self.fail(
                _("No Download url retrieved/all captcha attempts failed"))

        self.link = json['link']
Beispiel #8
0
    def handleFree(self, pyfile):
        inputs = self.parseHtmlForm(
            input_names={'token': re.compile(r'.+')})[1]
        if 'token' not in inputs:
            self.error(_("Unable to detect token"))

        self.html = self.load(pyfile.url,
                              post={'token': inputs['token']},
                              decode=True)

        inputs = self.parseHtmlForm(input_names={'hash': re.compile(r'.+')})[1]
        if 'hash' not in inputs:
            self.error(_("Unable to detect hash"))

        recaptcha = ReCaptcha(self)
        response, challenge = recaptcha.challenge()

        #@NOTE: Work-around for v0.4.9 just_header issue
        #@TODO: Check for v0.4.10
        self.req.http.c.setopt(pycurl.FOLLOWLOCATION, 0)
        self.load(pyfile.url,
                  post={
                      'recaptcha_challenge_field': challenge,
                      'recaptcha_response_field': response,
                      'hash': inputs['hash']
                  })
        self.req.http.c.setopt(pycurl.FOLLOWLOCATION, 1)

        if 'location' in self.req.http.header.lower():
            self.link = re.search(r'location: (\S+)', self.req.http.header,
                                  re.I).group(1)
            self.correctCaptcha()
        else:
            self.invalidCaptcha()
Beispiel #9
0
    def handleFree(self, pyfile):
        # used here to load the cookies which will be required later
        self.load(pyfile.url, post={'goToFreePage': ""})

        self.load("http://nitroflare.com/ajax/setCookie.php", post={'fileId': self.info['pattern']['ID']})
        self.html = self.load("http://nitroflare.com/ajax/freeDownload.php",
                              post={'method': "startTimer", 'fileId': self.info['pattern']['ID']})

        self.checkErrors()

        try:
            js_file   = self.load("http://nitroflare.com/js/downloadFree.js?v=1.0.1")
            var_time  = re.search("var time = (\\d+);", js_file)
            wait_time = int(var_time.groups()[0])

        except Exception:
            wait_time = 60

        self.wait(wait_time)

        recaptcha = ReCaptcha(self)
        response, challenge = recaptcha.challenge(self.RECAPTCHA_KEY)

        self.html = self.load("http://nitroflare.com/ajax/freeDownload.php",
                              post={'method'                   : "fetchDownload",
                                    'recaptcha_challenge_field': challenge,
                                    'recaptcha_response_field' : response})

        return super(NitroflareCom, self).handleFree(pyfile)
Beispiel #10
0
    def handleFree(self, pyfile):
        recaptcha   = ReCaptcha(self)
        captcha_key = recaptcha.detect_key()

        if captcha_key:
            try:
                self.link = re.search(self.LINK_PREMIUM_PATTERN, self.html)
                recaptcha.challenge()

            except Exception, e:
                self.error(e)
Beispiel #11
0
    def handleFree(self, pyfile):
        recaptcha = ReCaptcha(self)

        response, challenge = recaptcha.challenge()
        self.html = self.load(pyfile.url,
                              post={
                                  'recaptcha_challenge_field': challenge,
                                  'recaptcha_response_field': response
                              })

        m = re.search(self.LINK_FREE_PATTERN, self.html)
        if m:
            self.link = m.group(1)
Beispiel #12
0
    def handleFree(self, pyfile):
        if r">Only premium users can download this file" in self.html:
            self.fail(_("Only premium users can download this file"))

        m = re.search(
            r"Next free download from your ip will be available in <b>(\d+)\s*minutes",
            self.html)
        if m:
            self.wait(int(m.group(1)) * 60, True)
        elif "The daily downloads limit from your IP is exceeded" in self.html:
            self.logWarning(
                _("You have reached your daily downloads limit for today"))
            self.wait(secondsToMidnight(gmt=2), True)

        self.logDebug("URL: " + self.req.http.lastEffectiveURL)
        m = re.match(self.__pattern__, self.req.http.lastEffectiveURL)
        fileID = m.group('ID') if m else self.info['pattern']['ID']

        m = re.search(r'recaptcha/api/challenge\?k=(\w+)', self.html)
        if m:
            recaptcha = ReCaptcha(self)
            captcha_key = m.group(1)

            for _i in xrange(5):
                get_data = {"type": "recaptcha"}
                get_data['capture'], get_data[
                    'challenge'] = recaptcha.challenge(captcha_key)
                res = json_loads(
                    self.load("http://extabit.com/file/%s/" % fileID,
                              get=get_data))
                if "ok" in res:
                    self.correctCaptcha()
                    break
                else:
                    self.invalidCaptcha()
            else:
                self.fail(_("Invalid captcha"))
        else:
            self.error(_("Captcha"))

        if not "href" in res:
            self.error(_("Bad JSON response"))

        self.html = self.load("http://extabit.com/file/%s%s" %
                              (fileID, res['href']))

        m = re.search(self.LINK_FREE_PATTERN, self.html)
        if m is None:
            self.error(_("LINK_FREE_PATTERN not found"))

        self.link = m.group(1)
Beispiel #13
0
    def handleCaptcha(self, inputs):
        m = re.search(self.CAPTCHA_PATTERN, self.html)
        if m:
            captcha_url = m.group(1)
            inputs['code'] = self.decryptCaptcha(captcha_url)
            return

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

            self.logDebug(captcha_div)

            inputs['code'] = "".join(
                a[1] for a in sorted(numerals, key=lambda num: int(num[0])))

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

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

        except Exception:
            captcha_key = recaptcha.detect_key()

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

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

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

        except Exception:
            captcha_key = solvemedia.detect_key()

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

        if captcha_key:
            inputs['adcopy_response'], inputs[
                'adcopy_challenge'] = solvemedia.challenge(captcha_key)
Beispiel #14
0
    def handleCaptcha(self):
        m = re.search(self.CAPTCHA_PATTERN, self.html)
        m2 = re.search(self.CIRCLE_CAPTCHA_PATTERN, self.html)

        if m:  #: normal captcha
            self.logDebug("Captcha-URL: %s" % m.group(1))

            captcha_code = self.decryptCaptcha(urlparse.urljoin(
                self.base_url, m.group(1)),
                                               forceUser=True,
                                               imgtype="gif")

            self.siteWithLinks = self.load(
                self.pyfile.url,
                post={'recaptcha_response_field': captcha_code},
                decode=True)
        elif m2:  #: circle captcha
            self.logDebug("Captcha-URL: %s" % m2.group(1))

            captcha_code = self.decryptCaptcha('%s%s?c=abc' %
                                               (self.base_url, m2.group(1)),
                                               result_type='positional')

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

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

            if captcha_key:
                response, challenge = recaptcha.challenge(captcha_key)
                self.siteWithLinks = self.load(
                    self.pyfile.url,
                    post={'g-recaptcha-response': response},
                    decode=True)
            else:
                self.logInfo(_("No captcha found"))
                self.siteWithLinks = self.html

        if "recaptcha_image" in self.siteWithLinks or "data-sitekey" in self.siteWithLinks:
            self.invalidCaptcha()
            self.retry()
Beispiel #15
0
    def unlockProtection(self):
        postData = {}

        form = re.search(r'<form name="protected"(.*?)</form>',
                         self.cleanedHtml, re.S).group(1)

        # Submit package password
        if "password" in form:
            password = self.getPassword()
            self.logDebug("Submitting password [%s] for protected links" %
                          password)
            postData['password'] = password

        # Resolve anicaptcha
        if "anicaptcha" in form:
            self.logDebug("Captcha protected")
            captchaUri = re.search(r'src="(/temp/anicaptcha/.+?)"',
                                   form).group(1)
            captcha = self.decryptCaptcha("http://ncrypt.in" + captchaUri)
            self.logDebug("Captcha resolved [%s]" % captcha)
            postData['captcha'] = captcha

        # Resolve recaptcha
        if "recaptcha" in form:
            self.logDebug("ReCaptcha protected")
            captcha_key = re.search(r'\?k=(.*?)"', form).group(1)
            self.logDebug("Resolving ReCaptcha with key [%s]" % captcha_key)
            recaptcha = ReCaptcha(self)
            response, challenge = recaptcha.challenge(captcha_key)
            postData['recaptcha_challenge_field'] = challenge
            postData['recaptcha_response_field'] = response

        # Resolve circlecaptcha
        if "circlecaptcha" in form:
            self.logDebug("CircleCaptcha protected")
            captcha_img_url = "http://ncrypt.in/classes/captcha/circlecaptcha.php"
            coords = self.decryptCaptcha(captcha_img_url,
                                         forceUser=True,
                                         imgtype="png",
                                         result_type='positional')
            self.logDebug("Captcha resolved, coords [%s]" % str(coords))
            postData['circle.x'] = coords[0]
            postData['circle.y'] = coords[1]

        # Unlock protection
        postData['submit_protected'] = 'Continue to folder'
        return self.load(self.pyfile.url, post=postData, decode=True)
Beispiel #16
0
    def handleFree(self, pyfile):
        self.load("http://uploaded.net/language/en", just_header=True)

        self.html = self.load("http://uploaded.net/js/download.js",
                              decode=True)

        recaptcha = ReCaptcha(self)
        response, challenge = recaptcha.challenge()

        self.html = self.load("http://uploaded.net/io/ticket/captcha/%s" %
                              self.info['pattern']['ID'],
                              post={
                                  'recaptcha_challenge_field': challenge,
                                  'recaptcha_response_field': response
                              })

        super(UploadedTo, self).handleFree(pyfile)
        self.checkErrors()
Beispiel #17
0
    def doCaptcha(self):
        captcha_key = re.search(self.CAPTCHA_KEY_PATTERN, self.html).group(1)
        recaptcha = ReCaptcha(self)

        for _i in xrange(5):
            response, challenge = recaptcha.challenge(captcha_key)
            res = json_loads(
                self.load(self.URLS[2],
                          post={
                              'recaptcha_challenge_field': challenge,
                              'recaptcha_response_field': response,
                              'recaptcha_shortencode_field': self.file_id
                          }))
            if not res['success']:
                self.invalidCaptcha()
            else:
                self.correctCaptcha()
                break
        else:
            self.fail(_("Invalid captcha"))
Beispiel #18
0
    def handleFree(self, pyfile):
        # STAGE 1: get link to continue
        m = re.search(self.CHASH_PATTERN, self.html)
        if m is None:
            self.error(_("CHASH_PATTERN not found"))
        chash = m.group(1)
        self.logDebug("Read hash " + chash)
        # continue to stage2
        post_data = {'hash': chash, 'free': 'Slow download'}
        self.html = self.load(pyfile.url, post=post_data, decode=True)

        # STAGE 2: solv captcha and wait
        # first get the infos we need: recaptcha key and wait time
        recaptcha = ReCaptcha(self)

        # try the captcha 5 times
        for i in xrange(5):
            m = re.search(self.WAIT_PATTERN, self.html)
            if m is None:
                self.error(_("Wait pattern not found"))
            wait_time = int(m.group(1))

            # then, do the waiting
            self.wait(wait_time)

            # then, handle the captcha
            response, challenge = recaptcha.challenge()
            post_data.update({'recaptcha_challenge_field': challenge,
                              'recaptcha_response_field' : response})

            self.html = self.load(pyfile.url, post=post_data, decode=True)

            # STAGE 3: get direct link
            m = re.search(self.LINK_FREE_PATTERN, self.html, re.S)
            if m:
                break

        if m is None:
            self.error(_("Download link not found"))

        self.link = m.group(1)
Beispiel #19
0
    def handleCaptcha(self):
        recaptcha = ReCaptcha(self)

        for _i in xrange(5):
            response, challenge = recaptcha.challenge(self.RECAPTCHA_KEY)

            m = re.search(r'var wait=(\d+);', self.html)
            self.setWait(int(m.group(1)) if m else 30)

            res = self.load("%s/free/captcha/%d" % (self.pyfile.url, int(time.time() * 1000)),
                            post={'dl_free'                  : "1",
                                  'recaptcha_challenge_field': challenge,
                                  'recaptcha_response_field' : response})
            if not res == '0':
                self.correctCaptcha()
                return res
            else:
                self.invalidCaptcha()
        else:
            self.invalidCaptcha()
            self.fail(_("No valid captcha solution received"))
Beispiel #20
0
    def solveCaptcha(self):
        recaptcha = ReCaptcha(self)

        for _i in xrange(5):
            response, challenge = recaptcha.challenge(self.RECAPTCHA_KEY)
            apiUrl = "https://www.oboom.com/1.0/download/ticket"
            params = {"recaptcha_challenge_field": challenge,
                      "recaptcha_response_field": response,
                      "download_id": self.fileId,
                      "token": self.sessionToken}
            result = self.loadUrl(apiUrl, params)

            if result[0] == 200:
                self.downloadToken = result[1]
                self.downloadAuth = result[2]
                self.correctCaptcha()
                self.setWait(30)
                self.wait()
                break

            elif result[0] == 400:
                if result[1] == "incorrect-captcha-sol":
                    self.invalidCaptcha()
                elif result[1] == "captcha-timeout":
                    self.invalidCaptcha()
                elif result[1] == "forbidden":
                    self.retry(5, 15 * 60, _("Service unavailable"))

            elif result[0] == 403:
                if result[1] == -1:  # another download is running
                    self.setWait(15 * 60)
                else:
                    self.setWait(result[1], True)
                self.wait()
                self.retry(5)
        else:
            self.invalidCaptcha()
            self.fail(_("Received invalid captcha 5 times"))
Beispiel #21
0
    def handleCaptcha(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
                                  },
                                  decode=True)
            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},
                                  decode=True)
Beispiel #22
0
    def handleFree(self, pyfile):
        self.req.http.lastURL = pyfile.url
        self.req.http.c.setopt(pycurl.HTTPHEADER,
                               ["X-Requested-With: XMLHttpRequest"])

        jsvars = self.getJsonResponse("https://rapidu.net/ajax.php",
                                      get={'a': "getLoadTimeToDownload"},
                                      post={'_go': ""},
                                      decode=True)

        if str(jsvars['timeToDownload']) is "stop":
            t = (24 * 60 * 60) - (int(time.time()) %
                                  (24 * 60 * 60)) + time.altzone

            self.logInfo("You've reach your daily download transfer")

            self.retry(10, 10 if t < 1 else None, _("Try tomorrow again")
                       )  #@NOTE: check t in case of not synchronised clock

        else:
            self.wait(int(jsvars['timeToDownload']) - int(time.time()))

        recaptcha = ReCaptcha(self)
        response, challenge = recaptcha.challenge(self.RECAPTCHA_KEY)

        jsvars = self.getJsonResponse("https://rapidu.net/ajax.php",
                                      get={'a': "getCheckCaptcha"},
                                      post={
                                          '_go': "",
                                          'captcha1': challenge,
                                          'captcha2': response,
                                          'fileId': self.info['pattern']['ID']
                                      },
                                      decode=True)

        if jsvars['message'] == 'success':
            self.link = jsvars['url']
Beispiel #23
0
    def getDownloadUrl(self):
        # Return location if direct download is active
        if self.premium:
            header = self.load(self.pyfile.url, just_header=True)
            if 'location' in header:
                return header['location']

        # Get download info
        self.logDebug("Getting download info")
        res = self.load("http://bitshare.com/files-ajax/" + self.file_id +
                        "/request.html",
                        post={
                            "request": "generateID",
                            "ajaxid": self.ajaxid
                        })

        self.handleErrors(res, ':')

        parts = res.split(":")
        filetype = parts[0]
        wait = int(parts[1])
        captcha = int(parts[2])

        self.logDebug("Download info [type: '%s', waiting: %d, captcha: %d]" %
                      (filetype, wait, captcha))

        # Waiting
        if wait > 0:
            self.logDebug("Waiting %d seconds." % wait)
            if wait < 120:
                self.wait(wait, False)
            else:
                self.wait(wait - 55, True)
                self.retry()

        # Resolve captcha
        if captcha == 1:
            self.logDebug("File is captcha protected")
            recaptcha = ReCaptcha(self)

            # Try up to 3 times
            for i in xrange(3):
                response, challenge = recaptcha.challenge()
                res = self.load("http://bitshare.com/files-ajax/" +
                                self.file_id + "/request.html",
                                post={
                                    "request": "validateCaptcha",
                                    "ajaxid": self.ajaxid,
                                    "recaptcha_challenge_field": challenge,
                                    "recaptcha_response_field": response
                                })
                if self.handleCaptchaErrors(res):
                    break

        # Get download URL
        self.logDebug("Getting download url")
        res = self.load("http://bitshare.com/files-ajax/" + self.file_id +
                        "/request.html",
                        post={
                            "request": "getDownloadURL",
                            "ajaxid": self.ajaxid
                        })

        self.handleErrors(res, '#')

        url = res.split("#")[-1]

        return url
Beispiel #24
0
    def handleFree(self, pyfile):
        action, inputs = self.parseHtmlForm('id="ifree_form"')
        if not action:
            self.error(_("ifree_form"))

        pyfile.size = float(inputs['sssize'])
        self.logDebug(action, inputs)
        inputs['desc'] = ""

        self.html = self.load(urlparse.urljoin("http://letitbit.net/", action), post=inputs)

        m = re.search(self.SECONDS_PATTERN, self.html)
        seconds = int(m.group(1)) if m else 60

        self.logDebug("Seconds found", seconds)

        m = re.search(self.CAPTCHA_CONTROL_FIELD, self.html)
        recaptcha_control_field = m.group(1)

        self.logDebug("ReCaptcha control field found", recaptcha_control_field)

        self.wait(seconds)

        res = self.load("http://letitbit.net/ajax/download3.php", post=" ")
        if res != '1':
            self.error(_("Unknown response - ajax_check_url"))

        self.logDebug(res)

        recaptcha = ReCaptcha(self)
        response, challenge = recaptcha.challenge()

        post_data = {"recaptcha_challenge_field": challenge,
                     "recaptcha_response_field": response,
                     "recaptcha_control_field": recaptcha_control_field}

        self.logDebug("Post data to send", post_data)

        res = self.load("http://letitbit.net/ajax/check_recaptcha.php", post=post_data)

        self.logDebug(res)

        if not res:
            self.invalidCaptcha()

        if res == "error_free_download_blocked":
            self.logWarning(_("Daily limit reached"))
            self.wait(secondsToMidnight(gmt=2), True)

        if res == "error_wrong_captcha":
            self.invalidCaptcha()
            self.retry()

        elif res.startswith('['):
            urls = json_loads(res)

        elif res.startswith('http://'):
            urls = [res]

        else:
            self.error(_("Unknown response - captcha check"))

        self.link = urls[0]
Beispiel #25
0
    def handleFree(self, pyfile):
        data = {"ukey": self.info['pattern']['ID']}

        m = re.search(self.AB1_PATTERN, self.html)
        if m is None:
            self.error(_("__AB1"))
        data['__ab1'] = m.group(1)

        recaptcha = ReCaptcha(self)

        m = re.search(self.RECAPTCHA_PATTERN, self.html)
        captcha_key = m.group(1) if m else recaptcha.detect_key()

        if captcha_key is None:
            self.error(_("ReCaptcha key not found"))

        response, challenge = recaptcha.challenge(captcha_key)
        self.account.form_data = {
            "recaptcha_challenge_field": challenge,
            "recaptcha_response_field": response
        }
        self.account.relogin(self.user)
        self.retry(2)

        json_url = "http://filecloud.io/download-request.json"
        res = self.load(json_url, post=data)
        self.logDebug(res)
        res = json_loads(res)

        if "error" in res and res['error']:
            self.fail(res)

        self.logDebug(res)
        if res['captcha']:
            data['ctype'] = "recaptcha"

            for _i in xrange(5):
                data['recaptcha_response'], data[
                    'recaptcha_challenge'] = recaptcha.challenge(captcha_key)

                json_url = "http://filecloud.io/download-request.json"
                res = self.load(json_url, post=data)
                self.logDebug(res)
                res = json_loads(res)

                if "retry" in res and res['retry']:
                    self.invalidCaptcha()
                else:
                    self.correctCaptcha()
                    break
            else:
                self.fail(_("Incorrect captcha"))

        if res['dl']:
            self.html = self.load('http://filecloud.io/download.html')

            m = re.search(self.LINK_FREE_PATTERN % self.info['pattern']['ID'],
                          self.html)
            if m is None:
                self.error(_("LINK_FREE_PATTERN not found"))

            if "size" in self.info and self.info['size']:
                self.check_data = {"size": int(self.info['size'])}

            self.link = m.group(1)
        else:
            self.fail(_("Unexpected server response"))
Beispiel #26
0
    def handleFree(self, pyfile):
        m = re.search(self.FLP_TOKEN_PATTERN, self.html)
        if m is None:
            self.error(_("Token"))
        flp_token = m.group(1)

        m = re.search(self.RECAPTCHA_PATTERN, self.html)
        if m is None:
            self.error(_("Captcha key"))
        captcha_key = m.group(1)

        # Get wait time
        get_dict = {
            'SID': self.req.cj.getCookie('SID'),
            'JsHttpRequest': str(int(time.time() * 10000)) + '-xml'
        }
        post_dict = {
            'action': 'set_download',
            'token': flp_token,
            'code': self.info['pattern']['ID']
        }
        wait_time = int(self.getJsonResponse(get_dict, post_dict, 'wait_time'))

        if wait_time > 0:
            self.wait(wait_time)

        post_dict = {
            "token": flp_token,
            "code": self.info['pattern']['ID'],
            "file_pass": ''
        }

        if 'var is_pass_exists = true;' in self.html:
            # Solve password
            password = self.getPassword()

            if password:
                self.logInfo(_("Password protected link, trying ") + file_pass)

                get_dict['JsHttpRequest'] = str(int(
                    time.time() * 10000)) + '-xml'
                post_dict['file_pass'] = file_pass

                self.link = self.getJsonResponse(get_dict, post_dict, 'link')

                if not self.link:
                    self.fail(_("Incorrect password"))
            else:
                self.fail(_("No password found"))

        else:
            # Solve recaptcha
            recaptcha = ReCaptcha(self)

            for i in xrange(5):
                get_dict['JsHttpRequest'] = str(int(
                    time.time() * 10000)) + '-xml'
                if i:
                    post_dict['recaptcha_response_field'], post_dict[
                        'recaptcha_challenge_field'] = recaptcha.challenge(
                            captcha_key)
                    self.logDebug(
                        u"RECAPTCHA: %s : %s : %s" %
                        (captcha_key, post_dict['recaptcha_challenge_field'],
                         post_dict['recaptcha_response_field']))

                self.link = self.getJsonResponse(get_dict, post_dict, 'link')

            else:
                self.fail(_("Invalid captcha"))