def load_cookie(self, resp):
cookie = http_cookies.SimpleCookie()
try:
cookie.load(resp.headers['Set-Cookie'])
return cookie
except KeyError:
return None
def _refresh_cookie(self, c, delta):
"""
Takes a cookie string c and a time delta in seconds, and returns
a refreshed cookie string.
"""
try:
c = Cookie.SimpleCookie(str(c))
except Cookie.CookieError:
raise ValueError("Invalid Cookie")
for i in c.values():
if "expires" in i:
d = parsedate_tz(i["expires"])
if d:
d = mktime_tz(d) + delta
i["expires"] = formatdate(d)
else:
# This can happen when the expires tag is invalid.
# reddit.com sends a an expires tag like this: "Thu, 31 Dec
# 2037 23:59:59 GMT", which is valid RFC 1123, but not
# strictly correct according to the cookie spec. Browsers
# appear to parse this tolerantly - maybe we should too.
# For now, we just ignore this.
del i["expires"]
ret = c.output(header="").strip()
if not ret:
raise ValueError("Invalid Cookie")
return ret
def test_headers():
webdriver = instantiate_webdriver(webdriver_class)
# TODO: Add more cookie examples with additional fields, such as
# expires, path, comment, max-age, secure, version, httponly
domain = get_tld(echo_header_server) if webdriver.name == 'phantomjs' else None
cookies = (
{'domain': domain, 'name': 'hello', 'value': 'world'},
{'domain': domain, 'name': 'another', 'value': 'cookie'}
)
# Open the server URL with the WebDriver instance initially so we can
# set custom cookies
webdriver.get(echo_header_server)
for cookie in cookies:
webdriver.add_cookie(cookie)
response = webdriver.request('GET', echo_header_server, headers={'extra': 'header'},
cookies={'extra': 'cookie'})
sent_headers = requests.structures.CaseInsensitiveDict(json.loads(response.headers['echo']))
# Simply assert that the User-Agent isn't requests' default one, which
# means that it and the rest of the headers must have been overwritten
assert sent_headers['user-agent'] != requests.utils.default_user_agent()
# Check if the additional header was sent as well
assert 'extra' in sent_headers and sent_headers['extra'] == 'header'
cookies = http_cookies.SimpleCookie()
# Python 2's Cookie module expects a string object, not Unicode
cookies.load(sent_headers['cookie'] if six.PY3 else sent_headers['cookie'].encode('ASCII'))
assert 'hello' in cookies and cookies['hello'].value == 'world'
assert 'another' in cookies and cookies['another'].value == 'cookie'
# Check if the additional cookie was sent as well
assert 'extra' in cookies and cookies['extra'].value == 'cookie'
webdriver.quit()
def get_cookie(res, cookie_name):
headers = res.headers.to_list()
cookie_string = [
h for h in headers if (h[0] == 'Set-Cookie' and cookie_name in h[1])
][0][1]
cookie = http_cookies.SimpleCookie(cookie_string)
access_granted_cookie = cookie[list(cookie.keys())[0]].value
return access_granted_cookie
def store_cookies(self, resp):
cookies = http_cookies.SimpleCookie()
try:
cookies.load(resp.headers['Set-Cookie'])
for key in cookies:
self.cookies[key] = cookies[key].value
except:
pass
def parse(curl_command):
method = "get"
tokens = shlex.split(curl_command)
parsed_args = parser.parse_args(tokens)
base_indent = " " * 4
data_token = ''
if parsed_args.X.lower() == 'post':
method = 'post'
post_data = parsed_args.data or parsed_args.data_binary
if post_data:
method = 'post'
try:
post_data_json = json.loads(post_data)
except ValueError:
post_data_json = None
# If we found JSON and it is a dict, pull it apart. Otherwise, just leave as a string
if post_data_json and isinstance(post_data_json, dict):
post_data = dict_to_pretty_string(post_data_json)
else:
post_data = "'{}'".format(post_data)
data_token = '{}data={},\n'.format(base_indent, post_data)
cookie_dict = OrderedDict()
quoted_headers = OrderedDict()
for curl_header in parsed_args.header:
if curl_header.startswith(':'):
occurrence = [m.start() for m in re.finditer(':', curl_header)]
header_key, header_value = curl_header[:occurrence[1]], curl_header[occurrence[1] + 1:]
else:
header_key, header_value = curl_header.split(":", 1)
if header_key.lower() == 'cookie':
cookie = Cookie.SimpleCookie(header_value)
for key in cookie:
cookie_dict[key] = cookie[key].value
else:
quoted_headers[header_key] = header_value.strip()
result = """requests.{method}("{url}",
{data_token}{headers_token},
{cookies_token},{security_token}
)""".format(
method=method,
url='https://github.com/search',
data_token=data_token,
headers_token="{}headers={}".format(base_indent, dict_to_pretty_string(quoted_headers)),
cookies_token="{}cookies={}".format(base_indent, dict_to_pretty_string(cookie_dict)),
security_token="\n%sverify=False" % base_indent if parsed_args.insecure else ""
)
headerNCookie={}
headerNCookie['headers']=quoted_headers
headerNCookie['cookies']=cookie_dict
return headerNCookie
def handle_response(self, f):
for i in f.response.headers.get_all("set-cookie"):
# FIXME: We now know that Cookie.py screws up some cookies with
# valid RFC 822/1123 datetime specifications for expiry. Sigh.
c = http_cookies.SimpleCookie(str(i))
for m in c.values():
k = self.ckey(m, f)
if self.domain_match(f.request.host, k[0]):
self.jar[k] = m
def set_cookie(self, name, value = '', expires = 0, path = '/', domain = '', secure = False, http_only = False):
cook = http_cookies.SimpleCookie()
cook[name] = value
cook[name]['expires'] = expires
cook[name]['path'] = path
cook[name]['domain'] = domain
cook[name]['secure'] = secure
cook[name]['httponly'] = http_only
self.send_header('Set-Cookie', cook.output(header = ''))
def _cookie_replace(self, message):
"""Replace $COOKIE in a message.
With cookie data from set-cookie in the prior request.
"""
response_cookies = self.prior.response['set-cookie']
cookies = http_cookies.SimpleCookie()
cookies.load(response_cookies)
cookie_string = cookies.output(attrs=[], header='', sep=',').strip()
return message.replace('$COOKIE', cookie_string)
def http_parse_cookies(headers):
if 'Cookie' not in headers:
return {}
try:
cookies = Cookie.SimpleCookie()
cookies.load(native_str(headers["Cookie"]))
return dict((key, name.value) for key, name in six.iteritems(cookies))
except Exception:
return {}
def parse(curl_command):
method = "get"
tokens = shlex.split(curl_command)
parsed_args = parser.parse_args(tokens)
base_indent = " " * 4
data_token = ''
post_data = parsed_args.data or parsed_args.data_binary
if post_data:
method = 'post'
try:
post_data_json = json.loads(post_data)
except ValueError:
post_data_json = None
# If we found JSON and it is a dict, pull it apart. Otherwise, just leave as a string
if post_data_json and isinstance(post_data_json, dict):
post_data = dict_to_pretty_string(post_data_json)
else:
post_data = "'{}'".format(post_data)
data_token = '{}data={},\n'.format(base_indent, post_data)
cookie_dict = OrderedDict()
quoted_headers = OrderedDict()
for curl_header in parsed_args.header:
header_key, header_value = curl_header.split(":", 1)
if header_key.lower() == 'cookie':
cookie = Cookie.SimpleCookie(header_value)
for key in cookie:
cookie_dict[key] = cookie[key].value
else:
quoted_headers[header_key] = header_value.strip()
result = """requests.{method}("{url}",
{data_token}{headers_token},
{cookies_token},
)""".format(
method=method,
url=parsed_args.url,
data_token=data_token,
headers_token="{}headers={}".format(
base_indent, dict_to_pretty_string(quoted_headers)),
cookies_token="{}cookies={}".format(
base_indent, dict_to_pretty_string(cookie_dict)),
)
# print result
if method == "post":
return parsed_args.url, method, ''.join(post_data).strip(
"'"), quoted_headers, cookie_dict
else:
return parsed_args.url, method, None, quoted_headers, cookie_dict
def get_cookie_value(cookies, name):
'''
Returns cookie value by its name. None if no such value.
:param cookies: str: cookies raw data
:param name: str: cookies key
'''
cookie_parser = http_cookies.SimpleCookie()
cookie_parser.load(str(cookies))
try:
return cookie_parser[name].value
except KeyError:
return None
def _cookie_replacer(self, match):
"""Replace a regex match with the cookie of a previous response."""
case = match.group('case')
if case:
referred_case = self.history[case]
else:
referred_case = self.prior
response_cookies = referred_case.response['set-cookie']
cookies = http_cookies.SimpleCookie()
cookies.load(response_cookies)
cookie_string = cookies.output(attrs=[], header='', sep=',').strip()
return cookie_string
def parse_cookies_and_headers(origin_headers):
""":return: tuple. type is (OrderedDict(), OrderedDict())"""
cookies = OrderedDict()
headers = CaseInsensitiveDict()
for curl_header in origin_headers:
header_key, header_value = curl_header.split(':', 1)
if header_key.lower() == 'cookie':
cookie = Cookie.SimpleCookie(header_value)
for key in cookie:
cookies[key] = cookie[key].value
else:
headers[header_key] = header_value.strip()
return cookies, headers
def findCookieData(cookieName):
" return value of cookie or None is not set, port of lib/cheapcgi.c:findCookieData "
global cookies
if not cookies:
if "HTTP_COOKIE" in os.environ:
cookies = http_cookies.SimpleCookie(os.environ["HTTP_COOKIE"])
else:
cookies = {}
# unlike cheapcgi, Python does not even allow duplicate cookies, so no need to handle this case
cookie = cookies.get(cookieName)
if cookie:
return cookie.value
return None
def parse(curl_command):
method = "get"
tokens = shlex.split(curl_command)
parsed_args = parser.parse_args(tokens)
base_indent = " " * 4
data_token = ''
if parsed_args.X.lower() == 'post':
method = 'post'
post_data = parsed_args.data or parsed_args.data_binary
if post_data:
method = 'post'
post_data = "'{}'".format(post_data)
data_token = '{}data={},\n'.format(base_indent, post_data)
cookie_dict = OrderedDict()
quoted_headers = OrderedDict()
for curl_header in parsed_args.header:
if curl_header.startswith(':'):
occurrence = [m.start() for m in re.finditer(':', curl_header)]
header_key, header_value = curl_header[:occurrence[
1]], curl_header[occurrence[1] + 1:]
else:
header_key, header_value = curl_header.split(":", 1)
if header_key.lower() == 'cookie':
cookie = Cookie.SimpleCookie(header_value)
for key in cookie:
cookie_dict[key] = cookie[key].value
else:
quoted_headers[header_key] = header_value.strip()
result = """requests.{method}("{url}",
{data_token}{headers_token},
{cookies_token},{security_token}
)""".format(method=method,
url=parsed_args.url,
data_token=data_token,
headers_token="{}headers={}".format(
base_indent, dict_to_pretty_string(quoted_headers)),
cookies_token="{}cookies={}".format(
base_indent, dict_to_pretty_string(cookie_dict)),
security_token="\n%sverify=False" %
base_indent if parsed_args.insecure else "")
return result
def parse_context(curl_command):
method = "get"
tokens = shlex.split(curl_command)
parsed_args = parser.parse_args(tokens)
post_data = parsed_args.data or parsed_args.data_binary or parsed_args.data_urlencoded or parsed_args.form
if post_data:
method = 'post'
if parsed_args.X:
method = parsed_args.X.lower()
cookie_dict = OrderedDict()
quoted_headers = OrderedDict()
if len(parsed_args.data_urlencoded) > 0 :
data_dict = OrderedDict()
for curl_param in post_data :
param_header, param_value = curl_param.split("=",1)
data_dict[param_header] = param_value.strip()
post_data = data_dict
elif len (parsed_args.form) > 0:
post_data = '&'.join(post_data)
for curl_header in parsed_args.header:
if curl_header.startswith(':'):
occurrence = [m.start() for m in re.finditer(':', curl_header)]
header_key, header_value = curl_header[:occurrence[1]], curl_header[occurrence[1] + 1:]
else:
header_key, header_value = curl_header.split(":", 1)
if header_key.lower() == 'cookie':
cookie = Cookie.SimpleCookie(header_value)
for key in cookie:
cookie_dict[key] = cookie[key].value
else:
quoted_headers[header_key] = header_value.strip()
return ParsedContext(
method=method,
url=parsed_args.url,
data=post_data,
headers=quoted_headers,
cookies=cookie_dict,
verify=parsed_args.insecure
)
def setCookies():
"""
Gets the __ac value from the browser headers and sets it as cookie in order to keep
the user logged during the tests. If SimpleCookie can't parse the values,
regular expressions are used.
"""
headers_cookie = self.browser.headers['set-cookie']
cookie = Cookie.SimpleCookie()
cookie.load(headers_cookie)
if '__ac' in cookie.keys():
ac_value = cookie['__ac'].value
else:
reg = '__ac=\"([A-Za-z0-9%]+)*\"'
match = re.search(reg, headers_cookie)
ac_value = match.group(1) if match else None
self.browser.cookies["__ac"] = ac_value
def __init__(self, iterable, status, headers):
self._text = None
self._content = b''.join(iterable)
if hasattr(iterable, 'close'):
iterable.close()
self._status = status
self._status_code = int(status[:3])
self._headers = CaseInsensitiveDict(headers)
cookies = http_cookies.SimpleCookie()
for name, value in headers:
if name.lower() == 'set-cookie':
cookies.load(value)
if _PY26 or (_PY27 and _JYTHON):
match = re.match(r'\s*([^=;,]+)=', value)
assert match
cookie_name = match.group(1)
# NOTE(kgriffs): py26/Jython has a bug that causes
# SimpleCookie to incorrectly parse the "expires"
# attribute, so we have to do it ourselves. This
# algorithm is obviously very naive, but it should
# work well enough until we stop supporting
# 2.6, at which time we can remove this code.
match = re.search('expires=([^;]+)', value)
if match:
cookies[cookie_name]['expires'] = match.group(1)
# NOTE(kgriffs): py26/Jython's SimpleCookie won't
# parse the "httponly" and "secure" attributes, so
# we have to do it ourselves.
if 'httponly' in value:
cookies[cookie_name]['httponly'] = True
if 'secure' in value:
cookies[cookie_name]['secure'] = True
self._cookies = dict(
(morsel.key, Cookie(morsel))
for morsel in cookies.values()
)
self._encoding = helpers.get_encoding_from_headers(self._headers)
def get_cookie(res, cookie_name):
headers = res.headers.to_list()
set_cookie_strings = [
h for h in headers if (h[0] == 'Set-Cookie' and cookie_name in h[1])
]
try:
cookie_string = set_cookie_strings[0][1]
except IndexError as e:
print(cookie_name)
for header in headers:
print(header)
print(set_cookie_strings)
raise e
cookie = http_cookies.SimpleCookie(cookie_string)
access_granted_cookie = cookie[list(cookie.keys())[0]].value
return access_granted_cookie
def analyze(curl_command):
method = "get"
tokens = shlex.split(curl_command)
parsed_args = parser.parse_args(tokens)
base_indent = " " * 4
data_token = ''
post_data = parsed_args.data or parsed_args.data_binary
if post_data:
method = 'post'
try:
post_data_json = json.loads(post_data)
except ValueError:
post_data_json = None
# If we found JSON and it is a dict, pull it apart. Otherwise, just leave as a string
if post_data_json and isinstance(post_data_json, dict):
post_data = dict_to_pretty_string(post_data_json)
else:
post_data = "'{}',\n".format(post_data)
data_token = '{}data={}'.format(base_indent, post_data)
cookie_dict = OrderedDict()
quoted_headers = OrderedDict()
for curl_header in parsed_args.header:
header_key, header_value = curl_header.split(":", 1)
if header_key.lower() == 'cookie':
cookie = Cookie.SimpleCookie(header_value)
for key in cookie:
cookie_dict[key] = cookie[key].value
else:
quoted_headers[header_key] = header_value.strip()
results = {
"method": method,
"url": parsed_args.url,
"data_token": data_token,
"headers": quoted_headers,
"cookies": cookie_dict,
"base_indent": base_indent
}
return results
def get_first_matching_cookie(cookie_names, path, resp_headers):
if 'Set-Cookie' not in resp_headers:
return None
cookies = http_cookies.SimpleCookie()
try:
cookies.load(resp_headers['Set-Cookie'])
except:
return None
if isinstance(cookie_names, six.string_types):
cookie_names = [cookie_names]
for cn in cookie_names:
if cn in cookies:
c = cookies[cn]
if c and cookie_matches_path(c, path):
return c
return None
def _get_session_cookie(self):
'''**Deprecated** Use session_id instead.
Attempt to retrieve the session cookie from the filesystem.
:Returns: user's session cookie
'''
warnings.warn(
'session_cookie is deprecated, use session_id'
' instead',
DeprecationWarning,
stacklevel=2)
session_id = self.session_id
if not session_id:
return ''
cookie = Cookie.SimpleCookie()
cookie[self.session_name] = session_id
return cookie
def get_all_matching_cookies(cookie_names, path, resp_headers):
matching_cookies = None
if 'Set-Cookie' not in resp_headers:
return None
cookies = http_cookies.SimpleCookie()
try:
cookies.load(resp_headers['Set-Cookie'])
except Exception:
return None
matching_cookies = []
for cn in cookie_names:
if cn in cookies:
c = cookies[cn]
if c and cookie_matches_path(c, path):
matching_cookies.append(c)
return matching_cookies
def parse_context(curl_command):
method = "get"
tokens = shlex.split(curl_command)
parsed_args = parser.parse_args(tokens)
post_data = parsed_args.data or parsed_args.data_binary
if post_data:
method = 'post'
if parsed_args.X:
method = parsed_args.X.lower()
cookie_dict = OrderedDict()
quoted_headers = OrderedDict()
for curl_header in parsed_args.header:
if curl_header.startswith(':'):
occurrence = [m.start() for m in re.finditer(':', curl_header)]
header_key, header_value = curl_header[:occurrence[
1]], curl_header[occurrence[1] + 1:]
else:
header_key, header_value = curl_header.split(":", 1)
if header_key.lower().strip("$") == 'cookie':
cookie = Cookie.SimpleCookie(header_value)
for key in cookie:
cookie_dict[key] = cookie[key].value
else:
quoted_headers[header_key] = header_value.strip()
# add auth
user = parsed_args.user
if parsed_args.user:
user = tuple(user.split(':'))
return ParsedContext(method=method,
url=parsed_args.url,
data=post_data,
headers=quoted_headers,
cookies=cookie_dict,
verify=parsed_args.insecure,
auth=user)
def parse_cmd(curl_command):
"""
解析curl的参数并映射到parsed_content的tuple中
:param: curl_command: 以curl 开头的命令
:return: <nametuple> 分割后的结果tuple
"""
method = "get"
tokens = shlex.split(curl_command)
parsed_args = parser.parse_args(tokens)
post_data = parsed_args.data or parsed_args.data_binary
if post_data:
method = 'post'
if parsed_args.X:
method = parsed_args.X.lower()
cookie_dict = OrderedDict()
quoted_headers = OrderedDict()
# 解析parsed_args.header
for curl_header in parsed_args.header:
if curl_header.startswith(':'):
occurrence = [m.start() for m in re.finditer(':', curl_header)]
header_key, header_value = curl_header[:occurrence[
1]], curl_header[occurrence[1] + 1:]
else:
header_key, header_value = curl_header.split(":", 1)
if header_key.lower().strip("$") == 'cookie':
cookie = Cookie.SimpleCookie(header_value)
for key in cookie:
cookie_dict[key] = cookie[key].value
else:
quoted_headers[header_key] = header_value.strip()
# result nametuple
return parsed_content(method=method,
url=parsed_args.url,
data=post_data,
headers=quoted_headers,
cookies=cookie_dict,
verify=parsed_args.insecure)
def fetch_token(path, headers):
parse = urlparse.urlparse(path, scheme='ws')
if parse.scheme not in ('http', 'https', 'ws'):
# From a bug in urlparse in Python < 2.7.4 we cannot support
# special schemes (cf: http://bugs.python.org/issue9374)
if sys.version_info < (2, 7, 4):
raise exceptions.WebSocketError("We do not support scheme '%s' under "
"Python < 2.7.4, please use http or https" % parse.scheme)
query = parse.query
token = urlparse.parse_qs(query).get("token", [""]).pop()
if not token:
hcookie = headers.getheader('cookie')
if hcookie:
cookie = Cookie.SimpleCookie()
cookie.load(hcookie)
if 'token' in cookie:
token = cookie['token'].value
return token
def __init__(self, iterable, status, headers):
self._text = None
self._content = b''.join(iterable)
if hasattr(iterable, 'close'):
iterable.close()
self._status = status
self._status_code = int(status[:3])
self._headers = CaseInsensitiveDict(headers)
cookies = http_cookies.SimpleCookie()
for name, value in headers:
if name.lower() == 'set-cookie':
cookies.load(value)
self._cookies = dict(
(morsel.key, Cookie(morsel)) for morsel in cookies.values())
self._encoding = helpers.get_encoding_from_headers(self._headers)
def parse(self, headers):
"""
Parse HTTP header for cookie. If cookie is found, return cookie ID,
else return None.
"""
self.log.debug("Parsing cookie from {headers}", headers=headers)
# see if there already is a cookie set ..
if 'cookie' in headers:
try:
cookie = http_cookies.SimpleCookie()
cookie.load(str(headers['cookie']))
except http_cookies.CookieError:
pass
else:
if self._cookie_id_field in cookie:
cbtid = cookie[self._cookie_id_field].value
if cbtid in self._cookies:
return cbtid
return None
def parse_cookie(cookie, final_url):
if cookie == '':
return {}
if not isinstance(cookie, Cookie.BaseCookie):
try:
c = Cookie.SimpleCookie()
c.load(cookie)
except Cookie.CookieError:
# Invalid cookie
return {}
else:
c = cookie
cookiedict = {}
for key in c.keys():
cook = c.get(key)
cookiedict[key] = cook.value
return cookiedict
