HEX
Server: LiteSpeed
System: Linux standart9.isimtescil.net 3.10.0-962.3.2.lve1.5.26.7.el7.x86_64 #1 SMP Wed Oct 2 07:53:12 EDT 2019 x86_64
User: karalev (5310)
PHP: 8.2.29
Disabled: NONE
$ pwd: /opt/alt/python27/lib/python2.7/site-packages/paste/auth/
Upload Files
File: //opt/alt/python27/lib/python2.7/site-packages/paste/auth/cookie.pyc
�
|��Wc@sdZddlZddlZddlZddlZddlZyddlmZWnek
ruddl	ZnXddl
mZd�Ze
ejdde�j��Zee
eej���Zd%d&d'd(gZgeD]\ZZeef^q�Zej�ed�Zd�Zdefd��YZdjgedd�D]Zee�^qN�Zd�Z de!fd��YZ"de#fd��YZ$de!fd��YZ%e%Z&dd)dd d!d"�Z(dddgZ)d#e*krddl+Z+e+j,d$e+j-�ndS(*s
Cookie "Saved" Authentication

This authentication middleware saves the current REMOTE_USER,
REMOTE_SESSION, and any other environment variables specified in a
cookie so that it can be retrieved during the next request without
requiring re-authentication. This uses a session cookie on the client
side (so it goes away when the user closes their window) and does
server-side expiration.

Following is a very simple example where a form is presented asking for
a user name (no actual checking), and dummy session identifier (perhaps
corresponding to a database session id) is stored in the cookie.

::

  >>> from paste.httpserver import serve
  >>> from paste.fileapp import DataApp
  >>> from paste.httpexceptions import *
  >>> from paste.auth.cookie import AuthCookieHandler
  >>> from paste.wsgilib import parse_querystring
  >>> def testapp(environ, start_response):
  ...     user = dict(parse_querystring(environ)).get('user','')
  ...     if user:
  ...         environ['REMOTE_USER'] = user
  ...         environ['REMOTE_SESSION'] = 'a-session-id'
  ...     if environ.get('REMOTE_USER'):
  ...         page = '<html><body>Welcome %s (%s)</body></html>'
  ...         page %= (environ['REMOTE_USER'], environ['REMOTE_SESSION'])
  ...     else:
  ...         page = ('<html><body><form><input name="user" />'
  ...                 '<input type="submit" /></form></body></html>')
  ...     return DataApp(page, content_type="text/html")(
  ...                    environ, start_response)
  >>> serve(AuthCookieHandler(testapp))
  serving on...

