gdata.gauth
index
/usr/local/svn/gdata-python-client/src/gdata/gauth.py

# Copyright (C) 2009 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

 
Modules
       
atom
gdata.experimental_oauth
random
time
urllib

 
Classes
       
__builtin__.object
AuthSubToken
ClientLoginToken

 
class AuthSubToken(__builtin__.object)
     Methods defined here:
ModifyRequest = modify_request(self, http_request)
__init__(self, token_string, scopes=None)
modify_request(self, http_request)

Static methods defined here:
FromUrl = from_url(str_or_uri)
Creates a new AuthSubToken using information in the URL.
 
Uses auth_sub_string_from_url.
 
Args:
  str_or_uri: The current page's URL (as a str or atom.http_core.Uri)
              which should contain a token query parameter since the
              Google auth server redirected the user's browser to this
              URL.
from_url(str_or_uri)
Creates a new AuthSubToken using information in the URL.
 
Uses auth_sub_string_from_url.
 
Args:
  str_or_uri: The current page's URL (as a str or atom.http_core.Uri)
              which should contain a token query parameter since the
              Google auth server redirected the user's browser to this
              URL.

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class ClientLoginToken(__builtin__.object)
     Methods defined here:
ModifyRequest = modify_request(self, http_request)
__init__(self, token_string)
modify_request(self, http_request)

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
Functions
       
AuthSubStringFromUrl = auth_sub_string_from_url(url, scopes_param_prefix='auth_sub_scopes')
Finds the token string (and scopes) after the browser is redirected.
 
After the Google Accounts AuthSub pages redirect the user's broswer back to
the web application (using the 'next' URL from the request) the web app must
extract the token from the current page's URL. The token is provided as a
URL parameter named 'token' and if generate_auth_sub_url was used to create
the request, the token's valid scopes are included in a URL parameter whose
name is specified in scopes_param_prefix.
 
Args:
  url: atom.url.Url or str representing the current URL. The token value
       and valid scopes should be included as URL parameters.
  scopes_param_prefix: str (optional) The URL parameter key which maps to
                       the list of valid scopes for the token.
 
Returns:
  A tuple containing the token value as a string, and a tuple of scopes 
  (as atom.http_core.Uri objects) which are URL prefixes under which this
  token grants permission to read and write user data.
  (token_string, (scope_uri, scope_uri, scope_uri, ...))
  If no scopes were included in the URL, the second value in the tuple is
  None. If there was no token param in the url, the tuple returned is 
  (None, None)
GenerateClientLoginRequestBody = generate_client_login_request_body(email, password, service, source, account_type='HOSTED_OR_GOOGLE', captcha_token=None, captcha_response=None)
Creates the body of the autentication request
 
See http://code.google.com/apis/accounts/AuthForInstalledApps.html#Request
for more details.
 
Args:
  email: str
  password: str
  service: str
  source: str
  account_type: str (optional) Defaul is 'HOSTED_OR_GOOGLE', other valid
      values are 'GOOGLE' and 'HOSTED'
  captcha_token: str (optional)
  captcha_response: str (optional)
 
Returns:
  The HTTP body to send in a request for a client login token.
GetCaptchaChallenge = get_captcha_challenge(http_body, captcha_base_url='http://www.google.com/accounts/')
Returns the URL and token for a CAPTCHA challenge issued by the server.
 
Args:
  http_body: str The body of the HTTP response from the server which 
      contains the CAPTCHA challenge.
  captcha_base_url: str This function returns a full URL for viewing the 
      challenge image which is built from the server's response. This
      base_url is used as the beginning of the URL because the server
      only provides the end of the URL. For example the server provides
      'Captcha?ctoken=Hi...N' and the URL for the image is
      'http://www.google.com/accounts/Captcha?ctoken=Hi...N'
 
Returns:
  A dictionary containing the information needed to repond to the CAPTCHA
  challenge, the image URL and the ID token of the challenge. The 
  dictionary is in the form:
  {'token': string identifying the CAPTCHA image,
   'url': string containing the URL of the image}
  Returns None if there was no CAPTCHA challenge in the response.
GetClientLoginTokenString = get_client_login_token_string(http_body)
Returns the token value for a ClientLoginToken.
 
Reads the token from the server's response to a Client Login request and
creates the token value string to use in requests.
 
Args:
  http_body: str The body of the server's HTTP response to a Client Login
      request
 
Returns:
  The token value string for a ClientLoginToken.
ae_delete(token_key)
ae_load(token_key)
ae_save(token, token_key)
auth_sub_string_from_body(http_body)
Extracts the AuthSub token from an HTTP body string.
 
Used to find the new session token after making a request to upgrade a
single use AuthSub token.
 
Args:
  http_body: str The repsonse from the server which contains the AuthSub
      key. For example, this function would find the new session token
      from the server's response to an upgrade token request.
 
Returns:
  The raw token value string to use in an AuthSubToken object.
auth_sub_string_from_url(url, scopes_param_prefix='auth_sub_scopes')
Finds the token string (and scopes) after the browser is redirected.
 
After the Google Accounts AuthSub pages redirect the user's broswer back to
the web application (using the 'next' URL from the request) the web app must
extract the token from the current page's URL. The token is provided as a
URL parameter named 'token' and if generate_auth_sub_url was used to create
the request, the token's valid scopes are included in a URL parameter whose
name is specified in scopes_param_prefix.
 
Args:
  url: atom.url.Url or str representing the current URL. The token value
       and valid scopes should be included as URL parameters.
  scopes_param_prefix: str (optional) The URL parameter key which maps to
                       the list of valid scopes for the token.
 
