def party_make(self, environ, start_response): content_type = 'text/html' username = '' if 'HTTP_COOKIE' in environ: c = SimpleCookie(environ.get('HTTP_COOKIE', '')) if 'name1' in c: key = c.get('name1').value name1_key = key if key in usernames: username = str(usernames[key]) if username == '': username = "******" data = """\ <html><head><title>Create a Party - Drinkz - Alex Lockwood</title> <style type="text/css"> h1 {color:red;} p {color:black;} </style></head><body> <h1>Create a Party!</h1> <a href='/'>Return to Index</a><p> """ data += "<form action='party_make_submit'>Please input the following information:<br>" data += "Party title: <input type='text' name='title'><br>Date: <input type='text' name='date'><br>Time: <input type='text' name='time'><br>Address: <input type='text' name='address'><br>" data += "Enter up to three liquors you're bringing:<br>" data += "Brand: <input type='text' name='m1'>Liquor: <input type='text' name='l1'>Amount (ml): <input type=number name='a1' min='0' max='5000'>" data += "Brand: <input type='text' name='m2'>Liquor: <input type='text' name='l2'>Amount (ml): <input type=number name='a2' min='0' max='5000'>" data += "Brand: <input type='text' name='m3'>Liquor: <input type='text' name='l3'>Amount (ml): <input type=number name='a3' min='0' max='5000'>" data += "<input type='submit' value='CREATE PARTY!'><input name='user' type='hidden' value='%s'></form></p></body></html>"% username start_response('200 OK', list(html_headers)) return [data]
def __init__(self, environ, backend, ttl, cookie_name, fp_use_ip, log): self.handler = backend self.ttl = ttl self.cookie_name = cookie_name self.sid = None self.data = {} self.log = log self.clear_cookie = False self.session_start = False fingerprint = '%s%s%s' % (environ.get('HTTP_USER_AGENT'), environ.get('HTTP_ACCEPT_ENCODING'), environ.get('HTTP_ACCEPT_LANGUAGE')) if fp_use_ip: fingerprint += environ.get('REMOTE_ADDR') self.fingerprint = hashlib.sha1(fingerprint).hexdigest() if 'HTTP_COOKIE' in environ: cookie = SimpleCookie(environ['HTTP_COOKIE']) if cookie.get(self.cookie_name): cookie_sid = cookie[self.cookie_name].value if cookie_sid: self.sid = cookie_sid
def start(self, cookies, cookieopts=None): c = SimpleCookie(cookies) sid = c.get(self.cookiename) create = True if sid is not None: for m in self.get(sid.value): yield m if self.apiroutine.retvalue is not None: self.apiroutine.retvalue = (self.SessionHandle( self.apiroutine.retvalue, self.apiroutine), []) create = False if create: for m in self.create(): yield m sh = self.apiroutine.retvalue m = Morsel() m.key = self.cookiename m.value = sh.id m.coded_value = sh.id opts = {'path': '/', 'httponly': True} if cookieopts: opts.update(cookieopts) if not cookieopts['httponly']: del cookieopts['httponly'] m.update(opts) self.apiroutine.retvalue = (sh, [m])
def application(environ, start_response): GET = parse_qs(environ['QUERY_STRING']) path = environ['PATH_INFO'] cookies = SimpleCookie(environ.get('HTTP_COOKIE', '')) headers = {'Content-Type': 'text/html'} if path == '/': response = base%{'contenido': form} elif path == '/set': cookies['sessionId'] = store.add(GET.get('name', ['NULL McNULL',])[0]) response = base%{'contenido': '<div style="background-color:green;color:white">Cookie establecida</div>'} headers.update({'Set-Cookie': cookies['sessionId'].OutputString()}) else: cookie = cookies.get('sessionId',None) name = cookie and store.get(cookie.value, None) or None response = base%{'contenido': "<p>El valor de la sesión es: %s</p>"%name if name else 'Ninguno'} headers.update({'Content-Length': str(len(response))}) start_response( "200 OK", headers.items() ) return [response]
def status(self, environ, start_response): name1 = '' name1_key = '*empty*' if 'HTTP_COOKIE' in environ: c = SimpleCookie(environ.get('HTTP_COOKIE', '')) if 'name1' in c: key = c.get('name1').value name1 = usernames.get(key, '') name1_key = key data = """ <html> <body> Your username is """ data += name1 data += " and your key is " data += name1_key data += "<p><a href='/'>Home</a></body></html>" else: data = """ <html> <body> You're not Logged in.....<p> <a href='/'>Home</a> </body> </html> """ start_response('200 OK', list(html_headers)) return [data]
def getSession(self): """Return the existing session or a new session""" if self.session is not None: return self.session # Get value of cookie header that was sent cookie_str = self.headers.get('Cookie') if cookie_str: cookie_obj = SimpleCookie(cookie_str) sid_morsel = cookie_obj.get(self.SESSION_COOKIE_NAME, None) if sid_morsel is not None: sid = sid_morsel.value else: sid = None else: sid = None # If a session id was not set, create a new one if sid is None: # Pure pragmatism: Use function for nonce salt to generate session ID. sid = make_nonce_salt(16) session = None else: session = self.server.sessions.get(sid) # If no session exists for this session ID, create one if session is None: session = self.server.sessions[sid] = {} session['id'] = sid self.session = session return session
def cookie_parts(name, kaka): cookie_obj = SimpleCookie(kaka) morsel = cookie_obj.get(name) if morsel: return morsel.value.split("|") else: return None
def parse_cookie(name, seed, kaka): """Parses and verifies a cookie value :param seed: A seed used for the HMAC signature :param kaka: The cookie :return: A tuple consisting of (payload, timestamp) """ if not kaka: return None cookie_obj = SimpleCookie(kaka) morsel = cookie_obj.get(name) if morsel: parts = morsel.value.split("|") if len(parts) != 3: return None # verify the cookie signature sig = cookie_signature(seed, parts[0], parts[1]) if sig != parts[2]: raise Exception("Invalid cookie signature") try: return parts[0].strip(), parts[1] except KeyError: return None else: return None
def application(environ, start_response): GET = parse_qs(environ['QUERY_STRING']) path = environ['PATH_INFO'] cookies = SimpleCookie(environ.get('HTTP_COOKIE', '')) headers = {'Content-Type': 'text/html'} if path == '/': response = base % {'contenido': form} elif path == '/set': cookies['sessionId'] = store.add( GET.get('name', [ 'NULL McNULL', ])[0]) response = base % { 'contenido': '<div style="background-color:green;color:white">Cookie establecida</div>' } headers.update({'Set-Cookie': cookies['sessionId'].OutputString()}) else: cookie = cookies.get('sessionId', None) name = cookie and store.get(cookie.value, None) or None response = base % { 'contenido': "<p>El valor de la sesión es: %s</p>" % name if name else 'Ninguno' } headers.update({'Content-Length': str(len(response))}) start_response("200 OK", headers.items()) return [response]
def __call__(self, environ, start_response): cookie = SimpleCookie(environ.get('HTTP_COOKIE', '')) morsel = cookie.get(self.cookie_name, None) if morsel is None: session = self.store.new() else: session = self.store.get(morsel.value) environ[self.environ_key] = session def injecting_start_response(status, headers, exc_info=None): if session.should_save: morsel = Morsel() morsel.key = self.cookie_name morsel.coded_value = session.sid if self.cookie_age is not None: morsel['max-age'] = self.cookie_age morsel['expires'] = cookie_date(time() + self.cookie_age) if self.cookie_domain is not None: morsel['domain'] = self.cookie_domain if self.cookie_path is not None: morsel['path'] = self.cookie_path if self.cookie_secure is not None: morsel['secure'] = self.cookie_secure headers.append(tuple(str(morsel).split(':', 1))) return start_response(status, headers, exc_info) return ClosingIterator(self.app(environ, injecting_start_response), lambda: self.store.save_if_modified(session))
def parse_cookie(name, seed, kaka): """Parses and verifies a cookie value :param seed: A seed used for the HMAC signature :param kaka: The cookie :return: A tuple consisting of (payload, timestamp) """ if not kaka: return None cookie_obj = SimpleCookie(kaka) morsel = cookie_obj.get(name) if morsel: parts = morsel.value.split("|") if len(parts) != 3: return None # verify the cookie signature sig = cookie_signature(seed, parts[0], parts[1]) if sig != parts[2]: raise SAMLError("Invalid cookie signature") try: return parts[0].strip(), parts[1] except KeyError: return None else: return None
def start(self, cookies, cookieopts=None): c = SimpleCookie(cookies) sid = c.get(self.cookiename) create = True if sid is not None: for m in self.get(sid.value): yield m if self.apiroutine.retvalue is not None: self.apiroutine.retvalue = (self.SessionHandle(self.apiroutine.retvalue, self.apiroutine), []) create = False if create: for m in self.create(): yield m sh = self.apiroutine.retvalue m = Morsel() m.key = self.cookiename m.value = sh.id m.coded_value = sh.id opts = {"path": "/", "httponly": True} if cookieopts: opts.update(cookieopts) if not cookieopts["httponly"]: del cookieopts["httponly"] m.update(opts) self.apiroutine.retvalue = (sh, [m])
def parse_cookie(name, seed, kaka): """Parses and verifies a cookie value """ if not kaka: return None cookie_obj = SimpleCookie(kaka) morsel = cookie_obj.get(name) if morsel: parts = morsel.value.split("|") if len(parts) != 3: return None # verify the cookie signature #print >> sys.stderr, "COOKIE verify '%s' '%s' '%s'" % (seed, # parts[0], # parts[1]) sig = cookie_signature(seed, parts[0], parts[1]) #print >> sys.stderr, ">>", sig if sig != parts[2]: raise Exception("Invalid cookie signature") try: return parts[0].strip(), parts[1] except KeyError: return None else: return None
def getSession(self): """Return the existing session or a new session""" if self.session is not None: return self.session # Get value of cookie header that was sent cookie_str = self.headers.get('Cookie') if cookie_str: cookie_obj = SimpleCookie(cookie_str) sid_morsel = cookie_obj.get(self.SESSION_COOKIE_NAME, None) if sid_morsel is not None: sid = sid_morsel.value else: sid = None else: sid = None # If a session id was not set, create a new one if sid is None: sid = randomString(16, '0123456789abcdef') session = None else: session = self.server.sessions.get(sid) # If no session exists for this session ID, create one if session is None: session = self.server.sessions[sid] = {} session['id'] = sid self.session = session return session
async def start(self, cookies, cookieopts=None): """ Session start operation. First check among the cookies to find existed sessions; if there is not an existed session, create a new one. :param cookies: cookie header from the client :param cookieopts: extra options used when creating a new cookie :return: ``(session_handle, cookies)`` where session_handle is a SessionHandle object, and cookies is a list of created Set-Cookie headers (may be empty) """ c = SimpleCookie(cookies) sid = c.get(self.cookiename) create = True if sid is not None: sh = await self.get(sid.value) if sh is not None: return (self.SessionHandle(sh, self.apiroutine), []) if create: sh = await self.create() m = Morsel() m.key = self.cookiename m.value = sh.id m.coded_value = sh.id opts = {'path': '/', 'httponly': True} if cookieopts: opts.update(cookieopts) if not cookieopts['httponly']: del cookieopts['httponly'] m.update(opts) return (sh, [m])
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 getCookie2(cookie_name): cookiestr = doc().cookie c = SimpleCookie(str(cookiestr)) cs = c.get(cookie_name, None) print "getCookie2", cookiestr, "name", cookie_name, "val", cs if cs: return cs.value return None
def recv_make_party(self, environ, start_response): formdata = environ['QUERY_STRING'] results = urlparse.parse_qs(formdata) new_music = "" new_crash_spots = 0 new_DDs = 0 try: new_music = results['music'][0] new_crash_spots = results['crash_spots'][0] new_DDs = results['DD'][0] except KeyError: pass name1 = '' if 'HTTP_COOKIE' in environ: c = SimpleCookie(environ.get('HTTP_COOKIE', '')) if 'name1' in c: key = c.get('name1').value name1 = usernames.get(key, '') p = party.Party(name1, new_music, int(new_crash_spots), int(new_DDs)) db.add_party(p) content_type = 'text/html' data = """\ <html> <head> <title>Party</title> <style type='text/css'> h1 {color:red;} body { font-size: 14px; } </style> </head> <body> """ data += "Liquors:" data += "<p>" for item in results['liquors']: p.add_liquor(item[0:]) data += item[0:] data += "<p>" data += "Type of music: "+new_music data += '<p>' data += "Crash Spots: "+str(new_crash_spots) data += '<p>' data += "Desginated Drivers: "+str(new_DDs) data += """\ <p> <a href='./'>return to index</a> </body> </html> """ start_response('200 OK', list(html_headers)) return [data]
def readCookie(self, name): cookie_str = self.headers.get('Cookie') print 'cookie:', cookie_str if cookie_str: c = SimpleCookie(cookie_str) cookie_morsel = c.get(name, None) if cookie_morsel is not None: return cookie_morsel.value return None
def auth_wrapper(environ, start_response): cookie = SimpleCookie(environ.get('HTTP_COOKIE')) t = cookie.get(name) tkt = None if t: tkt = SignedCookie.parse(t.value) service = AuthService(tkt) environ['shotweb.authservice'] = service return app(environ, service.start_response_wrapper(start_response))
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__(self, item, cls): if len(self) == 0: c = SimpleCookie(app.request.get('HTTP_COOKIE', '')) # TODO Fix for GAE for key in c.keys(): self[key] = c.get(key).value return self
def authPloneUser(self, username, password, loginurl): http = httplib2.Http() headers = {} headers['Content-type'] = 'application/x-www-form-urlencoded' headers[ 'User-Agent'] = 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)' headers[LEOCORNUS_HTTP_HEADER_KEY] = LEOCORNUS_HTTP_HEADER_VALUE login_form = {} login_form['__ac_name'] = username login_form['__ac_password'] = password login_form['cookies_enabled'] = '1' login_form['js_enabled'] = '0' login_form['form.submitted'] = '1' body = urllib.urlencode(login_form) try: res, cont = http.request(loginurl, 'POST', headers=headers, body=body) except Exception: # not valid login url! return None if res.has_key('set-cookie'): cookie = SimpleCookie() cookie.load(res['set-cookie']) cookieName = settings.PLONEPROXY_COOKIE_NAME defaultCookieName = '__ac' if cookie.has_key(cookieName): cookieValue = cookie.get(cookieName).value return (cookieName, cookieValue) elif cookie.has_key(defaultCookieName): # try the default Plone cookie name in case. cookieValue = cookie.get(defaultCookieName).value return (defaultCookieName, cookieValue) # no valid cookie found! return None
def _loadSessionFromCookie(self, environ): """ Attempt to load the associated session using the identifier from the cookie. """ C = SimpleCookie(environ.get('HTTP_COOKIE')) morsel = C.get(self._cookieName, None) if morsel is not None: self._session = self._store.checkOutSession(morsel.value) self._expired = self._session is None
def delete_cookie(environ, name): kaka = environ.get("HTTP_COOKIE", "") if kaka: cookie_obj = SimpleCookie(kaka) morsel = cookie_obj.get(name, None) cookie = SimpleCookie() cookie[name] = morsel cookie[name]["expires"] = _expiration("now", "%a, %d-%b-%Y %H:%M:%S CET") return tuple(cookie.output().split(": ", 1)) return None
def _fromcookie(self, environ): '''Attempt to load the associated session using the identifier from the cookie. ''' cookie = SimpleCookie(environ.get('HTTP_COOKIE')) morsel = cookie.get(self._fieldname, None) if morsel is not None: self._sid, self.session = self._cache.checkout(morsel.value) self._csid = morsel.value if self._csid != self._sid: self.new = True
def kaka2user(kaka): logger.debug("KAKA: %s" % kaka) if kaka: cookie_obj = SimpleCookie(kaka) morsel = cookie_obj.get("idpauthn", None) if morsel: return IDP.authn[morsel.value] else: logger.debug() return None
def get_id(self, cookie_str=""): if cookie_str: #print "-connection by cookie-" cookie_obj = SimpleCookie(cookie_str) morsel = cookie_obj.get(self.name) if morsel is not None: self.sid = self.parse_cookie(morsel.value) if not self.sid: #print "-New connection-" self.sid = self._sid()
def get_id(self, cookie_str): """ :param cookie_str: :return: """ cookie_obj = SimpleCookie(cookie_str) morsel = cookie_obj.get(self.name) if morsel is not None: return self.parse_cookie(morsel.value) return None
def index(self, environ, start_response): data = open('index.html').read() start_response('200 OK', list(html_headers)) if 'HTTP_COOKIE' in environ: c = SimpleCookie(environ.get('HTTP_COOKIE', '')) if 'name1' in c: data += "<br><br> Logged in as: " + str(usernames.get(c.get('name1').value, "")) + "<br><br>" data += "<a href='logout'>Logout</a> " else: data +="<p><form action='login1_process'> Username: <input type='text' name='name' size='15'> <input type='submit' value='log in'> </form>" return [data]
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 delete_cookie(environ, name): kaka = environ.get("HTTP_COOKIE", '') if kaka: cookie_obj = SimpleCookie(kaka) morsel = cookie_obj.get(name, None) cookie = SimpleCookie() cookie[name] = morsel cookie[name]["expires"] = \ _expiration("now", "%a, %d-%b-%Y %H:%M:%S CET") return tuple(cookie.output().split(": ", 1)) return None
def authPloneUser(self, username, password, loginurl): http = httplib2.Http() headers = {} headers['Content-type'] = 'application/x-www-form-urlencoded' headers['User-Agent'] = 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)' headers[LEOCORNUS_HTTP_HEADER_KEY] = LEOCORNUS_HTTP_HEADER_VALUE login_form = {} login_form['__ac_name'] = username login_form['__ac_password'] = password login_form['cookies_enabled'] = '1' login_form['js_enabled'] = '0' login_form['form.submitted'] = '1' body = urllib.urlencode(login_form) try: res, cont = http.request(loginurl, 'POST', headers=headers, body=body) except Exception: # not valid login url! return None if res.has_key('set-cookie'): cookie = SimpleCookie() cookie.load(res['set-cookie']) cookieName = settings.PLONEPROXY_COOKIE_NAME defaultCookieName = '__ac' if cookie.has_key(cookieName): cookieValue = cookie.get(cookieName).value return (cookieName, cookieValue) elif cookie.has_key(defaultCookieName): # try the default Plone cookie name in case. cookieValue = cookie.get(defaultCookieName).value return (defaultCookieName, cookieValue) # no valid cookie found! return None
def delete_cookie(environ, name): kaka = environ.get("HTTP_COOKIE", '') if kaka: cookie_obj = SimpleCookie(kaka) morsel = cookie_obj.get(name, None) cookie = SimpleCookie() cookie[name] = "" cookie[name]['path'] = "/" logger.debug("Expire: %s" % morsel) cookie[name]["expires"] = _expiration("dawn") return tuple(cookie.output().split(": ", 1)) return None
def make_party(self, environ, start_response): name1 = '' name1_key = '*empty*' if 'HTTP_COOKIE' in environ: c = SimpleCookie(environ.get('HTTP_COOKIE', '')) if 'name1' in c: key = c.get('name1').value name1 = usernames.get(key, '') name1_key = key if name1 == '': headers = list(html_headers) headers.append(('Location', '/login_1')) start_response('302 Found', headers) return ["Redirect to login_1..."] content_type = 'text/html' data = """\ <html> <head> <title>Party</title> <style type='text/css'> h1 {color:red;} body { font-size: 14px; } </style> </head> <body> """ data += "Liquor at party:" data += "<p>" data += """\ <form action='recv_make_party'> """ for mfg, liquor in db.get_liquor_inventory(): data += "<input type='checkbox' name='liquors' value='"+mfg+' '+liquor+"'>"+liquor data += "<p>" data += """\ <p> Type of Music at Party: <input type='text' name='music' size='20'> Crash Spots: <input type='text' name='crash_spots' size='2'> Designated Drivers: <input type='text' name='DD' size='2'> <p> <input type='submit'> </form> <p> <a href='./'>return to index</a> """ start_response('200 OK', list(html_headers)) return [data]
def delete_cookie(environ, name): kaka = environ.get("HTTP_COOKIE", '') logger.debug("delete KAKA: %s" % kaka) if kaka: cookie_obj = SimpleCookie(kaka) morsel = cookie_obj.get(name, None) cookie = SimpleCookie() cookie[name] = "" cookie[name]['path'] = "/" logger.debug("Expire: %s" % morsel) cookie[name]["expires"] = _expiration("dawn") return tuple(cookie.output().split(": ", 1)) return None
def on_auth_token_responded(self, callback, resp): DEBUG(u'Auth token response code %s' % (resp.code, )) if resp.code == 200: headers = resp.headers if headers.hasHeader('Set-Cookie'): header = resp.headers.getRawHeaders('Set-Cookie') if header: header = '; '.join(header) cookie = SimpleCookie(header) login = cookie.get('Bugzilla_login') token = cookie.get('Bugzilla_logincookie') if not token or not login: self.fail(ValueError(u'Auth token not found')) else: self.auth_login = login.value self.auth_token = token.value DEBUG(u'Issuing on_auth_token_responded callback') callback() else: self.fail(ValueError(u'No cookie found')) else: self.fail(FetchException(u'Received response %s' % (resp.code, )))
def delete_cookie(self, environ, name): cookie = environ.get("HTTP_COOKIE", '') logger.debug("delete KAKA: %s" % cookie) if cookie: cookie_obj = SimpleCookie(cookie) morsel = cookie_obj.get(name, None) cookie = SimpleCookie() cookie[name] = "" cookie[name]['path'] = "/" logger.debug("Expire: %s" % morsel) cookie[name]["expires"] = self._expiration("dawn") return tuple(cookie.output().split(": ", 1)) return None
def kaka2user(self, kaka): logger.debug("KAKA: %s" % kaka) if kaka: cookie_obj = SimpleCookie(kaka) morsel = cookie_obj.get(self.cookie_name, None) if morsel: try: return self.uid2user[morsel.value] except KeyError: return None else: logger.debug("No spauthn cookie") return None
def _from_cookie(self, environ): ''' Attempt to load the associated session using the identifier from the cookie ''' #@@TODO: Use Webob.request cookie = SimpleCookie(environ.get('HTTP_COOKIE')) morsel = cookie.get(self._fieldname, None) if morsel: self._sid, self.session = self._cache.checkout(morsel.value) cookie_sid = morsel.value if cookie_sid != self._sid: self.is_new = True
def kaka2user(kaka): logger.debug("KAKA: %s" % kaka) if kaka: cookie_obj = SimpleCookie(kaka) morsel = cookie_obj.get("idpauthn", None) if morsel: try: return IDP.uid2user[morsel.value] except KeyError: return None else: logger.debug("No idpauthn cookie") return None
def __init__(self, request): self._options = _options self.rd = None self._master_rd = False self.request = request self._data = None self.id = None self._new_session = True self._changed = False cookie = self.request.headers.get('Cookie') if cookie is None: self.__create_id() else: c = SimpleCookie() c.load(cookie) session_cookie = c.get(self._options['_cookie_name']) if session_cookie is None: #new session! self.__create_id() else: self.id = session_cookie.value self._new_session = False def session_callback(request, response): exception = getattr(request, 'exception', None) commit = self._changed increase_expire_mod = _options['_increase_expire_mod'] if increase_expire_mod > 0: rnd = round(random.random() * 1000000) mod = rnd % increase_expire_mod if not mod: # print 'Saving due to increase_expire_mod' commit = True if exception is None and commit: self.__save() cookie = SimpleCookie() _cname = self._options['_cookie_name'] cookie[_cname] = self.id domain = self._options.get('cookie_domain') cookie[_cname]['path'] = _options['_path'] if domain is not None: cookie[_cname]['domain'] = domain if self._options['_secure']: cookie[_cname]['secure'] = True header = cookie[_cname].output(header='') # print 'Writing cookie header:',header response.headerlist.append(('Set-Cookie', header)) request.add_response_callback(session_callback)
def parse_cookie(cookie): if cookie == '': return {} try: c = SimpleCookie() c.load(cookie) except CookieError: # Invalid cookie return {} cookiedict = {} for key in c.keys(): cookiedict[key] = c.get(key).value return cookiedict
def delete_cookie(self, environ): cookie = environ.get("HTTP_COOKIE", '') logger.debug("delete cookie: %s" % cookie) if cookie: _name = self.cookie_name cookie_obj = SimpleCookie(cookie) morsel = cookie_obj.get(_name, None) cookie = SimpleCookie() cookie[_name] = "" cookie[_name]['path'] = "/" logger.debug("Expire: %s" % morsel) cookie[_name]["expires"] = _expiration("now") return cookie.output().split(": ", 1) return None
def info_from_cookie(kaka): logger.debug("KAKA: %s" % kaka) if kaka: cookie_obj = SimpleCookie(kaka) morsel = cookie_obj.get("idpauthn", None) if morsel: try: key, ref = base64.b64decode(morsel.value).split(":") return IDP.cache.uid2user[key], ref except KeyError: return None, None else: logger.debug("No idpauthn cookie") return None, None
def load_session(self, cookies): from Cookie import SimpleCookie from beaker.session import Session from pyload.web.webinterface import session cookies = SimpleCookie(cookies) sid = cookies.get(session.options['key']) if not sid: return None s = Session({}, use_cookies=False, id=sid.value, **session.options) if s.is_new: return None return s
def parse_cookie(cookie): if cookie == '': return {} if not isinstance(cookie, BaseCookie): try: c = SimpleCookie() c.load(cookie) except CookieError: # Invalid cookie return {} else: c = cookie cookiedict = {} for key in c.keys(): cookiedict[key] = c.get(key).value return cookiedict
def get_user(self, environ): cookie = environ.get("HTTP_COOKIE", '') logger.debug("Cookie: %s" % cookie) if cookie: cookie_obj = SimpleCookie(cookie) morsel = cookie_obj.get(self.cookie_name, None) if morsel: try: return self.uid2user[morsel.value] except KeyError: return None else: logger.debug("No %s cookie", self.cookie_name) return None
def server_id_validator(event): request = event.request server_id = event.request.registry.server_id cookies = SimpleCookie(request.environ.get('HTTP_COOKIE')) cookie_server_id = cookies.get('SERVER_ID', None) if cookie_server_id: value = cookie_server_id.value decrypted = decrypt(server_id, value) if not decrypted or not decrypted.startswith(server_id): logger.info('Invalid cookie: {}'.format( value, extra={'MESSAGE_ID': 'serverid_invalid'})) response_cookie = SimpleCookie() value, time = encrypt(server_id) response_cookie['SERVER_ID'] = value response_cookie['SERVER_ID']['path'] = '/' request.response = HTTPPreconditionFailed( headers={ 'Set-Cookie': response_cookie['SERVER_ID'].OutputString() }) request.response.empty_body = True logger.info('New cookie: {} ({})'.format(value, time), extra={'MESSAGE_ID': 'serverid_new'}) raise request.response else: time = decrypted[len(server_id):] logger.debug('Valid cookie: {} ({})'.format(value, time), extra={'MESSAGE_ID': 'serverid_valid'}) elif request.method in ['POST', 'PATCH', 'PUT', 'DELETE']: value, time = encrypt(server_id) response_cookie = SimpleCookie() response_cookie['SERVER_ID'] = value response_cookie['SERVER_ID']['path'] = '/' request.response = HTTPPreconditionFailed( headers={ 'Set-Cookie': response_cookie['SERVER_ID'].OutputString() }) request.response.empty_body = True logger.info('New cookie: {} ({})'.format(value, time), extra={'MESSAGE_ID': 'serverid_new'}) raise request.response if not cookie_server_id: value, time = encrypt(server_id) request.response.set_cookie(name='SERVER_ID', value=value) logger.info('New cookie: {} ({})'.format(value, time), extra={'MESSAGE_ID': 'serverid_new'}) return request.response
def server_id_validator(event): request = event.request couchdb_server_id = request.registry.couchdb_server_id cookies = SimpleCookie(request.environ.get("HTTP_COOKIE")) cookie_server_id = cookies.get("SERVER_ID", None) if cookie_server_id: value = cookie_server_id.value decrypted = decrypt(couchdb_server_id, value) if not decrypted or not decrypted.startswith(b(couchdb_server_id)): logger.info("Invalid cookie: {}".format( value, extra={"MESSAGE_ID": "serverid_invalid"})) raise server_id_response(request) elif request.method in ["POST", "PATCH", "PUT", "DELETE"]: raise server_id_response(request) if not cookie_server_id: request.add_response_callback(server_id_callback) return request.response