i����N(tsha1(tget_cookiescCstjdtj|��S(Ns
%Y%m%d%H%M(ttimetstrftimetgmtime(tvalue((sB/opt/alt/python27/lib/python2.7/site-packages/paste/auth/cookie.pyt	make_time5stxs\s\x5ct"s\x22t=s\x3dt;s\x3bcCstd�|t|��S(NcSs|j|d|d�S(Nii(treplace(tatb((sB/opt/alt/python27/lib/python2.7/site-packages/paste/auth/cookie.pyt<lambda>As(treducetstr(tstsublist((sB/opt/alt/python27/lib/python2.7/site-packages/paste/auth/cookie.pytencode@scCs
t|t�S(N(Rt_decode(R((sB/opt/alt/python27/lib/python2.7/site-packages/paste/auth/cookie.pyRBstCookieTooLargecBseZd�ZRS(cCs#tjd�||_||_dS(Ns*Signed cookie exceeds maximum size of 4096(tRuntimeErrort__init__tcontenttcookie(tselfRR((sB/opt/alt/python27/lib/python2.7/site-packages/paste/auth/cookie.pyREs
	(t__name__t
__module__R(((sB/opt/alt/python27/lib/python2.7/site-packages/paste/auth/cookie.pyRDstii�cCsdjtjtd��S(s returns a 64 byte secret Ri@(tjointrandomtsamplet
_all_chars(((sB/opt/alt/python27/lib/python2.7/site-packages/paste/auth/cookie.pyt
new_secretKstAuthCookieSignercBs2eZdZdddd�Zd�Zd�ZRS(s
    save/restore ``environ`` entries via digially signed cookie

    This class converts content into a timed and digitally signed
    cookie, as well as having the facility to reverse this procedure.
    If the cookie, after the content is encoded and signed exceeds the
    maximum length (4096), then CookieTooLarge exception is raised.

    The timeout of the cookie is handled on the server side for a few
    reasons.  First, if a 'Expires' directive is added to a cookie, then
    the cookie becomes persistent (lasting even after the browser window
    has closed). Second, the user's clock may be wrong (perhaps
    intentionally). The timeout is specified in minutes; and expiration
    date returned is rounded to one second.

    Constructor Arguments:

        ``secret``

            This is a secret key if you want to syncronize your keys so
            that the cookie will be good across a cluster of computers.
            It is recommended via the HMAC specification (RFC 2104) that
            the secret key be 64 bytes since this is the block size of
            the hashing.  If you do not provide a secret key, a random
            one is generated each time you create the handler; this
            should be sufficient for most cases.

        ``timeout``

            This is the time (in minutes) from which the cookie is set
            to expire.  Note that on each request a new (replacement)
            cookie is sent, hence this is effectively a session timeout
            parameter for your entire cluster.  If you do not provide a
            timeout, it is set at 30 minutes.

        ``maxlen``

            This is the maximum size of the *signed* cookie; hence the
            actual content signed will be somewhat less.  If the cookie
            goes over this size, a ``CookieTooLarge`` exception is
            raised so that unexpected handling of cookies on the client
            side are avoided.  By default this is set at 4k (4096 bytes),
            which is the standard cookie size limit.

    cCsV|p	d|_t|t�r1td|��n|p:d|_|pLt�|_dS(Nis5Timeout must be a number (minutes), not a string (%r)i(ttimeoutt
isinstancet
basestringt
ValueErrortmaxlenR"tsecret(RR)R$R(((sB/opt/alt/python27/lib/python2.7/site-packages/paste/auth/cookie.pyR}s
cCs�tjtj|j|t�j�ttj�d|j	�|�}|j
dd�j
dd�}|j
dd�j
dd�}t|�|jkr�t
||��n|S(	s�
        Sign the content returning a valid cookie (that does not
        need to be escaped and quoted).  The expiration of this
        cookie is handled server-side in the auth() function.
        i<t/t_R	t~s
Rs
(tbase64tencodestringthmactnewR)RtdigestRRR$RtlenR(R(RRR((sB/opt/alt/python27/lib/python2.7/site-packages/paste/auth/cookie.pytsign�s6
cCs�tj|jdd�jdd��}|t }|tt!}|t}|tj|j|t�j	�kr�t
|�t
ttj���kr�|SndS(s�
        Authenticate the cooke using the signature, verify that it
        has not expired; and return the cookie's content
        R+R*R,R	N(
R-tdecodestringRt_signature_sizet_header_sizeR/R0R)RR1tintRR(RRtdecodet	signaturetexpiresR((sB/opt/alt/python27/lib/python2.7/site-packages/paste/auth/cookie.pytauth�s!


$$N(RRt__doc__tNoneRR3R;(((sB/opt/alt/python27/lib/python2.7/site-packages/paste/auth/cookie.pyR#Os-		tAuthCookieEnvironcBs eZdZd�Zd�ZRS(sH
    a list of environment keys to be saved via cookie

    An instance of this object, found at ``environ['paste.auth.cookie']``
    lists the `environ` keys that were restored from or will be added
    to the digially signed cookie.  This object can be accessed from an
    `environ` variable by using this module's name.
    cCstj||�||_dS(N(tlistRthandler(RR@tscanlist((sB/opt/alt/python27/lib/python2.7/site-packages/paste/auth/cookie.pyR�scCs*||krdStj|t|��dS(N(R?tappendR(RR((sB/opt/alt/python27/lib/python2.7/site-packages/paste/auth/cookie.pyRB�s(RRR<RRB(((sB/opt/alt/python27/lib/python2.7/site-packages/paste/auth/cookie.pyR>�s	tAuthCookieHandlercBsJeZdZdZdZeZeZddddddd�Z
d�ZRS(s�
    the actual handler that should be put in your middleware stack

    This middleware uses cookies to stash-away a previously authenticated
    user (and perhaps other variables) so that re-authentication is not
    needed.  This does not implement sessions; and therefore N servers
    can be syncronized to accept the same saved authentication if they
    all use the same cookie_name and secret.

    By default, this handler scans the `environ` for the REMOTE_USER
    and REMOTE_SESSION key; if found, it is stored. It can be
    configured to scan other `environ` keys as well -- but be careful
    not to exceed 2-3k (so that the encoded and signed cookie does not
    exceed 4k). You can ask it to handle other environment variables
    by doing:

       ``environ['paste.auth.cookie'].append('your.environ.variable')``


    Constructor Arguments:

        ``application``

            This is the wrapped application which will have access to
            the ``environ['REMOTE_USER']`` restored by this middleware.

        ``cookie_name``

            The name of the cookie used to store this content, by default
            it is ``PASTE_AUTH_COOKIE``.

        ``scanlist``

            This is the initial set of ``environ`` keys to
            save/restore to the signed cookie.  By default is consists
            only of ``REMOTE_USER`` and ``REMOTE_SESSION``; any tuple
            or list of environment keys will work.  However, be
            careful, as the total saved size is limited to around 3k.

        ``signer``

            This is the signer object used to create the actual cookie
            values, by default, it is ``AuthCookieSigner`` and is passed
            the remaining arguments to this function: ``secret``,
            ``timeout``, and ``maxlen``.

    At this time, each cookie is individually signed.  To store more
    than the 4k of data; it is possible to sub-class this object to
    provide different ``environ_name`` and ``cookie_name``
    spaste.auth.cookietPASTE_AUTH_COOKIEcCsU|s|j|||�}n||_|p0d|_||_|pK|j|_dS(NtREMOTE_USERtREMOTE_SESSION(RERF(tsigner_classtsignerRAtapplicationtcookie_name(RRIRJRARHR)R$R(((sB/opt/alt/python27/lib/python2.7/site-packages/paste/auth/cookie.pyR�s		c
s\�j�krtd��n�j��j�}t��}|j�j�r�jj|�jj	�}|rx�|j
d�D]~}|j
d�\}}t|�}||kr�|j|�n|�kr�q�nt|��|<d|kr�d�d<q�q�Wqn|��j<d�kr4t
jd�nd���fd	�}	�j�|	�S(
NsAuthCookie already installed!R
R	RERt	AUTH_TYPEspaste.httpexceptionss�Since paste.httpexceptions is hooked in your processing chain before paste.auth.cookie, if an HTTPRedirection is raised, the cookies this module sets will not be included in your response.
cs0�j�j�}|r*t|�j�s0t�g}xz|D]r}�j|�}|d	k	r=t|�tk	r�td||f��n|j	dt
|�t
|�f�q=q=W|r dj|�}�jj
|�}d�j|f}d�dkr
|d7}n|j	d|f�n�|||�S(
s�
            Scan the environment for keys specified in the scanlist,
            pack up their values, signs the content and issues a cookie.
            sUThe value of the environmental variable %r is not a str (only str is allowed; got %r)s%s=%sR
s%s=%s; Path=/;thttpsswsgi.url_schemes secure;s
Set-CookieN(tgettenviron_nameR%t
environ_classtAssertionErrorR=ttypeRR'RBRRRHR3RJ(tstatustresponse_headerstexc_infoRARtktvR(tenvironRtstart_response(sB/opt/alt/python27/lib/python2.7/site-packages/paste/auth/cookie.pyt
response_hooks&
*
(RNRPRORARthas_keyRJRHR;RtsplitR8RBtwarningstwarnR=RI(
RRWRXRAtjarRtpairRURVRY((RWRRXsB/opt/alt/python27/lib/python2.7/site-packages/paste/auth/cookie.pyt__call__s,
N(RRR<RNRJR#RGR>ROR=RR`(((sB/opt/alt/python27/lib/python2.7/site-packages/paste/auth/cookie.pyRC�s2RDRERFiic
Cs�t|t�r|j�}n|dkrF|jd�rF|d}nyt|�}Wn!tk
rytd|��nXyt|�}Wn!tk
r�td|��nXt|d|d|d|d|d|�S(	s�
    This middleware uses cookies to stash-away a previously
    authenticated user (and perhaps other variables) so that
    re-authentication is not needed.  This does not implement
    sessions; and therefore N servers can be syncronized to accept the
    same saved authentication if they all use the same cookie_name and
    secret.

    By default, this handler scans the `environ` for the REMOTE_USER
    and REMOTE_SESSION key; if found, it is stored. It can be
    configured to scan other `environ` keys as well -- but be careful
    not to exceed 2-3k (so that the encoded and signed cookie does not
    exceed 4k). You can ask it to handle other environment variables
    by doing:

       ``environ['paste.auth.cookie'].append('your.environ.variable')``

    Configuration:

        ``cookie_name``

            The name of the cookie used to store this content, by
            default it is ``PASTE_AUTH_COOKIE``.

        ``scanlist``

            This is the initial set of ``environ`` keys to
            save/restore to the signed cookie.  By default is consists
            only of ``REMOTE_USER`` and ``REMOTE_SESSION``; any
            space-separated list of environment keys will work.
            However, be careful, as the total saved size is limited to
            around 3k.

        ``secret``

            The secret that will be used to sign the cookies.  If you
            don't provide one (and none is set globally) then a random
            secret will be created.  Each time the server is restarted
            a new secret will then be created and all cookies will
            become invalid!  This can be any string value.

        ``timeout``

            The time to keep the cookie, expressed in minutes.  This
            is handled server-side, so a new cookie with a new timeout
            is added to every response.

        ``maxlen``

            The maximum length of the cookie that is sent (default 4k,
            which is a typical browser maximum)
        
    R)s'Bad value for timeout (must be int): %rs&Bad value for maxlen (must be int): %rRJRAR$R(N(R%R&R[R=RMR7R'RC(tapptglobal_confRJRAR)R$R(((sB/opt/alt/python27/lib/python2.7/site-packages/paste/auth/cookie.pytmake_auth_cookie7s">


t__main__toptionflags(s\s\x5c(Rs\x22(R	s\x3d(R
s\x3b(sREMOTE_USERsREMOTE_SESSION(.R<R/R-RRR\thashlibRtImportErrortshat
paste.requestRRR2R0R1R5R6t_encodeRURVRtreverseRR8RRRtrangeRtchrR!R"tobjectR#R?R>RCt
middlewareR=Rct__all__RtdoctestttestmodtELLIPSIS(((sB/opt/alt/python27/lib/python2.7/site-packages/paste/auth/cookie.pyt<module>*s><
	!%
	1	_uH
@ Telegram