Returns:
  A tuple containing the token value as a string, and a tuple of scopes 
  (as atom.http_core.Uri objects) which are URL prefixes under which this
  token grants permission to read and write user data.
  (token_string, (scope_uri, scope_uri, scope_uri, ...))
  If no scopes were included in the URL, the second value in the tuple is
  None. If there was no token param in the url, the tuple returned is 
  (None, None)
build_oauth_base_string(http_request, consumer_key, nonce, signaure_type, timestamp, version, token=None)
Generates the base string to be signed in the OAuth request.
 
Args:
  http_request: The request being made to the server. The Request's URL
      must be complete before this signature is calculated as any changes
      to the URL will invalidate the signature.
  consumer_key: Domain identifying the third-party web application. This is
      the domain used when registering the application with Google. It
      identifies who is making the request on behalf of the user.
  nonce: Random 64-bit, unsigned number encoded as an ASCII string in decimal
      format. The nonce/timestamp pair should always be unique to prevent
      replay attacks.
  signaure_type: either RSA_SHA1 or HMAC_SHA1
  timestamp: Integer representing the time the request is sent. The
      timestamp should be expressed in number of seconds after January 1,
      1970 00:00:00 GMT.
  version: The OAuth version used by the requesting web application. This
      value must be '1.0' or '1.0a'. If not provided, Google assumes version
      1.0 is in use.
  token: The string for the OAuth request token or OAuth access token.
dump_tokens(tokens)
generate_auth_sub_url(next, scopes, secure=False, session=True, request_url=<atom.http_core.Uri object at 0xc57450>, domain='default', scopes_param_prefix='auth_sub_scopes')
Constructs a URI for requesting a multiscope AuthSub token.
 
The generated token will contain a URL parameter to pass along the
requested scopes to the next URL. When the Google Accounts page
redirects the broswser to the 'next' URL, it appends the single use
AuthSub token value to the URL as a URL parameter with the key 'token'.
However, the information about which scopes were requested is not
included by Google Accounts. This method adds the scopes to the next
URL before making the request so that the redirect will be sent to
a page, and both the token value and the list of scopes for which the token
was requested.
 
Args:
  next: atom.http_core.Uri or string The URL user will be sent to after
        authorizing this web application to access their data.
  scopes: list containint strings or atom.http_core.Uri objects. The URLs
          of the services to be accessed.
  secure: boolean (optional) Determines whether or not the issued token
          is a secure token.
  session: boolean (optional) Determines whether or not the issued token
           can be upgraded to a session token.
  request_url: atom.http_core.Uri or str The beginning of the request URL.
               This is normally 
               'http://www.google.com/accounts/AuthSubRequest' or
               '/accounts/AuthSubRequest'
  domain: The domain which the account is part of. This is used for Google
          Apps accounts, the default value is 'default' which means that
          the requested account is a Google Account (@gmail.com for
          example)
  scopes_param_prefix: str (optional) The requested scopes are added as a
                       URL parameter to the next URL so that the page at
                       the 'next' URL can extract the token value and the
                       valid scopes from the URL. The key for the URL
                       parameter defaults to 'auth_sub_scopes'
 
Returns:
  An atom.http_core.Uri which the user's browser should be directed to in
  order to authorize this application to access their information.
generate_client_login_request_body(email, password, service, source, account_type='HOSTED_OR_GOOGLE', captcha_token=None, captcha_response=None)
Creates the body of the autentication request
 
See http://code.google.com/apis/accounts/AuthForInstalledApps.html#Request
for more details.
 
Args:
  email: str
  password: str
  service: str
  source: str
  account_type: str (optional) Defaul is 'HOSTED_OR_GOOGLE', other valid
      values are 'GOOGLE' and 'HOSTED'
  captcha_token: str (optional)
  captcha_response: str (optional)
 
Returns:
  The HTTP body to send in a request for a client login token.
get_captcha_challenge(http_body, captcha_base_url='http://www.google.com/accounts/')
Returns the URL and token for a CAPTCHA challenge issued by the server.
 
Args:
  http_body: str The body of the HTTP response from the server which 
      contains the CAPTCHA challenge.
  captcha_base_url: str This function returns a full URL for viewing the 
      challenge image which is built from the server's response. This
      base_url is used as the beginning of the URL because the server
      only provides the end of the URL. For example the server provides
      'Captcha?ctoken=Hi...N' and the URL for the image is
      'http://www.google.com/accounts/Captcha?ctoken=Hi...N'
 
Returns:
  A dictionary containing the information needed to repond to the CAPTCHA
  challenge, the image URL and the ID token of the challenge. The 
  dictionary is in the form:
  {'token': string identifying the CAPTCHA image,
   'url': string containing the URL of the image}
  Returns None if there was no CAPTCHA challenge in the response.
get_client_login_token_string(http_body)
Returns the token value for a ClientLoginToken.
 
Reads the token from the server's response to a Client Login request and
creates the token value string to use in requests.
 
Args:
  http_body: str The body of the server's HTTP response to a Client Login
      request
 
Returns:
  The token value string for a ClientLoginToken.
load_tokens(blob)
token_from_blob(blob)
token_to_blob(token)
Serializes the token data as a string for storage in a datastore.
 
Supported token classes: ClientLoginTokenAuthSubToken.
 
Args:
  token: A token object which must be of one of the supported token classes.

 
Data
        AUTHSUB_AUTH_LABEL = 'AuthSub token='
HMAC_SHA1 = 'HMAC-SHA1'
PROGRAMMATIC_AUTH_LABEL = 'GoogleLogin auth='
RSA_SHA1 = 'RSA-SHA1'
__author__ = 'j.s@google.com (Jeff Scudder)'

 
Author
        j.s@google.com (Jeff Scudder)