class CookieHandler(object): def __init__(self, *args, **kw): # Somewhere to store cookies between consecutive requests self.cookies = SimpleCookie() super(CookieHandler, self).__init__(*args, **kw) def httpCookie(self, path): """Return self.cookies as an HTTP_COOKIE environment value.""" l = [m.OutputString().split(';')[0] for m in self.cookies.values() if path.startswith(m['path'])] return '; '.join(l) def loadCookies(self, envstring): self.cookies.load(envstring) def saveCookies(self, response): """Save cookies from the response.""" # Urgh - need to play with the response's privates to extract # cookies that have been set # TODO: extend the IHTTPRequest interface to allow access to all # cookies # TODO: handle cookie expirations for k, v in response._cookies.items(): k = k.encode('utf8') self.cookies[k] = v['value'].encode('utf8') if 'path' in v: self.cookies[k]['path'] = v['path']
def request_started_handler(sender, environ, **kwargs): if 'HTTP_COOKIE' not in environ: return cookie = SimpleCookie() cookie.load(environ['HTTP_COOKIE']) user = None if 'sessionid' in cookie: session_id = cookie['sessionid'].value try: session = Session.objects.get(session_key=session_id) except Session.DoesNotExist: session = None if session: user_id = session.get_decoded()['_auth_user_id'] try: user = get_user_model().objects.get(id=user_id) except: user = None if user is None and WRITE_EVENTS_ONLY_LOGGED_IN_USERS: return request_event = RequestEvent.objects.create( uri=environ['PATH_INFO'], type=environ['REQUEST_METHOD'], query_string=environ['QUERY_STRING'], user=user, remote_ip=environ['REMOTE_ADDR'], datetime=timezone.now() ) request_event.save()
class BaseHeaders(CaseInsensitiveMapping): """Represent the headers in an HTTP Request or Response message. """ def __init__(self, raw): """Takes headers as a string. """ def genheaders(): for line in raw.splitlines(): k, v = line.split(':', 1) yield k.strip(), v.strip() CaseInsensitiveMapping.__init__(self, genheaders) # Cookie # ====== self.cookie = SimpleCookie() try: self.cookie.load(self.get('Cookie', '')) except CookieError: pass # XXX really? def raw(self): """Return the headers as a string, formatted for an HTTP message. """ out = [] for header, values in self.iteritems(): for value in values: out.append('%s: %s' % (header, value)) return '\r\n'.join(out) raw = property(raw)
def setup(self, environ): for p in environ: if len(p) > 5 and 'HTTP_' in p: hk = p.replace('HTTP_', '') self.headers[hk] = environ[p] self.environ = environ cookie = SimpleCookie() name = nfw.utils.if_unicode_to_utf8('neutrino') if 'HTTP_COOKIE' in self.environ: cookie.load(self.environ['HTTP_COOKIE']) if name in cookie: id = nfw.utils.if_unicode_to_utf8(cookie[name].value) else: id = nfw.utils.if_unicode_to_utf8(nfw.random_id(16)) self._id = nfw.utils.if_unicode_to_utf8(id) self._name = "session:%s" % (id, ) cookie[name] = nfw.utils.if_unicode_to_utf8(id) host = self._get_host(environ) if host is not None: cookie[name]['domain'] = host cookie[name]['max-age'] = self._expire cookie_string = cookie[name].OutputString() if hasattr(self, '_load'): self._load() return cookie_string
def get_cookie_dict(environ): """Return a *plain* dictionary of cookies as found in the request. Unlike ``get_cookies`` this returns a dictionary, not a ``SimpleCookie`` object. For incoming cookies a dictionary fully represents the information. Like ``get_cookies`` this caches and checks the cache. """ header = environ.get('HTTP_COOKIE') if not header: return {} if environ.has_key('paste.cookies.dict'): cookies, check_header = environ['paste.cookies.dict'] if check_header == header: return cookies cookies = SimpleCookie() try: cookies.load(header) except CookieError: pass result = {} for name in cookies: result[name] = cookies[name].value environ['paste.cookies.dict'] = (result, header) return result
def username(cookie, name=None): """ try to extract username from PAS cookie """ if cookie is not None: cookies = SimpleCookie() try: cookies.load(cookie) except CookieError: return name if cookie_name in cookies: # Deal with doubly quoted cookies ac_cookie = repeatedly_unquote(cookies[cookie_name].value) try: ac = decodestring(ac_cookie + '=====') except (TypeError, binascii.Error): return name # plone.session 3.x (Plone 4.x) if '!' in ac[40:]: name, user_data = ac[40:].split('!', 1) # plone.session 2.x (Plone 3.x) elif ' ' in ac[20:21]: name = ac[21:] # PluggableAuthService.CookieAuthHelper elif ':' in ac: user, pwd = ac.split(':', 1) # PluggableAuthService >= 1.5 try: name = user.decode('hex') # PluggableAuthService < 1.5 except TypeError: name = user return name
def is_present(mpkt): hdrs = mpkt.cfields.get('dissector.http.headers', None) if not hdrs: return False if 'cookie' in hdrs: for cstr in hdrs['cookie']: cookie = SimpleCookie() cookie.load(cstr) for k, mar in cookie.items(): cookies[k].append(mar.value) return True elif 'set-cookie' in hdrs: for cstr in hdrs['set-cookie']: cookie = SimpleCookie() cookie.load(cstr) for k, mar in cookie.items(): cookies[k].append(mar.value) return True return False
def get_cookie_value(environ, name): c = SimpleCookie() c.load(environ.get('HTTP_COOKIE', '')) try: return c[name].value except: return ""
class cookie: def __init__( self ): self.cookieObj = SimpleCookie() self.load() def load( self ): if not os.environ.has_key("HTTP_COOKIE"): # Kein Cookie vorhanden return self.cookieObj.load( os.environ["HTTP_COOKIE"] ) def readCookie( self, CookieName ): if self.cookieObj == False: # Gibt kein Cookie return False if self.cookieObj.has_key(CookieName): return self.cookieObj[CookieName].value else: return False def debug( self ): print "Cookie-Debug:" print "<hr><pre>" if not os.environ.has_key("HTTP_COOKIE"): print "There is no HTTP_COOKIE in os.environ:\n" for k,v in os.environ.iteritems(): print k,v else: print self.cookieObj print "</pre><hr>"
def getSessionId(request_cookie): cookie = SimpleCookie() cookie.load(request_cookie) try: sessionId = int((cookie['id']).value) except CookieError, ValueError: sessionId = sessions.AddNewSession({'num' : 0, 'auth' : False})
def determineKey(handler): hdr = handler.headers.getheader('Cookie') if not hdr: return Session.generateKey() c = SimpleCookie() c.load(hdr) return c['session'].value if c.has_key( 'session') else Session.generateKey()
def get_cookie(self, name): cookie_str = self.request.headers.get('cookie') if not cookie_str: return None cookie = SimpleCookie() cookie.load(cookie_str) return cookie[name].value;
def parseStrToCookies(self, cookieStr): SC = SimpleCookie() SC.load(cookieStr) cookies = {} for key, morsel in SC.items(): cookies[key] = morsel.value return cookies
def __get_params(self): self._kwargs = self.__get_query_params() self._cog_ajax = self._kwargs.get('cog_ajax') self.__cog_target = self._kwargs.get('cog_target') self._cog_raw = self._kwargs.get('cog_raw', None) self._cog_method = self._kwargs.get('cog_method', None) # cog_method must not contain non-word caracters assert self._cog_method is None or \ re.search('\W', self._cog_method) is None if self._cog_method is not None and self._cog_method[0] == '_': # we never should receive a protected method... self._cog_method = "w3error" self._kwargs['cog_method'] = "w3error" self._kwargs['cog_error'] = "Can't call a protected method!" self._cog_ref_oid = self._kwargs.get('cog_ref_oid', None) self._cog_oid_ = self._kwargs.get('cog_oid_', None) self._session_key = None if 'HTTP_COOKIE' in self._environ: cookie_string = self._environ.get('HTTP_COOKIE') cookie = SimpleCookie() cookie.load(cookie_string) if 'cog_session' in cookie: self._session_key = cookie['cog_session'].value self.__cog_environment = self.__get_env() self._cog_fqtn_ = self._kwargs.get('cog_fqtn_', None) if self._cog_ref_oid and self._cog_ref_oid == self._cog_oid_: self._cog_oid_ = None self._kwargs['cog_controller'] = self self._kwargs['cog_first_call'] = True
class CookieScraper(object): "Scraper that keeps track of getting and setting cookies." def __init__(self): self._cookies = SimpleCookie() def get_page(self, url, post_data=None, headers=()): """ Helper method that gets the given URL, handling the sending and storing of cookies. Returns the requested page as a string. """ socket.timeout(300) opener = urllib.URLopener() opener.addheader('Cookie', self._cookies.output(attrs=[], header='', sep=';').strip()) for k, v in headers: opener.addheader(k, v) try: f = opener.open(url, post_data) except IOError, e: if e[1] == 302: # Got a 302 redirect, but check for cookies before redirecting. # e[3] is a httplib.HTTPMessage instance. if e[3].dict.has_key('set-cookie'): self._cookies.load(e[3].dict['set-cookie']) return self.get_page(e[3].getheader('location')) else: raise if f.headers.dict.has_key('set-cookie'): self._cookies.load(f.headers.dict['set-cookie']) return f.read()
class CookieHandler(object): def __init__(self, *args, **kw): # Somewhere to store cookies between consecutive requests self.cookies = SimpleCookie() super(CookieHandler, self).__init__(*args, **kw) def httpCookie(self, path): """Return self.cookies as an HTTP_COOKIE environment value.""" l = [m.OutputString() for m in self.cookies.values() if path.startswith(m['path'])] return '; '.join(l) def loadCookies(self, envstring): self.cookies.load(envstring) def saveCookies(self, response): """Save cookies from the response.""" # Urgh - need to play with the response's privates to extract # cookies that have been set for k,v in response._cookies.items(): k = k.encode('utf8') self.cookies[k] = v['value'].encode('utf8') if self.cookies[k].has_key('Path'): self.cookies[k]['Path'] = v['Path']
def process_request(self, context, start_response): _cookie = SimpleCookie() if 'HTTP_COOKIE' in context: _cookie.load(context['HTTP_COOKIE']) _protocol = str(context.get('SERVER_PROTOCOL', 'HTTP/1.1')) if _protocol.startswith('HTTPS'): _is_secure = True else: _is_secure = False session_id = None if self.SESSION_KEY in _cookie: session_id = _cookie[self.SESSION_KEY].value if not session_id: session_id = str(uuid.UUID(bytes=OpenSSL.rand.bytes(16))) push_environ_args(context, self.SESSION_LOCAL_NAME, session_id) def _start_response(status, response_headers, exc_info=None): cookie = SimpleCookie() cookie[self.SESSION_KEY] = session_id cookie[self.SESSION_KEY]['path'] = '/' if _is_secure: cookie[self.SESSION_KEY]['http'] = True cookie[self.SESSION_KEY]['secure'] = True cookie_string = cookie[self.SESSION_KEY].OutputString() response_headers.append(('Set-Cookie', cookie_string)) return start_response(status, response_headers, exc_info) return super(SessionMiddleware, self).process_request(context, _start_response)
class Headers(BaseHeaders): """Model headers in an HTTP Request message. """ def __init__(self, raw): """Extend BaseHeaders to add extra attributes. """ BaseHeaders.__init__(self, raw) # Cookie # ====== self.cookie = SimpleCookie() try: self.cookie.load(self.get('Cookie', '')) except CookieError: pass # XXX really? # Host # ==== # Per the spec, respond with 400 if no Host header is given. However, # we prefer X-Forwarded-For if that is available. host = self.get('X-Forwarded-Host', self['Host']) # KeyError raises 400 self.host = UnicodeWithRaw(host, encoding='idna') # Scheme # ====== # http://docs.python.org/library/wsgiref.html#wsgiref.util.guess_scheme scheme = 'https' if self.get('HTTPS', False) else 'http' self.scheme = UnicodeWithRaw(scheme)
class CookieScraper(object): "Scraper that keeps track of getting and setting cookies." def __init__(self): self._cookies = SimpleCookie() def get_page(self, url, post_data=None, headers=()): """ Helper method that gets the given URL, handling the sending and storing of cookies. Returns the requested page as a string. """ opener = urllib.URLopener() opener.addheader('Cookie', self._cookies.output(attrs=[], header='').strip()) for k, v in headers: opener.addheader(k, v) try: f = opener.open(url, post_data) except IOError, e: if e[1] == 302: # Got a 302 redirect, but check for cookies before redirecting. # e[3] is a httplib.HTTPMessage instance. if e[3].dict.has_key('set-cookie'): self._cookies.load(e[3].dict['set-cookie']) return self.get_page(e[3].getheader('location')) else: raise if f.headers.dict.has_key('set-cookie'): self._cookies.load(f.headers.dict['set-cookie']) return f.read()
def get_cookies(str): cookie = SimpleCookie() cookie.load(str) cookies = {} for key, morsel in cookie.items(): cookies[key] = morsel.value return cookies
def cookies(self, rawdata): """Set Response Cookies. :param rawdata: (str or dict). List of `cookielib.Cookie`. """ sc = SimpleCookie() sc.load(rawdata) self._cookies = sc.items()
def cookies(self): from Cookie import SimpleCookie cookie = SimpleCookie() cookie.load(self.environ.get('HTTP_COOKIE', '')) result = {} for key, value in cookie.iteritems(): result[key] = value return result
def test_cookie_credentials_plaintext(self): fetch_arguments = build_fetch_arguments("/foobar") credentials = CookieCredentials("auth", "token") credentials(fetch_arguments) cookie = SimpleCookie() cookie.load(fetch_arguments.headers["Cookie"]) self.assertTrue("auth" in cookie) self.assertEqual("token", cookie["auth"].value)
def __call__(self, environ, start_response): sc = SimpleCookie() if 'HTTP_COOKIE' in environ: sc.load(environ.get('HTTP_COOKIE')) ses = Session(ExpressSession(sc)) ses.read() environ['express.session'] = ses return self.app(environ, start_response)
def cookies(self): """Stored Cookies.""" cookie = SimpleCookie() cookie.load(self.environ.get('HTTP_COOKIE', '')) result = {} for key, value in cookie.iteritems(): result[key] = value.value.decode(self.charset, 'ignore') return result
def load_username(cookie): c = SimpleCookie() c.load(cookie) try: return c["username"].value except: return ""
def cookies(self, name=None): """ add method to get Cookie """ cookies = self.environ.get('HTTP_COOKIE', '') c*k = SimpleCookie() try: c*k.load(cookies) except CookieError, msg: return c*k
def get_cookie(self, key): in_cookies = SimpleCookie() request_cookies = self.headers.get('Cookie') if request_cookies: in_cookies.load(request_cookies) val = in_cookies.get(key) return val.value if val else None return None
def _parse_cookies(cookies): if not cookies: return {} cookie = SimpleCookie() cookie.load(cookies) return {key: cookie[key].coded_value for key in cookie.keys()}
def parse_cookies(environ): #transform the cookie environment into a SimpleCokkie object line = environ.get('HTTP_COOKIE', None) if line: cook = SimpleCookie() cook.load(line) return cook else: return None
def parse_cookie(cookie): if cookie == '': return {} c = SimpleCookie() c.load(cookie) cookiedict = {} for key in c.keys(): cookiedict[key] = c.get(key).value return cookiedict
def _get_cookies(self, response): c = SimpleCookie() for h, v in response.getheaders(): if h == 'set-cookie': c.load(v) for cookie in c.itervalues(): domain = cookie['domain'].rstrip(',').lstrip('.') or response.host self.cookies[domain][cookie.key] = cookie
def load(self, rawdata, ignore_parse_errors=False): if ignore_parse_errors: self.bad_cookies = [] self._BaseCookie__set = self._loose_set SimpleCookie.load(self, rawdata) if ignore_parse_errors: self._BaseCookie__set = self._strict_set for key in self.bad_cookies: del self[key]
def session_cookie(self): cookie = SimpleCookie() if "HTTP_COOKIE" in environ: cookie.load(environ["HTTP_COOKIE"]) if self.COOKIE_NAME not in cookie: cookie[self.COOKIE_NAME] = uuid4().hex return cookie
def _make_cookie(cookie_headers): def _add_dash(match_obj): return match_obj.group(0).replace(' ', '-') cookie = SimpleCookie() set_cookie_str = re.sub(r'\d{2}\s\w+\s\d{4}', _add_dash, cookie_headers) cookie.load(set_cookie_str) return cookie
def login(): confdir = findconffolder() conf = ConfigParser.ConfigParser() conf.read(join(confdir, "config")) # make the url and credentials url = join(conf.get("resources", "url"), "authenticate/login") username = raw_input("Username: "******"Password: "******"username": username, "password": password}) parsed_url = urlparse(url) host = parsed_url.netloc if parsed_url.scheme == "https": conn = httplib.HTTPSConnection(host) else: conn = httplib.HTTPConnection(host) response = conn.request("POST", parsed_url.path, creds, {"Content-type": "application/x-www-form-urlencoded"}) response = conn.getresponse() if response.status > 400: raise LoginError( "Login to %s failed with the following message: %s %s (%s)" % (url, response.status, response.reason, response.msg) ) response.read() setcookie = response.getheader("Set-Cookie") if setcookie == None: raise LoginError( "Login failed. This is usually because of " "invalid username/password, but might be " "caused by wrong login urlprefix or server errors. " "Technical error message: Login urlprefix did not " "respond with any authorization cookies." ) cookie = SimpleCookie() cookie.load(setcookie) cookieout = cookie.output().replace("Set-Cookie: ", "") session = open(join(confdir, "session"), "w") session.write(cookieout) session.close() chmod(join(confdir, "session"), stat.S_IRUSR | stat.S_IWUSR) conf.set("resources", "user", username) with open(join(confdir, "config"), "wb") as f: conf.write(f) return cookieout
def _parse_cookies(self): cookies = {} cookie_data = self.environ.get('HTTP_COOKIE', '') if cookie_data: _parsed = SimpleCookie() _parsed.load(cookie_data) for name in _parsed: cookies[name] = _parsed[name].value self._request_cookies = cookies self._cookies_parsed = 1
def clear_username(cookie): c = SimpleCookie() c.load(cookie) expires = datetime.datetime(2000, 2, 14, 18, 30, 14) + datetime.timedelta(hours=1) c["username"]["expires"] = expires.strftime("%a, %d %b %Y %H:%M:%S") s = c.output() (key, value) = s.split(": ") return (key, value)
def _handle_cookies(self, response): # type: (httplib.HTTPResponse) -> None """ Parse cookies from |HTTP| response and store for next request. :param httplib.HTTPResponse: The |HTTP| response. """ # FIXME: this cookie handling doesn't respect path, domain and expiry cookies = SimpleCookie() cookies.load(response.getheader('set-cookie', '')) self.cookies.update(dict((cookie.key, cookie.value) for cookie in cookies.values()))
def _get_cookie(self, request, name): cookie_str = request.environ.get('HTTP_COOKIE') if not cookie_str: return cookie = SimpleCookie() cookie.load(cookie_str) if name not in cookie: return value = cookie.get(name).value if value != 'unset_%s' % name: return json.loads(base64.b64decode(value))
def __retrieve_cookie_values(self, raw_string): cookies = {} cookie = SimpleCookie() cookie.load(raw_string) for key, morsel in cookie.items(): if any(name.lower() in key.lower() for name in Scanner.cookie_keys): cookies[key] = morsel.value return cookies
def getcookie(self, key, default=''): try: #load the cookies from the environ dict's HTTP_COOKIE c = SimpleCookie() c.load(self.environ['HTTP_COOKIE']) #return the value of the cookie return str(c[key].value) except KeyError: return default
def clear_username(cookie): c = SimpleCookie() c.load(cookie) expires = datetime.datetime(2000, 2, 14, 18, 30, 14) + datetime.timedelta(hours=1) c['username']['expires'] = expires.strftime('%a, %d %b %Y %H:%M:%S') s = c.output() (key, value) = s.split(': ') return (key, value)
def test_get_json(yahoo_response, cookies): response = yahoo_response('v2/groups/groupname/files/a/2?param1=c¶m2=4', {'result': 'returned data'}) yga = YahooGroupsAPI('groupname', cookies) json = yga.get_json('files', 'a', 2, param1='c', param2=4) request = response.calls[0].request request_cookies = SimpleCookie() request_cookies.load(request.headers['Cookie']) assert dict(cookies) == {k: v.value for k, v in request_cookies.items()} assert json == {'result': 'returned data'}