)Jf+dZddlZddlZddlmZmZmZddlmZddl m Z m Z m Z m Z mZmZddlmZmZmZmZmZmZmZddlmZddlmZdd lmZmZmZdd lmZdd l m!Z!m"Z#dd l$m%Z%dd lm&Z&gdZ'ej(e)Z*dZ+dZ,Gdde-Z.Gdde-Z/Gdde/Z0Gdde-Z1Gdde2Z3Gdde4Z5Gdde5Z6Gdd e2Z7Gd!d"e-Z8Gd#d$e-Z9d%Z:d&Z;d'ZGd+d,e>Z?Gd-d.e>Z@Gd/d0e>ZAGd1d2e>ZBdS)3a OpenID support for Relying Parties (aka Consumers). This module documents the main interface with the OpenID consumer library. The only part of the library which has to be used and isn't documented in full here is the store required to create an C{L{Consumer}} instance. More on the abstract store type and concrete implementations of it that are provided in the documentation for the C{L{__init__}} method of the C{L{Consumer}} class. OVERVIEW ======== The OpenID identity verification process most commonly uses the following steps, as visible to the user of this library: 1. The user enters their OpenID into a field on the consumer's site, and hits a login button. 2. The consumer site discovers the user's OpenID provider using the Yadis protocol. 3. The consumer site sends the browser a redirect to the OpenID provider. This is the authentication request as described in the OpenID specification. 4. The OpenID provider's site sends the browser a redirect back to the consumer site. This redirect contains the provider's response to the authentication request. The most important part of the flow to note is the consumer's site must handle two separate HTTP requests in order to perform the full identity check. LIBRARY DESIGN ============== This consumer library is designed with that flow in mind. The goal is to make it as easy as possible to perform the above steps securely. At a high level, there are two important parts in the consumer library. The first important part is this module, which contains the interface to actually use this library. The second is the C{L{openid.store.interface}} module, which describes the interface to use if you need to create a custom method for storing the state this library needs to maintain between requests. In general, the second part is less important for users of the library to know about, as several implementations are provided which cover a wide variety of situations in which consumers may use the library. This module contains a class, C{L{Consumer}}, with methods corresponding to the actions necessary in each of steps 2, 3, and 4 described in the overview. Use of this library should be as easy as creating an C{L{Consumer}} instance and calling the methods appropriate for the action the site wants to take. SESSIONS, STORES, AND STATELESS MODE ==================================== The C{L{Consumer}} object keeps track of two types of state: 1. State of the user's current authentication attempt. Things like the identity URL, the list of endpoints discovered for that URL, and in case where some endpoints are unreachable, the list of endpoints already tried. This state needs to be held from Consumer.begin() to Consumer.complete(), but it is only applicable to a single session with a single user agent, and at the end of the authentication process (i.e. when an OP replies with either C{id_res} or C{cancel}) it may be discarded. 2. State of relationships with servers, i.e. shared secrets (associations) with servers and nonces seen on signed messages. This information should persist from one session to the next and should not be bound to a particular user-agent. These two types of storage are reflected in the first two arguments of Consumer's constructor, C{session} and C{store}. C{session} is a dict-like object and we hope your web framework provides you with one of these bound to the user agent. C{store} is an instance of L{openid.store.interface.OpenIDStore}. Since the store does hold secrets shared between your application and the OpenID provider, you should be careful about how you use it in a shared hosting environment. If the filesystem or database permissions of your web host allow strangers to read from them, do not store your data there! If you have no safe place to store your data, construct your consumer with C{None} for the store, and it will operate only in stateless mode. Stateless mode may be slower, put more load on the OpenID provider, and trusts the provider to keep you safe from replay attacks. Several store implementation are provided, and the interface is fully documented so that custom stores can be used as well. See the documentation for the C{L{Consumer}} class for more information on the interface for stores. The implementations that are provided allow the consumer site to store the necessary data in several different ways, including several SQL databases and normal files on disk. IMMEDIATE MODE ============== In the flow described above, the user may need to confirm to the OpenID provider that it's ok to disclose his or her identity. The provider may draw pages asking for information from the user before it redirects the browser back to the consumer's site. This is generally transparent to the consumer site, so it is typically ignored as an implementation detail. There can be times, however, where the consumer site wants to get a response immediately. When this is the case, the consumer can put the library in immediate mode. In immediate mode, there is an extra response possible from the server, which is essentially the server reporting that it doesn't have enough information to answer the question yet. USING THIS LIBRARY ================== Integrating this library into an application is usually a relatively straightforward process. The process should basically follow this plan: Add an OpenID login field somewhere on your site. When an OpenID is entered in that field and the form is submitted, it should make a request to your site which includes that OpenID URL. First, the application should L{instantiate a Consumer} with a session for per-user state and store for shared state. using the store of choice. Next, the application should call the 'C{L{begin}}' method on the C{L{Consumer}} instance. This method takes the OpenID URL. The C{L{begin}} method returns an C{L{AuthRequest}} object. Next, the application should call the C{L{redirectURL}} method on the C{L{AuthRequest}} object. The parameter C{return_to} is the URL that the OpenID server will send the user back to after attempting to verify his or her identity. The C{realm} parameter is the URL (or URL pattern) that identifies your web site to the user when he or she is authorizing it. Send a redirect to the resulting URL to the user's browser. That's the first half of the authentication process. The second half of the process is done after the user's OpenID Provider sends the user's browser a redirect back to your site to complete their login. When that happens, the user will contact your site at the URL given as the C{return_to} URL to the C{L{redirectURL}} call made above. The request will have several query parameters added to the URL by the OpenID provider as the information necessary to finish the request. Get a C{L{Consumer}} instance with the same session and store as before and call its C{L{complete}} method, passing in all the received query arguments. There are multiple possible return types possible from that method. These indicate whether or not the login was successful, and include any additional information appropriate for their type. @var SUCCESS: constant used as the status for L{SuccessResponse} objects. @var FAILURE: constant used as the status for L{FailureResponse} objects. @var CANCEL: constant used as the status for L{CancelResponse} objects. @var SETUP_NEEDED: constant used as the status for L{SetupNeededResponse} objects. N)urlparse urldefrag parse_qsl)fetchers)discoverOpenIDServiceEndpointDiscoveryFailureOPENID_1_0_TYPEOPENID_1_1_TYPEOPENID_2_0_TYPE)Message OPENID_NS OPENID2_NS OPENID1_NSIDENTIFIER_SELECT no_defaultBARE_NS) cryptutil)oidutil) Associationdefault_negotiatorSessionNegotiator) DiffieHellman)mkNoncesplit) Discovery)urinorm) AuthRequestConsumerSuccessResponseSetupNeededResponseCancelResponseFailureResponseSUCCESSFAILURECANCEL SETUP_NEEDEDcrtj||}t||S)zMake a Direct Request to an OpenID Provider and return the result as a Message object. @raises openid.fetchers.HTTPFetchingError: if an error is encountered in making the HTTP post. @rtype: L{openid.message.Message} )body)rfetch toURLEncoded_httpResponseToMessage)request_message server_urlresps [/home/alex/cs2snipeproduction/venv/lib/python3.11/site-packages/openid/consumer/consumer.py makeKVPostr1s6 >*?+G+G+I+I J J JD "$ 3 33ctj|j}|jdkrt||jdvr"d}|||jfz}t j||S)auAdapt a POST response to a Message. @type response: L{openid.fetchers.HTTPResponse} @param response: Result of a POST to an OpenID endpoint. @rtype: L{openid.message.Message} @raises openid.fetchers.HTTPFetchingError: if the server returned a status of other than 200 or 400. @raises ServerError: if the server returned an OpenID error. i)z"bad status code from server %s: %s)r fromKVFormr)status ServerError fromMessagerHTTPFetchingError)responser.response_messagefmt error_messages r0r,r,ss)(-88#%%&6777  * *2z8?;; (777 r2cTeZdZdZdZdZeeZd dZ d dZ d dZ d Z d Z dS) raAn OpenID consumer implementation that performs discovery and does session management. @ivar consumer: an instance of an object implementing the OpenID protocol, but doing no discovery or session management. @type consumer: GenericConsumer @ivar session: A dictionary-like object representing the user's session data. This is used for keeping state of the OpenID transaction when the user is redirected to the server. @cvar session_key_prefix: A string that is prepended to session keys to ensure that they are unique. This variable may be changed to suit your application. _openid_consumer_ last_tokenNcn||_|t}|||_|j|jz|_dS)axInitialize a Consumer instance. You should create a new instance of the Consumer object with every HTTP request that handles OpenID transactions. @param session: See L{the session instance variable} @param store: an object that implements the interface in C{L{openid.store.interface.OpenIDStore}}. Several implementations are provided, to cover common database environments. @type store: C{L{openid.store.interface.OpenIDStore}} @see: L{openid.store.interface} @see: L{openid.store} N)sessionGenericConsumerconsumersession_key_prefix_token _token_key)selfrCstoreconsumer_classs r0__init__zConsumer.__init__!s<$  !,N&u-- 1DK?r2Fc$t|j||j} ||j}n/#t j$r}td|jdd}~wwxYw|td|d| ||S)awStart the OpenID authentication process. See steps 1-2 in the overview at the top of this file. @param user_url: Identity URL given by the user. This method performs a textual transformation of the URL to try and make sure it is normalized. For example, a user_url of example.com will be normalized to http://example.com/ normalizing and resolving any redirects the server might issue. @type user_url: unicode @param anonymous: Whether to make an anonymous request of the OpenID provider. Such a request does not ask for an authorization assertion for an OpenID identifier, but may be used with extensions to pass other data. e.g. "I don't care who you are, but I'd like to know your time zone." @type anonymous: bool @returns: An object containing the discovered information will be returned, with a method for building a redirect URL to the server, as described in step 3 of the overview. This object may also be used to add extension arguments to the request, using its L{addExtensionArg} method. @returntype: L{AuthRequest} @raises openid.consumer.discover.DiscoveryFailure: when I fail to find an OpenID server for this URL. If the C{yadis} package is available, L{openid.consumer.discover.DiscoveryFailure} is an alias for C{yadis.discover.DiscoveryFailure}. zError fetching XRDS document: Nz$No usable OpenID services found for ) rrCrFgetNextService _discoverrr:r whybeginWithoutDiscovery)rIuser_url anonymousdiscoservicerPs r0beginzConsumer.begin9sH$,$2IJJ 6**4>::GG) 6 6 6""$'GG$/0466 6 6 ?""$,H$01577 7--gyAA As8A$AA$c|j|}|j|j|j< ||n.#t $r!}tt|d}~wwxYw|S)aStart OpenID verification without doing OpenID server discovery. This method is used internally by Consumer.begin after discovery is performed, and exists to provide an interface for library users needing to perform their own discovery. @param service: an OpenID service endpoint descriptor. This object and factories for it are found in the L{openid.consumer.discover} module. @type service: L{OpenIDServiceEndpoint} @returns: an OpenID authentication request object. @rtype: L{AuthRequest} @See: Openid.consumer.consumer.Consumer.begin @see: openid.consumer.discover N) rErVendpointrCrH setAnonymous ValueError ProtocolErrorstr)rIrUrSauth_reqrPs r0rQzConsumer.beginWithoutDiscoveryjs*=&&w//(0(9 T_% *  ! !) , , , , * * *C)) ) *sA A1A,,A1cn|j|j}tj|}|j|||} |j|j=n#t$rYnwxYw|jdvr=|j 6t|j|j |j }| d|S)aZCalled to interpret the server's response to an OpenID request. It is called in step 4 of the flow described in the consumer overview. @param query: A dictionary of the query parameters for this HTTP request. @param current_url: The URL used to invoke the application. Extract the URL from your application's web request framework and specify it here to have it checked against the openid.return_to value in the response. If the return_to URL check fails, the status of the completion will be FAILURE. @returns: a subclass of Response. The type of response is indicated by the status attribute, which will be one of SUCCESS, CANCEL, FAILURE, or SETUP_NEEDED. @see: L{SuccessResponse} @see: L{CancelResponse} @see: L{SetupNeededResponse} @see: L{FailureResponse} )successcancelNT)force) rCgetrHr fromPostArgsrEcompleteKeyErrorr7 identity_urlrrFcleanup)rIquery current_urlrXmessager;rTs r0rdzConsumer.completes2<##DO44&u--=))'8[II  T_--    D  O4 4 4%1dlH,A"577E MMM % % %s A A,+A,c8t||j_dS)aSet the order in which association types/sessions should be attempted. For instance, to only allow HMAC-SHA256 associations created with a DH-SHA256 association session: >>> consumer.setAssociationPreference([('HMAC-SHA256', 'DH-SHA256')]) Any association type/association type pair that is not in this list will not be attempted at all. @param association_preferences: The list of allowed (association type, association session type) pairs that should be allowed for this consumer to use, in order from most preferred to least preferred. @type association_preferences: [(str, str)] @returns: None @see: C{L{openid.association.SessionNegotiator}} N)rrE negotiator)rIassociation_preferencess r0setAssociationPreferencez!Consumer.setAssociationPreferences($55L#M#M    r2N)F)__name__ __module__ __qualname____doc__rFrG staticmethodrrOrLrVrQrdrnr2r0rr s - F X&&I@@@@0/B/B/B/Bb>,,,\NNNNNr2rcPeZdZdZeejZdZdgZ ddZ dZ dZ dS) DiffieHellmanSHA1ConsumerSessionDH-SHA1 HMAC-SHA1Nc>|tj}||_dSro)r fromDefaultsdh)rIr}s r0rLz)DiffieHellmanSHA1ConsumerSession.__init__s :+--Br2ctj|jj}d|i}|jsP|tj|jjtj|jjd|S)Ndh_consumer_public) dh_modulusdh_gen)r longToBase64r}publicusingDefaultValuesupdatemodulus generator)rIcpubargss r0 getRequestz+DiffieHellmanSHA1ConsumerSession.getRequests%dgn55$d+w))++  KK'4TW_EE#01BCC     r2c|tdt}|tdt}tj|}t j|}|j|||j S)Ndh_server_public enc_mac_key) getArgrrr base64ToLongr fromBase64r} xorSecret hash_func)rIr;dh_server_public64 enc_mac_key64rrs r0 extractSecretz.DiffieHellmanSHA1ConsumerSession.extractSecretsr%__Y8J-799  =*MM $12DEE(77 w  !1;OOOr2ro) rprqrr session_typertrsha1r secret_sizeallowed_assoc_typesrLrrrur2r0rwrwsnL Y^,,IK&-   PPPPPr2rwc<eZdZdZeejZdZdgZ dS)"DiffieHellmanSHA256ConsumerSession DH-SHA256 HMAC-SHA256N) rprqrrrrtrsha256rrrrur2r0rrs4L Y-..IK(/r2rc&eZdZdZddgZdZdZdS)PlainTextConsumerSession no-encryptionrzrciSrorurIs r0rz#PlainTextConsumerSession.getRequests r2cl|tdt}tj|S)Nmac_key)rrrrr)rIr; mac_key64s r0rz&PlainTextConsumerSession.extractSecrets(OOIy*EE !),,,r2N)rprqrrrrrrrur2r0rrsB"L& 6-----r2rceZdZdZddZdS)SetupNeededErrorzVInternally-used exception that indicates that an immediate-mode request cancelled.NcJt||||_dSro) ExceptionrLuser_setup_url)rIrs r0rLzSetupNeededError.__init__s&4000,r2ro)rprqrrrsrLrur2r0rrs2------r2rceZdZdZdS)r[zsException that indicates that a message violated the protocol. It is raised and caught internally to this file.N)rprqrrrsrur2r0r[r[ s"BBBBr2r[ceZdZdZdZdZdS)TypeURIMismatchz8A protocol error arising from type URIs mismatching cZt|||||_||_dSro)r[rLexpectedrX)rIrrXs r0rLzTypeURIMismatch.__init__s,tXx888    r2c zd|jjd|jjd|jd|jjd|jd }|S)N<.z: Required type z not found in z for endpoint >) __class__rqrprrX type_uris)rIss r0__str__zTypeURIMismatch.__str__sK N % % %t~'>'>'> M # # #T]]] 4r2N)rprqrrrsrLrrur2r0rrs<!!! r2rc4eZdZdZdZdZeeZdS)r8z]Exception that is raised when the server returns a 400 response code to a direct request.cft||||_||_||_dSro)rrL error_text error_coderj)rIrrrjs r0rLzServerError.__init__%s14,,,$$ r2c|tdd}|td}||||S)zgGenerate a ServerError instance, extracting the error text and the error code from the message.errorzr)rr)clsrjrrs r0r9zServerError.fromMessage+sG^^Iw$ACC ^^I|<< s:z7333r2N)rprqrrrsrLr9 classmethodrur2r0r8r8!sG!! 444+k**KKKr2r8c*eZdZdZdZdZeeedZ e e Z dZ dZdZdZd Zd Zd Zd Zd Ze eZdZdZdZdZdZdZdZe eZd&dZdZ dZ!dZ"dZ#dZ$dZ%dZ&dZ'dZ(d Z)d!Z*d"Z+d#Z,d$Z-d%Z.dS)'rDaThis is the implementation of the common logic for OpenID consumers. It is unaware of the application in which it is running. @ivar negotiator: An object that controls the kind of associations that the consumer makes. It defaults to C{L{openid.association.default_negotiator}}. Assign a different negotiator to it if you have specific requirements for how associations are made. @type negotiator: C{L{openid.association.SessionNegotiator}} janrain_nonceopenid1_claimed_id)rxrrcD||_tj|_dSro)rJrcopyrl)rIrJs r0rLzGenericConsumer.__init__Xs ,133r2c|jd}n||}t||}t|j|j<|jr|jj |j|j <|S)zCreate an AuthRequest object for the specified service_endpoint. This method will create an association if necessary.N) rJ_getAssociationrrreturn_to_argsopenid1_nonce_query_arg_namerj isOpenID1rX claimed_id!openid1_return_to_identifier_name)rIservice_endpointassocrequests r0rVzGenericConsumer.begin\s : EE(()9::E.66DKIIt@A ? $ $ & & , +  "4#I Jr2c|tdd}t|d|z|j}||||S)zProcess the OpenID message, using the specified endpoint and return_to URL as context. This method will handle any OpenID message that is sent to the return_to URL. mode _complete_)rrgetattr_completeInvalid)rIrjrX return_tor modeMethods r0rdzGenericConsumer.completensF ~~iAAT<$#68MNN z'8Y777r2c t|Sro)r")rIrjrX_s r0_complete_cancelz GenericConsumer._complete_cancelysh'''r2c|td}|td}|td}t||||S)Nrcontact reference)rrrrr#)rIrjrXrrrrs r0_complete_errorzGenericConsumer._complete_error|s_y'22..I66NN9k::  eW CCC Cr2c|s||||S|td}t ||S)Nr) isOpenID2rrrr!)rIrjrXrrs r0_complete_setup_neededz&GenericConsumer._complete_setup_neededsR  "" ?(((A>> >  4DEE"8^<<> W_Y7788 W_];;<< !QKK  D)D/11uu2ts'* AAAc|r,|td}|t|dSdS)zCheck an id_res message to see if it is a checkid_immediate cancel response. @raises SetupNeededError: if it is a checkid_immediate cancellation rN)rrrr)rIrjrs r0rz!GenericConsumer._checkSetupNeededsP      7$^^J8HIIN)&~666 7 7))r2c d|||||s.td|d|td|||}t d|jd|td| ||j| |||tdt}| d}d |D}t|||S) aHandle id_res responses that are not cancellations of immediate mode requests. @param message: the response paramaters. @param endpoint: the discovered endpoint object. May be None. @raises ProtocolError: If the message contents are not well-formed according to the OpenID specification. This includes missing fields or not signing fields that should be signed. @raises DiscoveryFailure: If the subject of the id_res message does not match the supplied endpoint, and discovery on the identifier in the message fails (this should only happen when using OpenID 2) @returntype: L{Response} z.return_to does not match return URL. Expected , got rzReceived id_res response from z using association assoc_handlesigned,cg|]}d|zS)zopenid.ru).0rs r0 z,GenericConsumer._doIdRes..s<<<1Q<<??? gx000!..HjII%++C00 << <<< x-@@@r2cB|t|jS)aBExtract the nonce from an OpenID 1 response. Return the nonce from the BARE_NS since we independently check the return_to arguments are the same as those in the response message. See the openid1_nonce_query_arg_name class variable @returns: The nonce as a string or None )rrr)rIrjrXs r0_idResGetNonceOpenID1z%GenericConsumer._idResGetNonceOpenID1s~~gt'HIIIr2c|r|||}d}n"|td}|j}|t d t |\}}n$#t$r}t d|d}~wwxYw|j+|j |||st ddSdS)Nresponse_noncezNonce missing from responsezMalformed nonce: z"Nonce already used or out of range) rrrrr.r[ splitNoncerZrJuseNonce)rIrjrXnoncer. timestampsaltrPs r0rz GenericConsumer._idResCheckNonces      -..wAAEJJNN:/?@@E!,J = =>> > A(//OItt A A A- ?@@ @ A J "J'' ItDD # DEE E # " " "s"A55 B?BBc\|td}|jd}n|j||}|rD|jdkrt d|d||st ddS|||st ddS)NrrzAssociation with z expiredz Bad signaturez"Server denied check_authentication)rrrJgetAssociation expiresInr[checkMessageSignature _checkAuth)rIrjr.rrs r0rz$GenericConsumer._idResCheckSignatures~~i@@ : EEJ--j,GGE  J!## $m%/ZZ%3444..w77 5#O444 5 5??7J77 J#$HIII J Jr2cgd}ddg}t|dgzt|dgzi}t|gdzt|i}||D]/}|t|st d|0|tdt}|d}||D]4}|t|r||vrt d |d 5dS) N)rrsigrridentity op_endpoint)r rrrzMissing required field rr"z " not signed) rrgetOpenIDNamespacehasKeyrr[rrr) rIrj basic_fieldsbasic_sig_fieldsrequire_fields require_sigsfieldrrs r0rz$GenericConsumer._idResCheckForFields0sGFEE '4  6  |3    K K K L    $G$>$>$@$@A M ME>>)U33 M#m55$KLLL M"..HjII%++C00 !'"<"<">">? C CE~~i// CE4L4L#m$ABBB C Cr2ctj|}|td}|t dt |}|d}t |}|D]O\}} ||}||krd} t | |||fz,#t$rd} t | ||fzwxYw|t} | D]} | |vrt d| dd  dS) z]Verify that the arguments in the return_to URL are present in this response. rNzResponse has no return_toz9parameter %s value %r does not match return_to's value %rz+return_to parameter %s absent from query %rz Parameter rz not in return_to URL) r rcrrr[rrregetArgsritems) rhrjr parsed_urlrt_query parsed_argsrt_keyrt_valuevalueformat bare_argspairs r0rz#GenericConsumer._verifyReturnToArgsSsW &u--NN9k::   ;<< <i(( a=)) !, > > FH >f u$$5F'&%1J(JKKK% > > >F#Ffe_$<=== > OOG,, OO%% 1 1D;&&#m%)!WWW%0111' 1 1s /%B!B6Nc|tkr|||S|||S)a Extract the information from an OpenID assertion message and verify it against the original @param endpoint: The endpoint that resulted from doing discovery @param resp_msg: The id_res message object @returns: the verified endpoint )rr_verifyDiscoveryResultsOpenID2_verifyDiscoveryResultsOpenID1)rIresp_msgrXs r0rz'GenericConsumer._verifyDiscoveryResults{sG  & & ( (J 6 666xJJ J66xJJ Jr2cBt}tg|_|td|_|td|_|tdt|_|j|jtd|j|jtd|jtj |jS|s7t d| |j|g}n|r7t d| |j|g}n |||nw#t$rj}tdt#|zt d | |j|g}Yd}~nd}~wwxYw|j|jkr t%j|}|j|_|S) Nrrrz4openid.identity is present without openid.claimed_idz4openid.claimed_id is present without openid.identityz'No pre-discovered information supplied.z>Pre-discovered information based on OP-ID; need to rediscover.6Error attempting to use stored discovery information: 'Attempting discovery to verify endpoint)rr rrrrlocal_idrr.r[fromOPEndpointURLrr_discoverAndVerifyisOPIdentifier_verifyDiscoverySinglerr\r)rIr1rXto_matches r0r/z.GenericConsumer._verifyDiscoveryResultsOpenID2s2(**-.&ooj,GG$OOJ CC'ooj-.8::   'H,=,IFHH H!-(2C2KFHH H  ((:8;NOO O  ? KKA B B B..x/BXJOOHH  $ $ & & ? KKP   ..x/BXJOOHH  ?++Hh????  ? ? ?  LFF EFFF2283F4<:??  ?  ("5 5 5y**H"*"5H s!E88 G,A G''G,c|t|j}||td| ||j}t }t g|_|td|_ ||_|j tdtj |}tg|_| | ||n&#t$r| ||YnwxYw|S#t$rN}tdt#|ztdYd}~nd}~wwxYw||||gS)NzWhen using OpenID 1, the claimed ID must be supplied, either by passing it through as a return_to parameter or by using a session, and supplied to the GenericConsumer as the argument to complete()rz&Missing required field openid.identityr3r4)rrr RuntimeErrorrrr rrr5r[rr r9rrrr\rr7)rIr1rXrr: to_match_1_0r;s r0r0z.GenericConsumer._verifyDiscoveryResultsOpenID1s__W%)%KMM    2011 1  !j&8!,J(**-.$OOJ CC(   $ HII Iy** "1!2    H//(CCCC&HHH//,GGGGGH  ! G G G  LFF EFFFFFFFF  G&&zHl3KLLLs7<CC; C63C;5C66C;; EAEEc`|jD]'}||st||(t|j\}}||jkrt d|d|j||kr9t d|d||j)|tks JddS|j|jkrt d|jd|jdS)aVerify that the given endpoint matches the information extracted from the OpenID assertion, and raise an exception if there is a mismatch. @type endpoint: openid.consumer.discover.OpenIDServiceEndpoint @type to_match: openid.consumer.discover.OpenIDServiceEndpoint @rtype: NoneType @raises ProtocolError: when the endpoint does not match the discovered information. z:Claimed ID does not match (different subjects!), Expected rzlocal_id mismatch. Expected NzThe code calling this must ensure that OpenID 2 responses have a non-none `openid.op_endpoint' and that it is set as the `server_url' attribute of the `to_match' endpoint.zOP Endpoint mismatch. Expected ) r usesExtensionrrrr[ getLocalIDr.preferredNamespacer)rIrXr:type_uridefragged_claimed_idrs r0r9z&GenericConsumer._verifyDiscoverySingles!* : :H))(33 :%h999 : #,H,?"@"@a 8#6 6 6-&%%x':':<== =    H$7$7$9$9 9 9-!)!4!4!6!6!6!68K8K8M8M8M!OPP P   &..00J>>>(?>>>>  H$7 7 7-!)!4!4!4h6I6I!KLL L8 7r2ctd|||\}}|std|d||||S)a`Given an endpoint object created from the information in an OpenID response, perform discovery and verify the discovery results, returning the matching endpoint that is the result of doing that discovery. @type to_match: openid.consumer.discover.OpenIDServiceEndpoint @param to_match: The endpoint whose information we're confirming @rtype: openid.consumer.discover.OpenIDServiceEndpoint @returns: The result of performing discovery on the claimed identifier in `to_match' @raises DiscoveryFailure: when discovery fails. zPerforming discovery on zNo OpenID information found at N)rrrOr _verifyDiscoveredServices)rIrto_match_endpointsrservicess r0r7z"GenericConsumer._discoverAndVerifys~  JJABBBnnZ00 8 9""$.J$23799 9--j(.@BB Br2chg}|D]\}|D]W} ||||ccS#t$r,}|t|Yd}~Pd}~wwxYw]td||D]}td|z t d|d)zSee @L{_discoverAndVerify}Nz#Discovery verification failure for z * Endpoint mismatch: z-No matching endpoint found after discovering )r9r[appendr\rrr ) rIrrHrGfailure_messagesrXto_match_endpointrPfailure_messages r0rFz)GenericConsumer._verifyDiscoveredServices6s   & &H%7 $ $!$//:KLLL $OOOOO %666$++CHH555555556 $ LLL%:) * * *#3 I I 5GHHHH"" $&& &s( A"AAc^td||}|dS |||}|||S#t jtf$r5}|jd}t d|zYd}~dSd}~wwxYw)zMake a check_authentication request to verify this message. @returns: True if the request is valid. @rtype: bool z!Using OpenID check_authenticationNFrzcheck_authentication failed: %s) rr_createCheckAuthRequest _makeKVPost_processCheckAuthResponserr:r8rr)rIrjr.rr;r;e0s r0rzGenericConsumer._checkAuthQs  7888..w77 ?5 H''<C D D D55555 sA!!B,7*B''B,c|td}|rt|trt |d}|dD]S}t |||}| t d|dST| }| tdd|S) zYGenerate a check_authentication request message given an id_res message. rzutf-8)encodingrNzMissing signed field rcheck_authentication) rr isinstancebytesr\rrr getAliasedArgrsetArg)rIrjrkvalcheck_auth_messages r0rOz'GenericConsumer._createCheckAuthRequestds 844  &%(( 7Vg666\\#&&   A++A..;KKKQQ ABBB44%\\^^!!)V5KLLL!!r2cp|tdd}|td}|Ztd||jtdn|j|||dkrdStd d S) zzProcess the response message from a check_authentication request, invalidating associations if requested. is_validfalseinvalidate_handleNz)Received "invalidate_handle" from server z3Unexpectedly got invalidate_handle without a store!trueTz0Server responds that checkAuth call is not validF)rrrrrJrremoveAssociation)rIr;r.r^r`s r0rQz)GenericConsumer._processCheckAuthResponseys??9j'BB$OOI7JKK  ( KKK$*( ) ) )z! )**** ,,Z9JKKK v  4 LLK L L L5r2c|j|j}| |jdkr7||}| |j|j||S)aGet an association for the endpoint's server_url. First try seeing if we have a good association in the store. If we do not, then attempt to negotiate an association with the server. If we negotiate a good association, it will get stored. @returns: A valid association for the endpoint's server_url or None @rtype: openid.association.Association or NoneType Nr)rJrr.r_negotiateAssociationstoreAssociationrIrXrs r0rzGenericConsumer._getAssociationsf ))(*=>> =EOq00..x88E  ++H,?GGG r2c |j\}} ||||}|S#t$r}||||}|h|\}} ||||}|cYd}~S#t$r7}t d|jd|d|Yd}~Yd}~dSd}~wwxYwYd}~dSd}~wwxYw)zMake association requests to the server, attempting to create a new association. @returns: a new association object @rtype: L{openid.association.Association} NzServer z6 refused its suggested association type: session_type=z , assoc_type=)rlgetAllowedType_requestAssociationr8 _extractSupportedAssociationTyperrr.)rIrX assoc_typerrrPsupportedTypess r0rdz%GenericConsumer._negotiateAssociationsL$(?#A#A#C#C L ,,Xz-9;;E0L- ! ! !!BBXz++N)+9( L ! 44Xz5ACCE!LLLLLL#   LLL%///zzKLLL 444444444 *))))) !sE7 C C A>7C8C > B?(B:0C:B??CC c0|jdks|jr,td|jd|jdStd|d|j|jtd}|jtd}||tddS|j ||s#d }t|||fzdS||fS) a,Handle ServerErrors resulting from association requests. @returns: If server replied with an C{unsupported-type} error, return a tuple of supported C{association_type}, C{session_type}. Otherwise logs the error and returns None. @rtype: tuple or None zunsupported-typez1Server error when requesting an association from : NzUnsupported association type rkrzTServer responded with unsupported association session but did not supply a fallback.zPServer sent unsupported session/association type: session_type=%s, assoc_type=%s) rrjrrrr.rrrrl isAllowed)rI server_errorrXrkrr=s r0rjz0GenericConsumer._extractSupportedAssociationTypesA  "&8 8 8#--// 9 LLL$$$l&=&=? @ @ @4  !zz<#:#:> ? ? ? ")00LII #+229nMM  !5 LLC D D D4**:|DD ,4C LL j99 : : :4|+ +r2c||||\}} |||j}n:#tj$r(}t d|Yd}~dSd}~wwxYw |||}|S#t$r0}t d|jd|Yd}~dSd}~wt$r0}t d|jd|Yd}~dSd}~wwxYw)aMake and process one association request to this endpoint's OP endpoint URL. @returns: An association object or None if the association processing failed. @raises ServerError: when the remote OpenID server returns an error. z!openid.associate request failed: Nz,Missing required parameter in response from rnz%Protocol error parsing response from ) _createAssociateRequestrPr.rr:rr_extractAssociationrer[) rIrXrkr assoc_sessionrr;rPrs r0riz#GenericConsumer._requestAssociationsc#:: j,00 t ''h.ABBHH)       ccL M M M44444  ,,X}EEEL       $$$cc+ , , ,44444       '222CC9 : : :44444 s98A/A**A/3B C=%C C= %C88C=cF|j|}|}d|d}|s t|d<|r |jdkr |j|d<||t j|}||fS)aCreate an association request for the given assoc_type and session_type. @param endpoint: The endpoint whose server_url will be queried. The important bit about the endpoint is whether it's in compatiblity mode (OpenID 1.1) @param assoc_type: The association type that the request should ask for. @type assoc_type: str @param session_type: The session type that should be used in the association request. The session_type is used to create an association session object, and that session object is asked for any additional fields that it needs to add to the request. @type session_type: str @returns: a pair of the association session object and the request message that will be sent to the server. @rtype: (association session type (depends on session_type), openid.message.Message) associate)rrknsrr) session_typescompatibilityModerrrrr fromOpenIDArgs)rIrXrkrsession_type_classrtrrjs r0rrz'GenericConsumer._createAssociateRequests0"/ =**,,  $   ))++ $#DJ**,, >*o==#0#=D  M,,..///(..g%%r2c|td}|dkrtdn |dks|d}|S)aGiven an association response message, extract the OpenID 1.X session type. This function mostly takes care of the 'no-encryption' default behavior in OpenID 1. If the association type is plain-text, this function will return 'no-encryption' @returns: The association type for this message @rtype: str @raises KeyError: when the session_type field is absent. rrz0OpenID server sent "no-encryption"for OpenID 1.Xr )rrrwarning)rIassoc_responsers r0_getOpenID1SessionTypez&GenericConsumer._getOpenID1SessionType@sc"&,,ZHH  ? * * NN- . . . .R  <#7*Lr2ch|tdt}|tdt}|tdt} t|}n$#t$r}t d|d}~wwxYw|r||}n!|tdt}|j |krF|r|dkrt}nd} | |j |fz} t | ||j vrd } t | |j |fz | |} n-#t$r }d } t | |j |fzd}~wwxYwtj||| |S) aAttempt to extract an association from the response, given the association response message and the established association session. @param assoc_response: The association response message from the server @type assoc_response: openid.message.Message @param assoc_session: The association session object that was used when making the request @type assoc_session: depends on the session type of the request @raises ProtocolError: when data is malformed @raises KeyError: when a field is missing @rtype: openid.association.Association rkr expires_inzInvalid expires_in field: Nrrz*Session type mismatch. Expected %r, got %rz2Unsupported assoc_type for session %s returned: %sz%Malformed response for %s session: %s)rrrintrZr[rrrrrrrr fromExpiresIn) rIr~rtrkrexpires_in_strrrPrr=rjsecrets r0rsz#GenericConsumer._extractAssociationfs($**9lJOO %,,Y-799 (..y,/9;; J^,,JJ J J J-## HII I J  # # % % =66~FFLL)00^1;==L  % 5 5((** - O33 !9 : : C!;\ JJ#G,,, ]> > >FC}'A:&N NOO O  I"00@@FF I I I9C}'A3&G GHH H I(\6)355 5s0%A55 B?BBE00 F:FFro)/rprqrrrsrrrwrrrxrtrrOrLrVrdrrrrrrr1rPrrrrrrrrr/r0r9r7rFrrOrQrrdrjrirrrrsrur2r0rDrD6s  $$3 )=%471M  X&&I444$ 8 8 8(((CCC=== 6 6 6OOO:,z**K 7 7 7*A*A*AX J J JFFF*JJJ8!C!C!CF$1$1$1L',':;; K K K K999v(M(M(MT.L.L.L`BBB.&&&6HHH&"""*,*$$$L',',',R@+&+&+&Z$$$LK5K5K5K5K5r2rDc\eZdZdZdZdZdZdZd dZd d Z dd Z dd Z d Z dS)raAn object that holds the state necessary for generating an OpenID authentication request. This object holds the association with the server and the discovered information with which the request will be made. It is separate from the consumer because you may wish to add things to the request before sending it on its way to the server. It also has serialization options that let you encode the authentication request as a URL or as a form POST. c||_||_i|_t||_d|_dS)a Creates a new AuthRequest object. This just stores each argument in an appropriately named field. Users of this library should not create instances of this class. Instances of this class are created by the library when needed. FN)rrXrr rBrj _anonymousrfs r0rLzAuthRequest.__init__s@    x::<<== r2ch|r(|jrtd||_dS)aSet whether this request should be made anonymously. If a request is anonymous, the identifier will not be sent in the request. This is only useful if you are making another kind of request with an extension in this request. Anonymous requests are not allowed when the request is made with OpenID 1. @raises ValueError: when attempting to set an OpenID1 request as anonymous z|j|||dS)aAdd an extension argument to this OpenID authentication request. Use caution when adding arguments, because they will be URL-escaped and appended to the redirect URL, which can easily get quite long. @param namespace: The namespace for the extension. For example, the simple registration extension uses the namespace C{sreg}. @type namespace: str @param key: The key within the extension namespace. For example, the nickname field in the simple registration extension's key is C{nickname}. @type key: str @param value: The value to provide to the server for this argument. @type value: str N)rjrY)rI namespacekeyr*s r0addExtensionArgzAuthRequest.addExtensionArgs$2 IsE22222r2NFc |rtj||j}nO|rtd|jrtd|jrtd|rd}nd}|j}|rd}nd}|t||d|d |i|j s|j r tx}}n%|j }|j j}|td ||r|t"d ||jr6|td |jjd |jj} nd} t(d|d|j jd| |S)a2Produce a L{openid.message.Message} representing this request. @param realm: The URL (or URL pattern) that identifies your web site to the user when she is authorizing it. @type realm: str @param return_to: The URL that the OpenID provider will send the user back to after attempting to verify her identity. Not specifying a return_to URL means that the user will not be returned to the site issuing the request upon its completion. @type return_to: str @param immediate: If True, the OpenID provider is to send back a response immediately, useful for behind-the-scenes authentication attempts. Otherwise the OpenID provider may engage the user before providing a response. This is the default case, as the user may need to provide credentials or approve the request before a positive response can be sent. @type immediate: bool @returntype: L{openid.message.Message} z7"return_to" is mandatory when using "checkid_immediate"z."return_to" is mandatory for OpenID 1 requestszJextra "return_to" arguments were specified, but no return_to was specifiedcheckid_immediate checkid_setup trust_rootrealmrrrrrzwith association zusing stateless mode.z Generated z request to  )r appendArgsrrZrjrr updateArgsrrrXr8rrArrYrrrhandlerrr.) rIrr immediaterrj realm_keyrrequest_identity assoc_log_msgs r0 getMessagezAuthRequest.getMessages:  ?*9d6IJJII  ?IKK K \ # # % % ?MNN N   ?>?? ?  #&DD"D,##%%      $III9 u D '     E}++-- 61BA --#'=#;#;#=#= !]5  NN9j2B C C C  "" Ez<DDD : 4 NN9ndj6G H H H H59Z5F5FIMM3M ddDM444mmE F F Fr2cn||||}||jjS)ahReturns a URL with an encoded OpenID request. The resulting URL is the OpenID provider's endpoint URL with parameters appended as query arguments. You should redirect the user agent to this URL. OpenID 2.0 endpoints also accept POST requests, see C{L{shouldSendRedirect}} and C{L{formMarkup}}. @param realm: The URL (or URL pattern) that identifies your web site to the user when she is authorizing it. @type realm: str @param return_to: The URL that the OpenID provider will send the user back to after attempting to verify her identity. Not specifying a return_to URL means that the user will not be returned to the site issuing the request upon its completion. @type return_to: str @param immediate: If True, the OpenID provider is to send back a response immediately, useful for behind-the-scenes authentication attempts. Otherwise the OpenID provider may engage the user before providing a response. This is the default case, as the user may need to provide credentials or approve the request before a positive response can be sent. @type immediate: bool @returns: The URL to redirect the user agent to. @returntype: str )rtoURLrXr.)rIrrrrjs r0 redirectURLzAuthRequest.redirectURLYs1L//%I>>}}T]5666r2cp||||}||jj|S)auGet html for a form to submit this request to the IDP. @param form_tag_attrs: Dictionary of attributes to be added to the form tag. 'accept-charset' and 'enctype' have defaults that can be overridden. If a value is supplied for 'action' or 'method', it will be replaced. @type form_tag_attrs: {unicode: unicode} )r toFormMarkuprXr.)rIrrrform_tag_attrsrjs r0 formMarkupzAuthRequest.formMarkups4//%I>>##DM$} @ivar signed_fields: The arguments in the server's response that were signed and verified. @cvar status: SUCCESS NcP||_|j|_||_|g}||_dSro)rXrrfrjr)rIrXrjrs r0rLzSuccessResponse.__init__s6! $/  M*r2c4|jS)zVWas this authentication response an OpenID 1 authentication response? )rjrrs r0rzSuccessResponse.isOpenID1s|%%'''r2cF|j|||jvS)z]Return whether a particular key is signed, regardless of its namespace alias )rjgetKeyr)rIns_urins_keys r0isSignedzSuccessResponse.isSigneds$|""6622d6HHHr2cj|||r|j|||S|S)zYReturn the specified signed field if available, otherwise return default )rrjr)rIrrdefaults r0 getSignedzSuccessResponse.getSigneds9 == ( ( <&&vvw?? ?Nr2c|j|}|D]<}|||s$td|d|ddS=|S)zGet signed arguments from the response message. Return a dict of all arguments in the specified namespace. If any of the arguments are not signed, return None. zSuccessResponse.getSignedNS: (z, z ) not signed.N)rjr#keysrrr)rIrmsg_argsrs r0 getSignedNSzSuccessResponse.getSignedNSs <''//==??  C==--  VVSSS"###tt   r2cd|r||S|j|S)awReturn response arguments in the specified namespace. @param namespace_uri: The namespace URI of the arguments to be returned. @param require_signed: True if the arguments should be among those signed in the response, False if you don't care. If require_signed is True and the arguments are not signed, return None. )rrjr#)rI namespace_urirequire_signeds r0extensionResponsez!SuccessResponse.extensionResponses6  7##M22 2<'' 66 6r2c8|tdS)apGet the openid.return_to argument from this response. This is useful for verifying that this request was initiated by this consumer. @returns: The return_to URL supplied to the server on the initial request, or C{None} if the response did not contain an C{openid.return_to} argument. @returntype: str r)rrrs r0 getReturnTozSuccessResponse.getReturnTo(s~~i555r2c|j|jko?|j|jko/|j|jko|j|jko|j|jkSro)rXrfrjrr7rIothers r0__eq__zSuccessResponse.__eq__6s_%.0."e&88...#u'::. ,  /r2c||k Srorurs r0__ne__zSuccessResponse.__ne__=sEM""r2c \d|jjd|jjd|jd|jd S)Nrr id=z signed=r)rrqrprfrrs r0__repr__zSuccessResponse.__repr__@s@ N % % %t~'>'>'>    t1113 3r2ro)rprqrrrsr$r7rLrrrrrrrrrrur2r0r r s(F + + + +((( III  777" 6 6 6///###33333r2r c$eZdZdZeZddZdZdS)r#aA response with a status of FAILURE. Indicates that the OpenID protocol has failed. This could be locally or remotely triggered. @ivar identity_url: The identity URL for which authenitcation was attempted, if it can be determined. Otherwise, None. @ivar message: A message indicating why the request failed, if one is supplied. otherwise, None. @cvar status: FAILURE NcZ||||_||_||_dSro)rrjrr)rIrXrjrrs r0rLzFailureResponse.__init__Us/ """  "r2c \d|jjd|jjd|jd|jd S)Nrrrz message=r)rrqrprfrjrs r0rzFailureResponse.__repr__[s@-1^-F-F-F-1^-D-D-D-1->->-> N Nr2)NNN)rprqrrrsr%r7rLrrur2r0r#r#FsM  F#### NNNNNr2r#ceZdZdZeZdZdS)r"aA response with a status of CANCEL. Indicates that the user cancelled the OpenID authentication request. @ivar identity_url: The identity URL for which authenitcation was attempted, if it can be determined. Otherwise, None. @cvar status: CANCEL c0||dSro)rrs r0rLzCancelResponse.__init__ms """""r2N)rprqrrrsr&r7rLrur2r0r"r"as4F#####r2r"ceZdZdZeZddZdS)r!a8A response with a status of SETUP_NEEDED. Indicates that the request was in immediate mode, and the server is unable to authenticate the user without further interaction. @ivar identity_url: The identity URL for which authenitcation was attempted. @ivar setup_url: A URL that can be used to send the user to the server to set up for authentication. The user should be redirected in to the setup_url, either in the current window or in a new browser window. C{None} in OpenID 2.0. @cvar status: SETUP_NEEDED Nc>||||_dSro)r setup_url)rIrXrs r0rLzSetupNeededResponse.__init__s! """"r2ro)rprqrrrsr'r7rLrur2r0r!r!qs9  F######r2r!)Crsrlogging urllib.parserrropenidropenid.consumer.discoverrrr r r r openid.messager rrrrrrrropenid.associationrrr openid.dhropenid.store.noncerrr openid.yadis.managerrr__all__ getLoggerrprr1r,objectrrwrrrrrZr[rr8rDrr%r$r&r'rr r#r"r!rur2r0rszzx 7777777777IIIIIIIIIIIIIIII,,,,,,,,,,,,,,,,,,######;;;;;;;;******     8 $ $ 4 4 4 4ANANANANANvANANANHPPPPPvPPPD*****)I*** - - - - -v - - ------y---BBBBBJBBB     m    +++++)+++*{ 5{ 5{ 5{ 5{ 5f{ 5{ 5{ 5|s1s1s1s1s1&s1s1s1l    v>t3t3t3t3t3ht3t3t3nNNNNNhNNN6 # # # # #X # # # #####(#####r2