Python utils.dict_from_cookiejar函数代码示例

    def login(self):
        """Login method used for logging in before doing search and torrent downloads."""
        if any(dict_from_cookiejar(self.session.cookies).values()):
            return True

        if 'pass' in dict_from_cookiejar(self.session.cookies):
            return True

        login_html = self.session.get(self.urls['login'])
        with BS4Parser(login_html.text, 'html5lib') as html:
            token = html.find('input', attrs={'name': '_token'}).get('value')

        login_params = {
            '_token': token,
            'email_username': self.username,
            'password': self.password,
            'remember': 1,
            'submit': 'Login',
        }

        response = self.session.post(self.urls['login'], data=login_params)
        if not response or not response.text:
            log.warning('Unable to connect to provider')
            return False

        if 'These credentials do not match our records.' in response.text:
            log.warning('Invalid username or password. Check your settings')
            return False

        return True

    def _getBasicURI(self, uri, values=None):
        '''
        Perform a GET/POST to a URI
        '''

        # POST if data is present, otherwise GET.
        if values is None:
            if self.debug:
                print('GET on: ', self._baseurl+uri)
                print(dict_from_cookiejar(self.opener.cookies))
            response = self.opener.get(self._baseurl+uri)
        else:
            if self.debug:
                print('POST on: ', self._baseurl+uri)
                print(dict_from_cookiejar(self.opener.cookies))
            response = self.opener.post(self._baseurl+uri, data=values)

        if self.debug:
            print('Final URL:', response.url)
            print(dict_from_cookiejar(self.opener.cookies))

        # Save the cookies.
        with open(self._cookiefile, 'wb') as h:
            pickle.dump(dict_from_cookiejar(self.opener.cookies), h)

        # Return the response object.
        return response

    def login(self):
        """Login method used for logging in before doing a search and torrent downloads."""
        cookie_dict = dict_from_cookiejar(self.session.cookies)
        if cookie_dict.get('session'):
            return True

        if self.cookies:
            add_dict_to_cookiejar(self.session.cookies, dict(x.rsplit('=', 1) for x in self.cookies.split(';')))

        cookie_dict = dict_from_cookiejar(self.session.cookies)
        if cookie_dict.get('session'):
            return True

        login_params = {
            'submit': 'Login',
            'username': self.username,
            'password': self.password,
            'keeplogged': 1,
        }

        response = self.get_url(self.urls['login'], post_data=login_params, returns='text')
        if not response:
            logger.log(u"Unable to connect to provider", logger.WARNING)
            return False

        if re.search('<title>Login :: BJ-Share</title>', response):
            logger.log(u"Invalid username or password. Check your settings", logger.WARNING)
            return False

        return True

    def login(self):
        if any(dict_from_cookiejar(sickrage.app.wsession.cookies).values()):
            return True

        if self.token is not None:
            if time.time() < (self.tokenLastUpdate + 30 * 60):
                return True

        login_params = {'username': self.username,
                        'password': self.password}

        try:
            response = sickrage.app.wsession.post(self.urls['login'], data=login_params, timeout=30,
                                                         auth=T411Auth(self.token)).json()
        except Exception:
            sickrage.app.log.warning("Unable to connect to provider".format(self.name))
            return False

        if 'token' in response:
            self.token = response['token']
            self.tokenLastUpdate = time.time()
            self.uid = response['uid'].encode('ascii', 'ignore')
            return True
        else:
            sickrage.app.log.warning("Token not found in authentication response")
            return False

 def post(self,
          url,
          headers=None,
          cookies=None,
          timeout=30,
          data={},
          verify=False,
          proxies=None):
     if self.session:
         r = self.session.post(
             url,
             headers=OrderDict(headers),
             cookies=cookies,
             timeout=timeout,
             data=data,
             verify=verify,
             proxies=proxies)
         r.raise_for_status()
         r.encoding = 'utf-8'
         return r.text, r.headers, dict_from_cookiejar(r.cookies), r.history
     else:
         r = requests.post(
             url,
             headers=OrderDict(headers),
             cookies=cookies,
             timeout=timeout,
             data=data,
             verify=verify,
             proxies=proxies)
         r.raise_for_status()
         r.encoding = 'utf-8'
         return r.text, r.headers, dict_from_cookiejar(r.cookies), r.history

    def login(self):
        if dict_from_cookiejar(self.session.cookies).get('uid') and dict_from_cookiejar(self.session.cookies).get('pass'):
            return True

        if self.cookies:
            self.add_cookies_from_ui()

            login_params = {
                'username': self.username,
                'password': self.password,
                'submit.x': 0,
                'submit.y': 0,
            }

            response = self.get_url(self.urls['login'], post_data=login_params, returns='response')
            if response.status_code != 200:
                logger.log('Unable to connect to provider', logger.WARNING)
                return False

            if re.search('You tried too often', response.text):
                logger.log('Too many login access attempts', logger.WARNING)
                return False

            if (dict_from_cookiejar(self.session.cookies).get('uid') and 
                    dict_from_cookiejar(self.session.cookies).get('uid') in response.text):
                    return True
            else:
                logger.log('Failed to login, check your cookies', logger.WARNING)
                self.session.cookies.clear()
                return False

