Google App Engine - Cookies seguros
https://stackoverflow.com/questions/2532004
-
22-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Eu estava procurando uma maneira de fazer autenticação/sessões baseadas em cookies no Google App Engine, porque não gosto da idéia de sessões baseadas em memcache, e também não gosto da ideia de forçar os usuários a criar contas do Google apenas para Use um site. Eu tropecei através de alguém postagem Isso mencionou algumas funções de biscoito assinadas da estrutura do tornado e parece o que eu preciso. O que tenho em mente é armazenar o ID de um usuário em um cookie à prova de violação e talvez usar um decorador para os manipuladores de solicitação testarem o status de autenticação do usuário e, como um benefício lateral, o ID do usuário estará disponível para o manipulador de solicitação para trabalho de dados de dados e tal. O conceito seria semelhante à autenticação de formas no ASP.NET. Este código vem do módulo web.py da estrutura de tornados.
De acordo com o DocStrings, ele "sinais e registros de data e hora, para que não possa ser forjado" e "retorna o cookie assinado, se valida, ou nenhum".
Tentei usá -lo em um projeto de mecanismo de aplicativos, mas não entendo as nuances de tentar fazer com que esses métodos funcionem no contexto do manipulador de solicitação. Alguém pode me mostrar a maneira certa de fazer isso sem perder a funcionalidade que os desenvolvedores do FriendFeed colocam nele? As partes set_secure_cookie e get_secure_cookie são as mais importantes, mas seria bom poder usar os outros métodos também.
#!/usr/bin/env python
import Cookie
import base64
import time
import hashlib
import hmac
import datetime
import re
import calendar
import email.utils
import logging
def _utf8(s):
if isinstance(s, unicode):
return s.encode("utf-8")
assert isinstance(s, str)
return s
def _unicode(s):
if isinstance(s, str):
try:
return s.decode("utf-8")
except UnicodeDecodeError:
raise HTTPError(400, "Non-utf8 argument")
assert isinstance(s, unicode)
return s
def _time_independent_equals(a, b):
if len(a) != len(b):
return False
result = 0
for x, y in zip(a, b):
result |= ord(x) ^ ord(y)
return result == 0
def cookies(self):
"""A dictionary of Cookie.Morsel objects."""
if not hasattr(self,"_cookies"):
self._cookies = Cookie.BaseCookie()
if "Cookie" in self.request.headers:
try:
self._cookies.load(self.request.headers["Cookie"])
except:
self.clear_all_cookies()
return self._cookies
def _cookie_signature(self,*parts):
self.require_setting("cookie_secret","secure cookies")
hash = hmac.new(self.application.settings["cookie_secret"],
digestmod=hashlib.sha1)
for part in parts:hash.update(part)
return hash.hexdigest()
def get_cookie(self,name,default=None):
"""Gets the value of the cookie with the given name,else default."""
if name in self.cookies:
return self.cookies[name].value
return default
def set_cookie(self,name,value,domain=None,expires=None,path="/",
expires_days=None):
"""Sets the given cookie name/value with the given options."""
name = _utf8(name)
value = _utf8(value)
if re.search(r"[\x00-\x20]",name + value):
# Don't let us accidentally inject bad stuff
raise ValueError("Invalid cookie %r:%r" % (name,value))
if not hasattr(self,"_new_cookies"):
self._new_cookies = []
new_cookie = Cookie.BaseCookie()
self._new_cookies.append(new_cookie)
new_cookie[name] = value
if domain:
new_cookie[name]["domain"] = domain
if expires_days is not None and not expires:
expires = datetime.datetime.utcnow() + datetime.timedelta(
days=expires_days)
if expires:
timestamp = calendar.timegm(expires.utctimetuple())
new_cookie[name]["expires"] = email.utils.formatdate(
timestamp,localtime=False,usegmt=True)
if path:
new_cookie[name]["path"] = path
def clear_cookie(self,name,path="/",domain=None):
"""Deletes the cookie with the given name."""
expires = datetime.datetime.utcnow() - datetime.timedelta(days=365)
self.set_cookie(name,value="",path=path,expires=expires,
domain=domain)
def clear_all_cookies(self):
"""Deletes all the cookies the user sent with this request."""
for name in self.cookies.iterkeys():
self.clear_cookie(name)
def set_secure_cookie(self,name,value,expires_days=30,**kwargs):
"""Signs and timestamps a cookie so it cannot be forged"""
timestamp = str(int(time.time()))
value = base64.b64encode(value)
signature = self._cookie_signature(name,value,timestamp)
value = "|".join([value,timestamp,signature])
self.set_cookie(name,value,expires_days=expires_days,**kwargs)
def get_secure_cookie(self,name,include_name=True,value=None):
"""Returns the given signed cookie if it validates,or None"""
if value is None:value = self.get_cookie(name)
if not value:return None
parts = value.split("|")
if len(parts) != 3:return None
if include_name:
signature = self._cookie_signature(name,parts[0],parts[1])
else:
signature = self._cookie_signature(parts[0],parts[1])
if not _time_independent_equals(parts[2],signature):
logging.warning("Invalid cookie signature %r",value)
return None
timestamp = int(parts[1])
if timestamp < time.time() - 31 * 86400:
logging.warning("Expired cookie %r",value)
return None
try:
return base64.b64decode(parts[0])
except:
return None
UID = 1234 | 1234567890 | D32B9E9C67274FA062E2599FD659CC14
Peças:
1. UID é o nome da chave
2. 1234 é o seu valor claro
3. 1234567890 é o registro de data e hora
4. D32B9E9C67274FA062E2599FD659CC14 é a assinatura feita a partir do valor e o timestamp
Solução 3
Isso funciona se alguém estiver interessado:
from google.appengine.ext import webapp
import Cookie
import base64
import time
import hashlib
import hmac
import datetime
import re
import calendar
import email.utils
import logging
def _utf8(s):
if isinstance(s, unicode):
return s.encode("utf-8")
assert isinstance(s, str)
return s
def _unicode(s):
if isinstance(s, str):
try:
return s.decode("utf-8")
except UnicodeDecodeError:
raise HTTPError(400, "Non-utf8 argument")
assert isinstance(s, unicode)
return s
def _time_independent_equals(a, b):
if len(a) != len(b):
return False
result = 0
for x, y in zip(a, b):
result |= ord(x) ^ ord(y)
return result == 0
class ExtendedRequestHandler(webapp.RequestHandler):
"""Extends the Google App Engine webapp.RequestHandler."""
def clear_cookie(self,name,path="/",domain=None):
"""Deletes the cookie with the given name."""
expires = datetime.datetime.utcnow() - datetime.timedelta(days=365)
self.set_cookie(name,value="",path=path,expires=expires,
domain=domain)
def clear_all_cookies(self):
"""Deletes all the cookies the user sent with this request."""
for name in self.cookies.iterkeys():
self.clear_cookie(name)
def cookies(self):
"""A dictionary of Cookie.Morsel objects."""
if not hasattr(self,"_cookies"):
self._cookies = Cookie.BaseCookie()
if "Cookie" in self.request.headers:
try:
self._cookies.load(self.request.headers["Cookie"])
except:
self.clear_all_cookies()
return self._cookies
def _cookie_signature(self,*parts):
"""Hashes a string based on a pass-phrase."""
hash = hmac.new("MySecretPhrase",digestmod=hashlib.sha1)
for part in parts:hash.update(part)
return hash.hexdigest()
def get_cookie(self,name,default=None):
"""Gets the value of the cookie with the given name,else default."""
if name in self.request.cookies:
return self.request.cookies[name]
return default
def set_cookie(self,name,value,domain=None,expires=None,path="/",expires_days=None):
"""Sets the given cookie name/value with the given options."""
name = _utf8(name)
value = _utf8(value)
if re.search(r"[\x00-\x20]",name + value): # Don't let us accidentally inject bad stuff
raise ValueError("Invalid cookie %r:%r" % (name,value))
new_cookie = Cookie.BaseCookie()
new_cookie[name] = value
if domain:
new_cookie[name]["domain"] = domain
if expires_days is not None and not expires:
expires = datetime.datetime.utcnow() + datetime.timedelta(days=expires_days)
if expires:
timestamp = calendar.timegm(expires.utctimetuple())
new_cookie[name]["expires"] = email.utils.formatdate(timestamp,localtime=False,usegmt=True)
if path:
new_cookie[name]["path"] = path
for morsel in new_cookie.values():
self.response.headers.add_header('Set-Cookie',morsel.OutputString(None))
def set_secure_cookie(self,name,value,expires_days=30,**kwargs):
"""Signs and timestamps a cookie so it cannot be forged"""
timestamp = str(int(time.time()))
value = base64.b64encode(value)
signature = self._cookie_signature(name,value,timestamp)
value = "|".join([value,timestamp,signature])
self.set_cookie(name,value,expires_days=expires_days,**kwargs)
def get_secure_cookie(self,name,include_name=True,value=None):
"""Returns the given signed cookie if it validates,or None"""
if value is None:value = self.get_cookie(name)
if not value:return None
parts = value.split("|")
if len(parts) != 3:return None
if include_name:
signature = self._cookie_signature(name,parts[0],parts[1])
else:
signature = self._cookie_signature(parts[0],parts[1])
if not _time_independent_equals(parts[2],signature):
logging.warning("Invalid cookie signature %r",value)
return None
timestamp = int(parts[1])
if timestamp < time.time() - 31 * 86400:
logging.warning("Expired cookie %r",value)
return None
try:
return base64.b64decode(parts[0])
except:
return None
Pode ser usado assim:
class MyHandler(ExtendedRequestHandler):
def get(self):
self.set_cookie(name="MyCookie",value="NewValue",expires_days=10)
self.set_secure_cookie(name="MySecureCookie",value="SecureValue",expires_days=10)
value1 = self.get_cookie('MyCookie')
value2 = self.get_secure_cookie('MySecureCookie')
Outras dicas
Tornado nunca foi feito para funcionar com o App Engine (é "seu próprio servidor" por completo). Por que você não escolhe alguma estrutura que foi destinado a um mecanismo de aplicativo da palavra "go" e é leve e dândi, como Tipfy? Ele fornece autenticação usando seu próprio sistema de usuário ou qualquer um dos próprios mecanismos de aplicativos users, Openin, Oauth e Facebook; sessões com cookies seguros ou dados do GAE; E muito mais, tudo em uma abordagem de "não-quadro" soberbamente leve, baseada no WSGI e Werkzeug. O que não gosta?!
Para aqueles que ainda estão procurando, extraímos apenas a implementação de biscoitos de tornado que você pode usar com o App Engine na Prossmart. Estamos usando -o com sucesso no App Engine e continuaremos a mantê -lo atualizado.
A própria biblioteca de cookies está em:http://github.com/thrivesmart/prayls/blob/master/prayls/lilcookies.py
Você pode vê -lo em ação em nosso aplicativo de exemplo que está incluído. Se a estrutura de nosso repositório mudar, você pode procurar lilcookes.py em github.com/thrivesmart/prayls
Espero que seja útil para alguém lá fora!
Se você deseja armazenar apenas o ID do usuário do usuário no cookie (presumivelmente para que você possa procurar o registro deles no armazenamento de dados), não precisa de cookies 'seguros' ou à prova de violação - você só precisa de um espaço para nome grande o suficiente para Torne a adivinhação IDs de usuário impraticável - por exemplo, GUIDS ou outros dados aleatórios.
Uma opção pré-fabricada para isso, que usa o armazenamento de dados para armazenamento de sessão, é Taça. Como alternativa, você pode lidar com isso você mesmo com cabeçalhos de defesa/cookie, se você realmente precisar armazenar o ID do usuário.
Alguém extraiu recentemente o código de autenticação e sessão do Tornado e criou uma nova biblioteca especificamente para o GAE.
Talvez isso seja mais do que você precisa, mas como eles fizeram isso especificamente para o GAE, você não deve se preocupar em adaptá -lo sozinho.
A biblioteca deles é chamada Gaema. Aqui está o anúncio do GAE Python Group em 4 de março de 2010:http://groups.google.com/group/google-appengine-python/browse_thread/thread/d2d6c597d66cad3/06c6dc49cb8eca0c?lnk=gst&q=tornado#06c6c49cb8eca00c
