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_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_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 _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 getCookies(self, response):
cookies = {}
for value in response.headers.get_all("Set-Cookie"):
cookies.update(parse_cookie(value))
return cookies
def get_cookies(rv):
cookies = {}
for value in rv.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 cookies(self):
"""The retreived cookie values as regular dictionary."""
return parse_cookie(self.environ, self.charset)
