+++ /dev/null
-"""
-The MIT License
-
-Copyright (c) 2007-2010 Leah Culver, Joe Stump, Mark Paschal, Vic Fryzel
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-"""
-
-import base64
-import urllib
-import time
-import random
-import urlparse
-import hmac
-import binascii
-import httplib2
-
-try:
- from urlparse import parse_qs
- parse_qs # placate pyflakes
-except ImportError:
- # fall back for Python 2.5
- from cgi import parse_qs
-
-try:
- from hashlib import sha1
- sha = sha1
-except ImportError:
- # hashlib was added in Python 2.5
- import sha
-
-import _version
-
-__version__ = _version.__version__
-
-OAUTH_VERSION = '1.0' # Hi Blaine!
-HTTP_METHOD = 'GET'
-SIGNATURE_METHOD = 'PLAINTEXT'
-
-
-class Error(RuntimeError):
- """Generic exception class."""
-
- def __init__(self, message='OAuth error occurred.'):
- self._message = message
-
- @property
- def message(self):
- """A hack to get around the deprecation errors in 2.6."""
- return self._message
-
- def __str__(self):
- return self._message
-
-
-class MissingSignature(Error):
- pass
-
-
-def build_authenticate_header(realm=''):
- """Optional WWW-Authenticate header (401 error)"""
- return {'WWW-Authenticate': 'OAuth realm="%s"' % realm}
-
-
-def build_xoauth_string(url, consumer, token=None):
- """Build an XOAUTH string for use in SMTP/IMPA authentication."""
- request = Request.from_consumer_and_token(consumer, token,
- "GET", url)
-
- signing_method = SignatureMethod_HMAC_SHA1()
- request.sign_request(signing_method, consumer, token)
-
- params = []
- for k, v in sorted(request.iteritems()):
- if v is not None:
- params.append('%s="%s"' % (k, escape(v)))
-
- return "%s %s %s" % ("GET", url, ','.join(params))
-
-
-def to_unicode(s):
- """ Convert to unicode, raise exception with instructive error
- message if s is not unicode, ascii, or utf-8. """
- if not isinstance(s, unicode):
- if not isinstance(s, str):
- raise TypeError('You are required to pass either unicode or string here, not: %r (%s)' % (type(s), s))
- try:
- s = s.decode('utf-8')
- except UnicodeDecodeError, le:
- raise TypeError('You are required to pass either a unicode object or a utf-8 string here. You passed a Python string object which contained non-utf-8: %r. The UnicodeDecodeError that resulted from attempting to interpret it as utf-8 was: %s' % (s, le,))
- return s
-
-def to_utf8(s):
- return to_unicode(s).encode('utf-8')
-
-def to_unicode_if_string(s):
- if isinstance(s, basestring):
- return to_unicode(s)
- else:
- return s
-
-def to_utf8_if_string(s):
- if isinstance(s, basestring):
- return to_utf8(s)
- else:
- return s
-
-def to_unicode_optional_iterator(x):
- """
- Raise TypeError if x is a str containing non-utf8 bytes or if x is
- an iterable which contains such a str.
- """
- if isinstance(x, basestring):
- return to_unicode(x)
-
- try:
- l = list(x)
- except TypeError, e:
- assert 'is not iterable' in str(e)
- return x
- else:
- return [ to_unicode(e) for e in l ]
-
-def to_utf8_optional_iterator(x):
- """
- Raise TypeError if x is a str or if x is an iterable which
- contains a str.
- """
- if isinstance(x, basestring):
- return to_utf8(x)
-
- try:
- l = list(x)
- except TypeError, e:
- assert 'is not iterable' in str(e)
- return x
- else:
- return [ to_utf8_if_string(e) for e in l ]
-
-def escape(s):
- """Escape a URL including any /."""
- return urllib.quote(s.encode('utf-8'), safe='~')
-
-def generate_timestamp():
- """Get seconds since epoch (UTC)."""
- return int(time.time())
-
-
-def generate_nonce(length=8):
- """Generate pseudorandom number."""
- return ''.join([str(random.randint(0, 9)) for i in range(length)])
-
-
-def generate_verifier(length=8):
- """Generate pseudorandom number."""
- return ''.join([str(random.randint(0, 9)) for i in range(length)])
-
-
-class Consumer(object):
- """A consumer of OAuth-protected services.
-
- The OAuth consumer is a "third-party" service that wants to access
- protected resources from an OAuth service provider on behalf of an end
- user. It's kind of the OAuth client.
-
- Usually a consumer must be registered with the service provider by the
- developer of the consumer software. As part of that process, the service
- provider gives the consumer a *key* and a *secret* with which the consumer
- software can identify itself to the service. The consumer will include its
- key in each request to identify itself, but will use its secret only when
- signing requests, to prove that the request is from that particular
- registered consumer.
-
- Once registered, the consumer can then use its consumer credentials to ask
- the service provider for a request token, kicking off the OAuth
- authorization process.
- """
-
- key = None
- secret = None
-
- def __init__(self, key, secret):
- self.key = key
- self.secret = secret
-
- if self.key is None or self.secret is None:
- raise ValueError("Key and secret must be set.")
-
- def __str__(self):
- data = {'oauth_consumer_key': self.key,
- 'oauth_consumer_secret': self.secret}
-
- return urllib.urlencode(data)
-
-
-class Token(object):
- """An OAuth credential used to request authorization or a protected
- resource.
-
- Tokens in OAuth comprise a *key* and a *secret*. The key is included in
- requests to identify the token being used, but the secret is used only in
- the signature, to prove that the requester is who the server gave the
- token to.
-
- When first negotiating the authorization, the consumer asks for a *request
- token* that the live user authorizes with the service provider. The
- consumer then exchanges the request token for an *access token* that can
- be used to access protected resources.
- """
-
- key = None
- secret = None
- callback = None
- callback_confirmed = None
- verifier = None
-
- def __init__(self, key, secret):
- self.key = key
- self.secret = secret
-
- if self.key is None or self.secret is None:
- raise ValueError("Key and secret must be set.")
-
- def set_callback(self, callback):
- self.callback = callback
- self.callback_confirmed = 'true'
-
- def set_verifier(self, verifier=None):
- if verifier is not None:
- self.verifier = verifier
- else:
- self.verifier = generate_verifier()
-
- def get_callback_url(self):
- if self.callback and self.verifier:
- # Append the oauth_verifier.
- parts = urlparse.urlparse(self.callback)
- scheme, netloc, path, params, query, fragment = parts[:6]
- if query:
- query = '%s&oauth_verifier=%s' % (query, self.verifier)
- else:
- query = 'oauth_verifier=%s' % self.verifier
- return urlparse.urlunparse((scheme, netloc, path, params,
- query, fragment))
- return self.callback
-
- def to_string(self):
- """Returns this token as a plain string, suitable for storage.
-
- The resulting string includes the token's secret, so you should never
- send or store this string where a third party can read it.
- """
-
- data = {
- 'oauth_token': self.key,
- 'oauth_token_secret': self.secret,
- }
-
- if self.callback_confirmed is not None:
- data['oauth_callback_confirmed'] = self.callback_confirmed
- return urllib.urlencode(data)
-
- @staticmethod
- def from_string(s):
- """Deserializes a token from a string like one returned by
- `to_string()`."""
-
- if not len(s):
- raise ValueError("Invalid parameter string.")
-
- params = parse_qs(s, keep_blank_values=False)
- if not len(params):
- raise ValueError("Invalid parameter string.")
-
- try:
- key = params['oauth_token'][0]
- except Exception:
- raise ValueError("'oauth_token' not found in OAuth request.")
-
- try:
- secret = params['oauth_token_secret'][0]
- except Exception:
- raise ValueError("'oauth_token_secret' not found in "
- "OAuth request.")
-
- token = Token(key, secret)
- try:
- token.callback_confirmed = params['oauth_callback_confirmed'][0]
- except KeyError:
- pass # 1.0, no callback confirmed.
- return token
-
- def __str__(self):
- return self.to_string()
-
-
-def setter(attr):
- name = attr.__name__
-
- def getter(self):
- try:
- return self.__dict__[name]
- except KeyError:
- raise AttributeError(name)
-
- def deleter(self):
- del self.__dict__[name]
-
- return property(getter, attr, deleter)
-
-
-class Request(dict):
-
- """The parameters and information for an HTTP request, suitable for
- authorizing with OAuth credentials.
-
- When a consumer wants to access a service's protected resources, it does
- so using a signed HTTP request identifying itself (the consumer) with its
- key, and providing an access token authorized by the end user to access
- those resources.
-
- """
-
- version = OAUTH_VERSION
-
- def __init__(self, method=HTTP_METHOD, url=None, parameters=None,
- body='', is_form_encoded=False):
- if url is not None:
- self.url = to_unicode(url)
- self.method = method
- if parameters is not None:
- for k, v in parameters.iteritems():
- k = to_unicode(k)
- v = to_unicode_optional_iterator(v)
- self[k] = v
- self.body = body
- self.is_form_encoded = is_form_encoded
-
-
- @setter
- def url(self, value):
- self.__dict__['url'] = value
- if value is not None:
- scheme, netloc, path, params, query, fragment = urlparse.urlparse(value)
-
- # Exclude default port numbers.
- if scheme == 'http' and netloc[-3:] == ':80':
- netloc = netloc[:-3]
- elif scheme == 'https' and netloc[-4:] == ':443':
- netloc = netloc[:-4]
- if scheme not in ('http', 'https'):
- raise ValueError("Unsupported URL %s (%s)." % (value, scheme))
-
- # Normalized URL excludes params, query, and fragment.
- self.normalized_url = urlparse.urlunparse((scheme, netloc, path, None, None, None))
- else:
- self.normalized_url = None
- self.__dict__['url'] = None
-
- @setter
- def method(self, value):
- self.__dict__['method'] = value.upper()
-
- def _get_timestamp_nonce(self):
- return self['oauth_timestamp'], self['oauth_nonce']
-
- def get_nonoauth_parameters(self):
- """Get any non-OAuth parameters."""
- return dict([(k, v) for k, v in self.iteritems()
- if not k.startswith('oauth_')])
-
- def to_header(self, realm=''):
- """Serialize as a header for an HTTPAuth request."""
- oauth_params = ((k, v) for k, v in self.items()
- if k.startswith('oauth_'))
- stringy_params = ((k, escape(str(v))) for k, v in oauth_params)
- header_params = ('%s="%s"' % (k, v) for k, v in stringy_params)
- params_header = ', '.join(header_params)
-
- auth_header = 'OAuth realm="%s"' % realm
- if params_header:
- auth_header = "%s, %s" % (auth_header, params_header)
-
- return {'Authorization': auth_header}
-
- def to_postdata(self):
- """Serialize as post data for a POST request."""
- d = {}
- for k, v in self.iteritems():
- d[k.encode('utf-8')] = to_utf8_optional_iterator(v)
-
- # tell urlencode to deal with sequence values and map them correctly
- # to resulting querystring. for example self["k"] = ["v1", "v2"] will
- # result in 'k=v1&k=v2' and not k=%5B%27v1%27%2C+%27v2%27%5D
- return urllib.urlencode(d, True).replace('+', '%20')
-
- def to_url(self):
- """Serialize as a URL for a GET request."""
- base_url = urlparse.urlparse(self.url)
- try:
- query = base_url.query
- except AttributeError:
- # must be python <2.5
- query = base_url[4]
- query = parse_qs(query)
- for k, v in self.items():
- query.setdefault(k, []).append(v)
-
- try:
- scheme = base_url.scheme
- netloc = base_url.netloc
- path = base_url.path
- params = base_url.params
- fragment = base_url.fragment
- except AttributeError:
- # must be python <2.5
- scheme = base_url[0]
- netloc = base_url[1]
- path = base_url[2]
- params = base_url[3]
- fragment = base_url[5]
-
- url = (scheme, netloc, path, params,
- urllib.urlencode(query, True), fragment)
- return urlparse.urlunparse(url)
-
- def get_parameter(self, parameter):
- ret = self.get(parameter)
- if ret is None:
- raise Error('Parameter not found: %s' % parameter)
-
- return ret
-
- def get_normalized_parameters(self):
- """Return a string that contains the parameters that must be signed."""
- items = []
- for key, value in self.iteritems():
- if key == 'oauth_signature':
- continue
- # 1.0a/9.1.1 states that kvp must be sorted by key, then by value,
- # so we unpack sequence values into multiple items for sorting.
- if isinstance(value, basestring):
- items.append((to_utf8_if_string(key), to_utf8(value)))
- else:
- try:
- value = list(value)
- except TypeError, e:
- assert 'is not iterable' in str(e)
- items.append((to_utf8_if_string(key), to_utf8_if_string(value)))
- else:
- items.extend((to_utf8_if_string(key), to_utf8_if_string(item)) for item in value)
-
- # Include any query string parameters from the provided URL
- query = urlparse.urlparse(self.url)[4]
-
- url_items = self._split_url_string(query).items()
- url_items = [(to_utf8(k), to_utf8(v)) for k, v in url_items if k != 'oauth_signature' ]
- items.extend(url_items)
-
- items.sort()
- encoded_str = urllib.urlencode(items)
- # Encode signature parameters per Oauth Core 1.0 protocol
- # spec draft 7, section 3.6
- # (http://tools.ietf.org/html/draft-hammer-oauth-07#section-3.6)
- # Spaces must be encoded with "%20" instead of "+"
- return encoded_str.replace('+', '%20').replace('%7E', '~')
-
- def sign_request(self, signature_method, consumer, token):
- """Set the signature parameter to the result of sign."""
-
- if not self.is_form_encoded:
- # according to
- # http://oauth.googlecode.com/svn/spec/ext/body_hash/1.0/oauth-bodyhash.html
- # section 4.1.1 "OAuth Consumers MUST NOT include an
- # oauth_body_hash parameter on requests with form-encoded
- # request bodies."
- self['oauth_body_hash'] = base64.b64encode(sha(self.body).digest())
-
- if 'oauth_consumer_key' not in self:
- self['oauth_consumer_key'] = consumer.key
-
- if token and 'oauth_token' not in self:
- self['oauth_token'] = token.key
-
- self['oauth_signature_method'] = signature_method.name
- self['oauth_signature'] = signature_method.sign(self, consumer, token)
-
- @classmethod
- def make_timestamp(cls):
- """Get seconds since epoch (UTC)."""
- return str(int(time.time()))
-
- @classmethod
- def make_nonce(cls):
- """Generate pseudorandom number."""
- return str(random.randint(0, 100000000))
-
- @classmethod
- def from_request(cls, http_method, http_url, headers=None, parameters=None,
- query_string=None):
- """Combines multiple parameter sources."""
- if parameters is None:
- parameters = {}
-
- # Headers
- if headers and 'Authorization' in headers:
- auth_header = headers['Authorization']
- # Check that the authorization header is OAuth.
- if auth_header[:6] == 'OAuth ':
- auth_header = auth_header[6:]
- try:
- # Get the parameters from the header.
- header_params = cls._split_header(auth_header)
- parameters.update(header_params)
- except:
- raise Error('Unable to parse OAuth parameters from '
- 'Authorization header.')
-
- # GET or POST query string.
- if query_string:
- query_params = cls._split_url_string(query_string)
- parameters.update(query_params)
-
- # URL parameters.
- param_str = urlparse.urlparse(http_url)[4] # query
- url_params = cls._split_url_string(param_str)
- parameters.update(url_params)
-
- if parameters:
- return cls(http_method, http_url, parameters)
-
- return None
-
- @classmethod
- def from_consumer_and_token(cls, consumer, token=None,
- http_method=HTTP_METHOD, http_url=None, parameters=None,
- body='', is_form_encoded=False):
- if not parameters:
- parameters = {}
-
- defaults = {
- 'oauth_consumer_key': consumer.key,
- 'oauth_timestamp': cls.make_timestamp(),
- 'oauth_nonce': cls.make_nonce(),
- 'oauth_version': cls.version,
- }
-
- defaults.update(parameters)
- parameters = defaults
-
- if token:
- parameters['oauth_token'] = token.key
- if token.verifier:
- parameters['oauth_verifier'] = token.verifier
-
- return Request(http_method, http_url, parameters, body=body,
- is_form_encoded=is_form_encoded)
-
- @classmethod
- def from_token_and_callback(cls, token, callback=None,
- http_method=HTTP_METHOD, http_url=None, parameters=None):
-
- if not parameters:
- parameters = {}
-
- parameters['oauth_token'] = token.key
-
- if callback:
- parameters['oauth_callback'] = callback
-
- return cls(http_method, http_url, parameters)
-
- @staticmethod
- def _split_header(header):
- """Turn Authorization: header into parameters."""
- params = {}
- parts = header.split(',')
- for param in parts:
- # Ignore realm parameter.
- if param.find('realm') > -1:
- continue
- # Remove whitespace.
- param = param.strip()
- # Split key-value.
- param_parts = param.split('=', 1)
- # Remove quotes and unescape the value.
- params[param_parts[0]] = urllib.unquote(param_parts[1].strip('\"'))
- return params
-
- @staticmethod
- def _split_url_string(param_str):
- """Turn URL string into parameters."""
- parameters = parse_qs(param_str.encode('utf-8'), keep_blank_values=True)
- for k, v in parameters.iteritems():
- parameters[k] = urllib.unquote(v[0])
- return parameters
-
-
-class Client(httplib2.Http):
- """OAuthClient is a worker to attempt to execute a request."""
-
- def __init__(self, consumer, token=None, cache=None, timeout=None,
- proxy_info=None):
-
- if consumer is not None and not isinstance(consumer, Consumer):
- raise ValueError("Invalid consumer.")
-
- if token is not None and not isinstance(token, Token):
- raise ValueError("Invalid token.")
-
- self.consumer = consumer
- self.token = token
- self.method = SignatureMethod_HMAC_SHA1()
-
- httplib2.Http.__init__(self, cache=cache, timeout=timeout, proxy_info=proxy_info)
-
- def set_signature_method(self, method):
- if not isinstance(method, SignatureMethod):
- raise ValueError("Invalid signature method.")
-
- self.method = method
-
- def request(self, uri, method="GET", body='', headers=None,
- redirections=httplib2.DEFAULT_MAX_REDIRECTS, connection_type=None):
- DEFAULT_POST_CONTENT_TYPE = 'application/x-www-form-urlencoded'
-
- if not isinstance(headers, dict):
- headers = {}
-
- if method == "POST":
- headers['Content-Type'] = headers.get('Content-Type',
- DEFAULT_POST_CONTENT_TYPE)
-
- is_form_encoded = \
- headers.get('Content-Type') == 'application/x-www-form-urlencoded'
-
- if is_form_encoded and body:
- parameters = parse_qs(body)
- else:
- parameters = None
-
- req = Request.from_consumer_and_token(self.consumer,
- token=self.token, http_method=method, http_url=uri,
- parameters=parameters, body=body, is_form_encoded=is_form_encoded)
-
- req.sign_request(self.method, self.consumer, self.token)
-
- schema, rest = urllib.splittype(uri)
- if rest.startswith('//'):
- hierpart = '//'
- else:
- hierpart = ''
- host, rest = urllib.splithost(rest)
-
- realm = schema + ':' + hierpart + host
-
- if is_form_encoded:
- body = req.to_postdata()
- elif method == "GET":
- uri = req.to_url()
- else:
- headers.update(req.to_header(realm=realm))
-
- return httplib2.Http.request(self, uri, method=method, body=body,
- headers=headers, redirections=redirections,
- connection_type=connection_type)
-
-
-class Server(object):
- """A skeletal implementation of a service provider, providing protected
- resources to requests from authorized consumers.
-
- This class implements the logic to check requests for authorization. You
- can use it with your web server or web framework to protect certain
- resources with OAuth.
- """
-
- timestamp_threshold = 300 # In seconds, five minutes.
- version = OAUTH_VERSION
- signature_methods = None
-
- def __init__(self, signature_methods=None):
- self.signature_methods = signature_methods or {}
-
- def add_signature_method(self, signature_method):
- self.signature_methods[signature_method.name] = signature_method
- return self.signature_methods
-
- def verify_request(self, request, consumer, token):
- """Verifies an api call and checks all the parameters."""
-
- self._check_version(request)
- self._check_signature(request, consumer, token)
- parameters = request.get_nonoauth_parameters()
- return parameters
-
- def build_authenticate_header(self, realm=''):
- """Optional support for the authenticate header."""
- return {'WWW-Authenticate': 'OAuth realm="%s"' % realm}
-
- def _check_version(self, request):
- """Verify the correct version of the request for this server."""
- version = self._get_version(request)
- if version and version != self.version:
- raise Error('OAuth version %s not supported.' % str(version))
-
- def _get_version(self, request):
- """Return the version of the request for this server."""
- try:
- version = request.get_parameter('oauth_version')
- except:
- version = OAUTH_VERSION
-
- return version
-
- def _get_signature_method(self, request):
- """Figure out the signature with some defaults."""
- try:
- signature_method = request.get_parameter('oauth_signature_method')
- except:
- signature_method = SIGNATURE_METHOD
-
- try:
- # Get the signature method object.
- signature_method = self.signature_methods[signature_method]
- except:
- signature_method_names = ', '.join(self.signature_methods.keys())
- raise Error('Signature method %s not supported try one of the following: %s' % (signature_method, signature_method_names))
-
- return signature_method
-
- def _get_verifier(self, request):
- return request.get_parameter('oauth_verifier')
-
- def _check_signature(self, request, consumer, token):
- timestamp, nonce = request._get_timestamp_nonce()
- self._check_timestamp(timestamp)
- signature_method = self._get_signature_method(request)
-
- try:
- signature = request.get_parameter('oauth_signature')
- except:
- raise MissingSignature('Missing oauth_signature.')
-
- # Validate the signature.
- valid = signature_method.check(request, consumer, token, signature)
-
- if not valid:
- key, base = signature_method.signing_base(request, consumer, token)
-
- raise Error('Invalid signature. Expected signature base '
- 'string: %s' % base)
-
- def _check_timestamp(self, timestamp):
- """Verify that timestamp is recentish."""
- timestamp = int(timestamp)
- now = int(time.time())
- lapsed = now - timestamp
- if lapsed > self.timestamp_threshold:
- raise Error('Expired timestamp: given %d and now %s has a '
- 'greater difference than threshold %d' % (timestamp, now,
- self.timestamp_threshold))
-
-
-class SignatureMethod(object):
- """A way of signing requests.
-
- The OAuth protocol lets consumers and service providers pick a way to sign
- requests. This interface shows the methods expected by the other `oauth`
- modules for signing requests. Subclass it and implement its methods to
- provide a new way to sign requests.
- """
-
- def signing_base(self, request, consumer, token):
- """Calculates the string that needs to be signed.
-
- This method returns a 2-tuple containing the starting key for the
- signing and the message to be signed. The latter may be used in error
- messages to help clients debug their software.
-
- """
- raise NotImplementedError
-
- def sign(self, request, consumer, token):
- """Returns the signature for the given request, based on the consumer
- and token also provided.
-
- You should use your implementation of `signing_base()` to build the
- message to sign. Otherwise it may be less useful for debugging.
-
- """
- raise NotImplementedError
-
- def check(self, request, consumer, token, signature):
- """Returns whether the given signature is the correct signature for
- the given consumer and token signing the given request."""
- built = self.sign(request, consumer, token)
- return built == signature
-
-
-class SignatureMethod_HMAC_SHA1(SignatureMethod):
- name = 'HMAC-SHA1'
-
- def signing_base(self, request, consumer, token):
- if not hasattr(request, 'normalized_url') or request.normalized_url is None:
- raise ValueError("Base URL for request is not set.")
-
- sig = (
- escape(request.method),
- escape(request.normalized_url),
- escape(request.get_normalized_parameters()),
- )
-
- key = '%s&' % escape(consumer.secret)
- if token:
- key += escape(token.secret)
- raw = '&'.join(sig)
- return key, raw
-
- def sign(self, request, consumer, token):
- """Builds the base signature string."""
- key, raw = self.signing_base(request, consumer, token)
-
- hashed = hmac.new(key, raw, sha)
-
- # Calculate the digest base 64.
- return binascii.b2a_base64(hashed.digest())[:-1]
-
-
-class SignatureMethod_PLAINTEXT(SignatureMethod):
-
- name = 'PLAINTEXT'
-
- def signing_base(self, request, consumer, token):
- """Concatenates the consumer key and secret with the token's
- secret."""
- sig = '%s&' % escape(consumer.secret)
- if token:
- sig = sig + escape(token.secret)
- return sig, sig
-
- def sign(self, request, consumer, token):
- key, raw = self.signing_base(request, consumer, token)
- return raw
projects / pithos / blobdiff