def __call__(self, environ, start_response): cookie = parse_cookie(environ) user_cookie = cookie.get(self.cookie_name, None) usersession = UserSession(self.userbase) usersession.set_cookie_value(user_cookie) environ[self.environ_key + ".session"] = usersession environ[self.environ_key + ".userbase"] = self.userbase def injecting_start_response(status, headers, exc_info=None): cookie_value = usersession.get_cookie_value() cookie_str = dump_cookie( self.cookie_name, cookie_value if cookie_value is not None else "", self.cookie_age, None if cookie_value is not None else datetime.datetime.now() - datetime.timedelta(days=1), self.cookie_path, self.cookie_domain, self.cookie_secure, self.cookie_httponly) headers.append(('Set-Cookie', cookie_str)) self.userbase.store_changes() return start_response(status, headers, exc_info) return self.app(environ, injecting_start_response)
def __call__(self, environ, start_response): cookie = parse_cookie(environ.get('HTTP_COOKIE', '')) sid = cookie.get(self.cookie_name, None) if sid is None: session = self.store.new() else: session = self.store.get(sid) environ[self.environ_key] = session def injecting_start_response(status, headers, exc_info=None): if session.should_save: age = session.get('_sheep_permstore', self.cookie_age) try: age = int(age) except: age = self.cookie_age self.store.save(session) headers.append(('Set-Cookie', dump_cookie(self.cookie_name, session.sid, age, self.cookie_expires, self.cookie_path, self.cookie_domain, self.cookie_secure, self.cookie_httponly))) return start_response(status, headers, exc_info) return ClosingIterator(self.app(environ, injecting_start_response), lambda: self.store.save_if_modified(session))
def __call__(self, environ, start_response): cookie = parse_cookie(environ.get("HTTP_COOKIE", "")) sid = cookie.get(self.cookie_name, None) if sid is None: session = self.store.new() else: session = self.store.get(sid) environ[self.environ_key] = session def injecting_start_response(status, headers, exc_info=None): if session.should_save: self.store.save(session) headers.append( ( "Set-Cookie", dump_cookie( self.cookie_name, session.sid, self.cookie_age, self.cookie_expires, self.cookie_path, self.cookie_domain, self.cookie_secure, self.cookie_httponly, ), ) ) return start_response(status, headers, exc_info) return ClosingIterator( self.app(environ, injecting_start_response), lambda: self.store.save_if_modified(session) )
def __call__(self, environ, start_response): cookie = parse_cookie(environ.get('HTTP_COOKIE', '')) sid = cookie.get(self.cookie_name, None) if sid is None: session = self.store.new() else: session = self.store.get(sid) environ[self.environ_key] = session def injecting_start_response(status, headers, exc_info=None): if session.should_save: self.store.save(session) headers.append(('Set-Cookie', dump_cookie(self.cookie_name, session.sid, self.cookie_age, self.cookie_expires, self.cookie_path, self.cookie_domain, self.cookie_secure, self.cookie_httponly, samesite=self.cookie_samesite))) return start_response(status, headers, exc_info) return ClosingIterator(self.app(environ, injecting_start_response), lambda: self.store.save_if_modified(session))
def __call__(self, environ, start_response): session_store = locate(settings.SESSION_STORE) if not session_store or not issubclass(session_store, SessionStore): raise ValueError( 'SESSION_STORE must be a sub class of \'SessionStore\'' ) session_store = session_store() auth_collection = locate(settings.AUTH_COLLECTION) if not auth_collection or not issubclass(auth_collection, Collection): raise ValueError( 'AUTH_COLLECTION must be a sub class of \'Collection\'' ) environ['session'] = session_store.new() session_id = environ.get('HTTP_AUTHORIZATION', '') if len(session_id.split('Token ')) == 2: session_id = session_id.split('Token ')[1] environ['session'] = session_store.get(session_id) else: cookies = environ.get('HTTP_COOKIE') if cookies: session_id = parse_cookie(cookies).get('session_id') if session_id: environ['session'] = session_store.get(session_id) environ[auth_collection.__name__.lower()] = auth_collection.get({ '_id': deserialize( environ['session'].get(auth_collection.__name__.lower(), '""') ) }) def authentication(status, headers, exc_info=None): headers.extend([ ( 'Set-Cookie', dump_cookie( 'session_id', environ['session'].sid, 7 * 24 * 60 * 60, ) ), ( 'HTTP_AUTHORIZATION', 'Token {0}'.format( environ['session'].sid ) ), ]) return start_response(status, headers, exc_info) response = self.app(environ, authentication) if environ['session'].should_save: session_store.save(environ['session']) return response
def get_session_from_env(environ): global gSessionStore cookie = parse_cookie(environ) session_id = None ret = None if 'session_id' in cookie: session_id = cookie['session_id'] ret = gSessionStore.get(session_id) return ret
def __call__(self, environ, start_response): session_store = locate(settings.SESSION_STORE) if not session_store or not issubclass(session_store, SessionStore): raise ValueError( 'SESSION_STORE must be a sub class of \'SessionStore\'') session_store = session_store() auth_collection = locate(settings.AUTH_COLLECTION) if not auth_collection or not issubclass(auth_collection, Collection): raise ValueError( 'AUTH_COLLECTION must be a sub class of \'Collection\'') environ['session'] = session_store.new() session_id = environ.get('HTTP_AUTHORIZATION', '') if len(session_id.split('Token ')) == 2: session_id = session_id.split('Token ')[1] environ['session'] = session_store.get(session_id) else: cookies = environ.get('HTTP_COOKIE') if cookies: session_id = parse_cookie(cookies).get('session_id') if session_id: environ['session'] = session_store.get(session_id) environ[auth_collection.__name__.lower()] = auth_collection.get({ '_id': deserialize(environ['session'].get( auth_collection.__name__.lower(), '""')) }) def authentication(status, headers, exc_info=None): if environ.get(auth_collection.__name__.lower()): headers.extend([ ('Set-Cookie', dump_cookie( 'session_id', environ['session'].sid, 30 * 24 * 60 * 60, )), ('HTTP_AUTHORIZATION', 'Token {0}'.format(environ['session'].sid)), ]) return start_response(status, headers, exc_info) response = self.app(environ, authentication) if environ['session'].should_save: session_store.save(environ['session']) return response
def get_cookies(self, response): """Parse cookies from Flask Response. :param response: :return: dict with cookie values """ cookies = {} for value in response.headers.get_all('Set-Cookie'): cookies.update(parse_cookie(value)) return cookies
def _get_cookies(headers): """ Convert a list of headers into all the cookies set """ result = {} for cookie_str in headers.getlist('Set-Cookie'): cookie = parse_cookie(cookie_str) result.update(cookie) # cookies are k => val dicts return result
def get_userinfo_from_env(environ): global gConfig, gLoginToken cookie = parse_cookie(environ) session_id = None ret = None if 'session_id' in cookie: session_id = cookie['session_id'] if session_id in gLoginToken: ret = gLoginToken[session_id] return session_id, ret
def get_pwd_cookie(short_name, res): cookie = (None, None, None) raw_cookie = None cookies = res.headers.get_all('Set-Cookie') for c in cookies: for k, v in parse_cookie(c).iteritems(): if k == u'%spswd' % short_name: cookie = k, v raw_cookie = c params = (v.strip().split('=') for v in raw_cookie.split(';')) expires = dict(params)['Expires'] expires = datetime.strptime(expires, '%a, %d-%b-%Y %H:%M:%S GMT') return cookie[0], cookie[1], expires
def test_wrapper_support(self): req = Request.from_values() resp = Response() c = SecureCookie.load_cookie(req, secret_key='foo') assert c.new c['foo'] = 42 assert c.secret_key == 'foo' c.save_cookie(resp) req = Request.from_values(headers={ 'Cookie': 'session="%s"' % parse_cookie(resp.headers['set-cookie'])['session'] }) c2 = SecureCookie.load_cookie(req, secret_key='foo') assert not c2.new assert c2 == c
def test_wrapper_support(self): req = Request.from_values() resp = Response() c = SecureCookie.load_cookie(req, secret_key="foo") assert c.new c["foo"] = 42 assert c.secret_key == "foo" c.save_cookie(resp) req = Request.from_values( headers={"Cookie": 'session="%s"' % parse_cookie(resp.headers["set-cookie"])["session"]} ) c2 = SecureCookie.load_cookie(req, secret_key="foo") assert not c2.new assert c2 == c
def test_wrapper_support(self): req = Request.from_values() resp = Response() c = EncryptedCookie.load_cookie(req, crypter_or_keys_location=KEYS_DIR) assert c.new c['foo'] = 42 assert c.crypter is not None c.save_cookie(resp) req = Request.from_values(headers={ 'Cookie': 'session="%s"' % parse_cookie(resp.headers['set-cookie'])['session'] }) c2 = EncryptedCookie.load_cookie(req, crypter_or_keys_location=KEYS_DIR) assert not c2.new assert c2 == c
def test_wrapper_support(): req = Request.from_values() resp = Response() c = SecureCookie.load_cookie(req, secret_key=b'foo') assert c.new c['foo'] = 42 assert c.secret_key == b'foo' c.save_cookie(resp) req = Request.from_values(headers={ 'Cookie': 'session="%s"' % parse_cookie(resp.headers['set-cookie'])['session'] }) c2 = SecureCookie.load_cookie(req, secret_key=b'foo') assert not c2.new assert c2 == c
def test_wrapper_support(): req = Request.from_values() resp = Response() c = SecureCookie.load_cookie(req, secret_key=b"foo") assert c.new c["foo"] = 42 assert c.secret_key == b"foo" c.save_cookie(resp) req = Request.from_values( headers={ "Cookie": 'session="%s"' % parse_cookie(resp.headers["set-cookie"])["session"] }) c2 = SecureCookie.load_cookie(req, secret_key=b"foo") assert not c2.new assert c2 == c
def api(self, request, args): cookies = parse_cookie(request.environ) if not "key" in cookies or not cookies["key"] == password: return Response("fail") func = args["func"] if func == "rgb": if not "args" in args: return NotFound() parts = args["args"].split(":") print parts try: arduino.client.rgb(*parts) except Exception as e: print e return NotFound() return Response("")
def _get_auth_cookies(): # Login with the user specified to get the reports with app.test_request_context(): user = security_manager.find_user(config.get('EMAIL_REPORTS_USER')) login_user(user) # A mock response object to get the cookie information from response = Response() app.session_interface.save_session(app, session, response) cookies = [] # Set the cookies in the driver for name, value in response.headers: if name.lower() == 'set-cookie': cookie = parse_cookie(value) cookies.append(cookie['session']) return cookies
def getCookies(self, response): cookies = {} for value in response.headers.get_all("Set-Cookie"): cookies.update(parse_cookie(value)) return cookies
def cookies(self): return parse_cookie(self.environ, self.charset, cls=self.dict_storage_class)
def get_cookies(rv): cookies = {} for value in rv.headers.get_all("Set-Cookie"): cookies.update(parse_cookie(value)) return cookies
def cookies(self): """The retreived cookie values as regular dictionary.""" return parse_cookie(self.environ, self.charset)