]> projects.mako.cc - twitter-api-cdsw-solutions/blob - oauthlib/oauth2/rfc6749/clients/web_application.py
fixed bugs and python3 updates for the twitter projects
[twitter-api-cdsw-solutions] / oauthlib / oauth2 / rfc6749 / clients / web_application.py
1 # -*- coding: utf-8 -*-
2 """
3 oauthlib.oauth2.rfc6749
4 ~~~~~~~~~~~~~~~~~~~~~~~
5
6 This module is an implementation of various logic needed
7 for consuming and providing OAuth 2.0 RFC6749.
8 """
9 from __future__ import absolute_import, unicode_literals
10
11 from .base import Client
12 from ..parameters import prepare_grant_uri, prepare_token_request
13 from ..parameters import parse_authorization_code_response
14 from ..parameters import parse_token_response
15
16
17 class WebApplicationClient(Client):
18
19     """A client utilizing the authorization code grant workflow.
20
21     A web application is a confidential client running on a web
22     server.  Resource owners access the client via an HTML user
23     interface rendered in a user-agent on the device used by the
24     resource owner.  The client credentials as well as any access
25     token issued to the client are stored on the web server and are
26     not exposed to or accessible by the resource owner.
27
28     The authorization code grant type is used to obtain both access
29     tokens and refresh tokens and is optimized for confidential clients.
30     As a redirection-based flow, the client must be capable of
31     interacting with the resource owner's user-agent (typically a web
32     browser) and capable of receiving incoming requests (via redirection)
33     from the authorization server.
34     """
35
36     def __init__(self, client_id, code=None, **kwargs):
37         super(WebApplicationClient, self).__init__(client_id, **kwargs)
38         self.code = code
39
40     def prepare_request_uri(self, uri, redirect_uri=None, scope=None,
41                             state=None, **kwargs):
42         """Prepare the authorization code request URI
43
44         The client constructs the request URI by adding the following
45         parameters to the query component of the authorization endpoint URI
46         using the "application/x-www-form-urlencoded" format, per `Appendix B`_:
47
48         :param redirect_uri:  OPTIONAL. The redirect URI must be an absolute URI
49                               and it should have been registerd with the OAuth
50                               provider prior to use. As described in `Section 3.1.2`_.
51
52         :param scope:  OPTIONAL. The scope of the access request as described by
53                        Section 3.3`_. These may be any string but are commonly
54                        URIs or various categories such as ``videos`` or ``documents``.
55
56         :param state:   RECOMMENDED.  An opaque value used by the client to maintain
57                         state between the request and callback.  The authorization
58                         server includes this value when redirecting the user-agent back
59                         to the client.  The parameter SHOULD be used for preventing
60                         cross-site request forgery as described in `Section 10.12`_.
61
62         :param kwargs:  Extra arguments to include in the request URI.
63
64         In addition to supplied parameters, OAuthLib will append the ``client_id``
65         that was provided in the constructor as well as the mandatory ``response_type``
66         argument, set to ``code``::
67
68             >>> from oauthlib.oauth2 import WebApplicationClient
69             >>> client = WebApplicationClient('your_id')
70             >>> client.prepare_request_uri('https://example.com')
71             'https://example.com?client_id=your_id&response_type=code'
72             >>> client.prepare_request_uri('https://example.com', redirect_uri='https://a.b/callback')
73             'https://example.com?client_id=your_id&response_type=code&redirect_uri=https%3A%2F%2Fa.b%2Fcallback'
74             >>> client.prepare_request_uri('https://example.com', scope=['profile', 'pictures'])
75             'https://example.com?client_id=your_id&response_type=code&scope=profile+pictures'
76             >>> client.prepare_request_uri('https://example.com', foo='bar')
77             'https://example.com?client_id=your_id&response_type=code&foo=bar'
78
79         .. _`Appendix B`: http://tools.ietf.org/html/rfc6749#appendix-B
80         .. _`Section 2.2`: http://tools.ietf.org/html/rfc6749#section-2.2
81         .. _`Section 3.1.2`: http://tools.ietf.org/html/rfc6749#section-3.1.2
82         .. _`Section 3.3`: http://tools.ietf.org/html/rfc6749#section-3.3
83         .. _`Section 10.12`: http://tools.ietf.org/html/rfc6749#section-10.12
84         """
85         return prepare_grant_uri(uri, self.client_id, 'code',
86                                  redirect_uri=redirect_uri, scope=scope, state=state, **kwargs)
87
88     def prepare_request_body(self, client_id=None, code=None, body='',
89                              redirect_uri=None, **kwargs):
90         """Prepare the access token request body.
91
92         The client makes a request to the token endpoint by adding the
93         following parameters using the "application/x-www-form-urlencoded"
94         format in the HTTP request entity-body:
95
96         :param client_id:   REQUIRED, if the client is not authenticating with the
97                             authorization server as described in `Section 3.2.1`_.
98
99         :param code:    REQUIRED. The authorization code received from the
100                         authorization server.
101
102         :param redirect_uri:    REQUIRED, if the "redirect_uri" parameter was included in the
103                                 authorization request as described in `Section 4.1.1`_, and their
104                                 values MUST be identical.
105
106         :param kwargs: Extra parameters to include in the token request.
107
108         In addition OAuthLib will add the ``grant_type`` parameter set to
109         ``authorization_code``.
110
111         If the client type is confidential or the client was issued client
112         credentials (or assigned other authentication requirements), the
113         client MUST authenticate with the authorization server as described
114         in `Section 3.2.1`_::
115
116             >>> from oauthlib.oauth2 import WebApplicationClient
117             >>> client = WebApplicationClient('your_id')
118             >>> client.prepare_request_body(code='sh35ksdf09sf')
119             'grant_type=authorization_code&code=sh35ksdf09sf'
120             >>> client.prepare_request_body(code='sh35ksdf09sf', foo='bar')
121             'grant_type=authorization_code&code=sh35ksdf09sf&foo=bar'
122
123         .. _`Section 4.1.1`: http://tools.ietf.org/html/rfc6749#section-4.1.1
124         .. _`Section 3.2.1`: http://tools.ietf.org/html/rfc6749#section-3.2.1
125         """
126         code = code or self.code
127         return prepare_token_request('authorization_code', code=code, body=body,
128                                      client_id=self.client_id, redirect_uri=redirect_uri, **kwargs)
129
130     def parse_request_uri_response(self, uri, state=None):
131         """Parse the URI query for code and state.
132
133         If the resource owner grants the access request, the authorization
134         server issues an authorization code and delivers it to the client by
135         adding the following parameters to the query component of the
136         redirection URI using the "application/x-www-form-urlencoded" format:
137
138         :param uri: The callback URI that resulted from the user being redirected
139                     back from the provider to you, the client.
140         :param state: The state provided in the authorization request.
141
142         **code**
143             The authorization code generated by the authorization server.
144             The authorization code MUST expire shortly after it is issued
145             to mitigate the risk of leaks. A maximum authorization code
146             lifetime of 10 minutes is RECOMMENDED. The client MUST NOT
147             use the authorization code more than once. If an authorization
148             code is used more than once, the authorization server MUST deny
149             the request and SHOULD revoke (when possible) all tokens
150             previously issued based on that authorization code.
151             The authorization code is bound to the client identifier and
152             redirection URI.
153
154         **state**
155                 If the "state" parameter was present in the authorization request.
156
157         This method is mainly intended to enforce strict state checking with
158         the added benefit of easily extracting parameters from the URI::
159
160             >>> from oauthlib.oauth2 import WebApplicationClient
161             >>> client = WebApplicationClient('your_id')
162             >>> uri = 'https://example.com/callback?code=sdfkjh345&state=sfetw45'
163             >>> client.parse_request_uri_response(uri, state='sfetw45')
164             {'state': 'sfetw45', 'code': 'sdfkjh345'}
165             >>> client.parse_request_uri_response(uri, state='other')
166             Traceback (most recent call last):
167                 File "<stdin>", line 1, in <module>
168                 File "oauthlib/oauth2/rfc6749/__init__.py", line 357, in parse_request_uri_response
169                     back from the provider to you, the client.
170                 File "oauthlib/oauth2/rfc6749/parameters.py", line 153, in parse_authorization_code_response
171                     raise MismatchingStateError()
172             oauthlib.oauth2.rfc6749.errors.MismatchingStateError
173         """
174         response = parse_authorization_code_response(uri, state=state)
175         self._populate_attributes(response)
176         return response

Benjamin Mako Hill || Want to submit a patch?