def _auth(usr, pswd, url, version):
    """ Authenticate to the remote ColdFusion server; bit of a pain 
    """

    if version in ['5.0']:
        data = {'PasswordProvided_required':'You+must+provide+a+password.',
                'PasswordProvided' : pswd,
                'Submit' : 'Password'
        }

    elif version in ['6.0', '6.1']:
        data = {
            'cfadminPassword' : pswd,
            'requestedURL' : '/CFIDE/administrator/index.cfm',
            'submit' : 'Login'
        }

    elif version in ['7.0', '8.0', '9.0']:
        salt = _salt(url) 
        hsh = hmac.new(salt, sha1(pswd).hexdigest().upper(), sha1).hexdigest().upper()
        data = {"cfadminPassword" : hsh,
                "requestedURL" : "/CFIDE/administrator/enter.cfm?",
                "cfadminUserId" : usr,
                "salt" : salt,
                "submit" : "Login"
               }

    elif version in ['10.0', '11.0']:
        
        hsh = sha1(pswd).hexdigest().upper()
        data = {'cfadminPassword' : hsh,
                'requestedURL' : '/CFIDE/administrator/enter.cfm?',
                'cfadminUserId' : usr,
                'submit' : 'Login'
               }

    try:
        res = utility.requests_post(url, data=data)
        if res.status_code is 200:

            utility.Msg("Successfully authenticated with %s:%s" % (usr, pswd), LOG.DEBUG)
            if version in ['5.0']:
                return (dict_from_cookiejar(res.cookies), None)
            elif len(res.history) > 0:
                return (dict_from_cookiejar(res.history[0].cookies), None)

    except Exception, e:
        utility.Msg("Error authenticating: %s" % e, LOG.ERROR)
        return (None, None)

    def login(self):
        cookie_dict = dict_from_cookiejar(self.cookie_jar)
        if cookie_dict.get('uid') and cookie_dict.get('pass'):
            return True

        if not self.add_cookies_from_ui():
            return False

        login_params = {'username': self.username, 'password': self.password, 'login': 'submit'}

        response = sickrage.srCore.srWebSession.post(self.urls['login'], data=login_params, timeout=30)
        if not response.ok:
            sickrage.srCore.srLogger.warning("[{}]: Unable to connect to provider".format(self.name))
            return False

        # Invalid username and password combination
        if re.search('Invalid username and password combination', response.text):
            sickrage.srCore.srLogger.warning(u"Invalid username or password. Check your settings")
            return False

        # You tried too often, please try again after 2 hours!
        if re.search('You tried too often', response.text):
            sickrage.srCore.srLogger.warning(u"You tried too often, please try again after 2 hours! Disable IPTorrents for at least 2 hours")
            return False

        # Captcha!
        if re.search('Captcha verification failed.', response.text):
            sickrage.srCore.srLogger.warning(u"Stupid captcha")
            return False

        return True

	def __init__(self, basename='edapi', cookiefile=None):
		# Build common file names from basename.
		self._basename = basename
		if cookiefile:
			self._cookiefile = cookiefile
		else:
			self._cookiefile = self._basename + '.cookies'

		self._envfile = self._basename + '.vars'

		# Setup the HTTP session.
		self.opener = requests.Session()

		self.opener.headers = {
			'User-Agent': self._agent
		}

		# Read/create the cookie jar.
		if os.path.exists(self._cookiefile):
			try:
				with open(self._cookiefile, 'rb') as h:
					self.opener.cookies = cookiejar_from_dict(pickle.load(h))
			except:
				print('Cookie files exists, but is unreadable.')
		else:
			with open(self._cookiefile, 'wb') as h:
				pickle.dump(dict_from_cookiejar(self.opener.cookies), h)

		# Grab the commander profile
		self.response = self._getURI('profile')

    def login(self):
        if any(dict_from_cookiejar(self.session.cookies).values()):
            return True

        login_params = {
            'username': self.username,
            'password': self.password,
            'submit.x': 0,
            'submit.y': 0
        }

        response = self.get_url(self.urls['login'], post_data=login_params, returns='text')
        if not response:
            logger.log('Unable to connect to provider', logger.WARNING)
            return False

        if re.search('Password not correct', response):
            logger.log('Your login is incorrect', logger.WARNING)
            return False

        if re.search('You tried too often', response):
            logger.log('Too many login access attempts', logger.WARNING)
            return False

        return True

    def login(self):
        if any(dict_from_cookiejar(self.session.cookies).values()):
            return True

        login_params = {'username': self.username,
                        'password': self.password,
                        'login': 'submit'}

        self.get_url(self.urls['login'], returns='text')
        response = self.get_url(self.urls['login'], post_data=login_params, returns='text')
        if not response:
            logger.log(u"Unable to connect to provider", logger.WARNING)
            return False

        # Invalid username and password combination
        if re.search('Invalid username and password combination', response):
            logger.log(u"Invalid username or password. Check your settings", logger.WARNING)
            return False

        # You tried too often, please try again after 2 hours!
        if re.search('You tried too often', response):
            logger.log(u"You tried too often, please try again after 2 hours! Disable IPTorrents for at least 2 hours", logger.WARNING)
            return False

        return True

    def login(self):
        """Login method used for logging in before doing search and torrent downloads."""
        cookies = dict_from_cookiejar(self.session.cookies)
        if any(cookies.values()) and cookies.get('uid'):
            return True

        login_params = {
            'username': self.username,
            'password': self.password,
        }

        response = self.session.post(self.urls['login'], data=login_params)

        if not response or not response.text:
            log.warning('Unable to connect to provider')
            return False

        if response.text == 'OK':
            return True
        elif response.text == 'Banned':
            log.warning('User {0} is banned from HeBits', self.username)
            return False
        elif response.text == 'MaxAttempts':
            log.warning('Max number of login attempts exceeded - your IP is blocked')
            return False
        else:
            log.warning('Invalid username or password. Check your settings')
            return False

    def login(self):
        if any(dict_from_cookiejar(self.session.cookies).values()):
            return True

        login_params = {
            'username': self.username,
            'password': self.password,
            'take_login': '1'
        }

        response = self.get_url(self.urls['login'], post_data=login_params, returns='text')

        if not response:
            check_login = self.get_url(self.urls['base_url'], returns='text')
            if re.search('account-logout.php', check_login):
                return True
            else:
                logger.log(u"Unable to connect to provider", logger.WARNING)
                return False

        if re.search('account-login.php', response):
            logger.log(u"Invalid username or password. Check your settings", logger.WARNING)
            return False

        return True

def attemptPTH(url, usr_auth):
    """ In vulnerable instances of CF7-9, you can use --cf-hash to obtain
    the remote server's hash and pass it.            
    """            
    
    utility.Msg("Attempting to pass the hash..", LOG.DEBUG)
    
    usr = None
    pwhsh = None
    if ':' in usr_auth:
        (usr, pwhsh) = usr_auth.split(':')
    else:
        (usr, pwhsh) = "admin", usr_auth

    salt = _salt(url) 
    hsh = hmac.new(salt, pwhsh, sha1).hexdigest().upper()
    data = {"cfadminPassword" : hsh,
            "requestedURL" : "/CFIDE/administrator/enter.cfm?",
            "cfadminUserId" : usr, 
            "salt" : salt,
            "submit" : "Login"
           }

    try:
        res = utility.requests_post(url, data=data)
        if res.status_code is 200 and len(res.history) > 0:
            utility.Msg("Sucessfully passed the hash", LOG.DEBUG)
            return (dict_from_cookiejar(res.history[0].cookies), None)
        
    except Exception, e:
        utility.Msg("Error authenticating: %s" % e, LOG.ERROR)

    def login(self):
        if any(dict_from_cookiejar(self.session.cookies).values()):
            return True

        login_params = {
            'username': self.username,
            'password': self.password,
        }

        # Yay lets add another request to the process since they are unreasonable.
        response = self.get_url(self.url, returns='text')
        with BS4Parser(response, 'html5lib') as html:
            form = html.find('form', id='loginform')
            if form:
                self.urls['login'] = urljoin(self.url, form['action'])

        response = self.get_url(self.urls['login'], post_data=login_params, returns='text')
        if not response:
            logger.log("Unable to connect to provider", logger.WARNING)
            return False

        if re.search('Incorrect username or Password. Please try again.', response):
            logger.log("Invalid username or password. Check your settings", logger.WARNING)
            return False

        return True