Exemplo n.º 1
0
    def from_consumer_and_token(oauth_consumer,
                                token=None,
                                callback=None,
                                verifier=None,
                                http_method=HTTP_METHOD,
                                http_url=None,
                                parameters=None):
        if not parameters:
            parameters = {}

        defaults = {
            constants.OAUTH_CONSUMER_KEY: oauth_consumer.key,
            constants.OAUTH_TIMESTAMP: generate_timestamp(),
            constants.OAUTH_NONCE: generate_nonce(),
            constants.OAUTH_VERSION: OAuthRequest.version,
        }

        defaults.update(parameters)
        parameters = defaults

        if token:
            parameters[constants.OAUTH_TOKEN] = token.key
            if token.callback:
                parameters[constants.OAUTH_CALLBACK] = token.callback
            # 1.0a support for verifier.
            if verifier:
                parameters[constants.OAUTH_VERIFIER] = verifier
        elif callback:
            # 1.0a support for callback in the request token request.
            parameters[constants.OAUTH_CALLBACK] = callback

        return PortalOAuthRequest(http_method, http_url, parameters)
Exemplo n.º 2
0
 def _makeOAuthRequest(self, url, token=None,
                                     params=None, http_method="GET"):
     '''Make a OAuth request from url and parameters
     
     Args:
       url: The Url to use for creating OAuth Request
       parameters:
          The URL parameters
       http_method:
          The HTTP method to use
     Returns:
       A OAauthRequest object
     '''
     
     oauth_base_params = {
     'oauth_version': "1.0",
     'oauth_nonce': oauth.generate_nonce(),
     'oauth_timestamp': int(time.time())
     }
     
     if params:
         params.update(oauth_base_params)
     else:
         params = oauth_base_params
     
     if not token:
         token = self._access_token
     request = oauth.Request(method=http_method,url=url,parameters=params)
     request.sign_request(self._signature_method, self._Consumer, token)
     return request
Exemplo n.º 3
0
    def from_consumer_and_token(
        oauth_consumer,
        token=None,
        callback=None,
        verifier=None,
        http_method=HTTP_METHOD,
        http_url=None,
        parameters=None,
    ):
        if not parameters:
            parameters = {}

        defaults = {
            constants.OAUTH_CONSUMER_KEY: oauth_consumer.key,
            constants.OAUTH_TIMESTAMP: generate_timestamp(),
            constants.OAUTH_NONCE: generate_nonce(),
            constants.OAUTH_VERSION: OAuthRequest.version,
        }

        defaults.update(parameters)
        parameters = defaults

        if token:
            parameters[constants.OAUTH_TOKEN] = token.key
            if token.callback:
                parameters[constants.OAUTH_CALLBACK] = token.callback
            # 1.0a support for verifier.
            if verifier:
                parameters[constants.OAUTH_VERIFIER] = verifier
        elif callback:
            # 1.0a support for callback in the request token request.
            parameters[constants.OAUTH_CALLBACK] = callback

        return PortalOAuthRequest(http_method, http_url, parameters)
Exemplo n.º 4
0
    def set_verifier(self, oauth_verifier):
        if self.request_token is None:
            raise AuthHandlerError(
                "Request token is not defined. This ususally means that the access token has been loaded from a file."
            )
        self.request_token.set_verifier(oauth_verifier)

        access_token_parms = {
            'oauth_consumer_key': self.key,
            'oauth_nonce': oauth.generate_nonce(),
            'oauth_signature_method': "HMAC-SHA1",
            'oauth_timestamp': str(int(time.time())),
            'oauth_token': self.request_token.key,
            'oauth_verifier': self.request_token.verifier
        }

        req = oauth.OAuthRequest(http_method="GET",
                                 http_url=ACCESS_TOKEN_URL,
                                 parameters=access_token_parms)
        req.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(), self.consumer,
                         self.request_token)
        resp = urllib2.urlopen(req.to_url())
        access_token_resp = dict(urlparse.parse_qsl(resp.read()))
        self.access_token = oauth.OAuthToken(
            access_token_resp["oauth_token"],
            access_token_resp["oauth_token_secret"])
Exemplo n.º 5
0
    def sign_request(self, consumer, signature_method):
        """Add oauth parameters and sign the request with the given method.
    
    Args:
      consumer: The OAuthConsumer set with a key and secret.
      signature_method: A supported method for signing the built request.

    """
        params = {
            "oauth_consumer_key": consumer.key,
            "oauth_timestamp": oauth.generate_timestamp(),
            "oauth_nonce": oauth.generate_nonce(),
            "oauth_version": oauth.OAuthRequest.version,
        }

        # PHP OAuth library contains a bug which interferes with signing.  Since
        # some containers use this library, we will implement a workaround here.
        if self.use_body_as_signing_parameter:
            params[self.get_post_body()] = ""
        else:
            # Otherwise, use the oauth_body_hash extension to sign the request body.
            if self.post_body:
                body_hash = b64encode(hashlib.sha1(self.get_post_body()).digest())
                params["oauth_body_hash"] = body_hash

        if self.get_security_token():
            self.set_parameter("xoauth_requestor_id", None)

        self.set_parameters(params)
        self.oauth_request.sign_request(signature_method, consumer, None)
Exemplo n.º 6
0
    def __init__(self,
                 key=None,
                 secret=None,
                 callback=None,
                 access_token_key=None,
                 access_token_secret=None,
                 request_token_key=None,
                 request_token_secret=None):

        self.key = key or method_call.API_KEY
        self.secret = secret or method_call.API_SECRET

        if self.key is None or self.secret is None:
            raise ValueError("API keys have not been set.")

        if callback is None:
            callback = "http://api.flickr.com/services/rest/?method=flickr.test.echo&api_key=%s" % self.key

        params = {
            'oauth_timestamp': str(int(time.time())),
            'oauth_signature_method': "HMAC-SHA1",
            'oauth_version': "1.0",
            'oauth_callback': callback,
            'oauth_nonce': oauth.generate_nonce(),
            'oauth_consumer_key': self.key
        }

        self.consumer = oauth.OAuthConsumer(key=self.key, secret=self.secret)
        if (access_token_key is None) and (request_token_key is None):
            req = oauth.OAuthRequest(http_method="GET",
                                     http_url=TOKEN_REQUEST_URL,
                                     parameters=params)
            req.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(),
                             self.consumer, None)
            resp = urllib2.urlopen(req.to_url())
            request_token = dict(urlparse.parse_qsl(resp.read()))
            self.request_token = oauth.OAuthToken(
                request_token['oauth_token'],
                request_token['oauth_token_secret'])
            self.access_token = None
        elif request_token_key is not None:
            self.access_token = None
            self.request_token = oauth.OAuthToken(request_token_key,
                                                  request_token_secret)
        else:
            self.request_token = None
            self.access_token = oauth.OAuthToken(access_token_key,
                                                 access_token_secret)
Exemplo n.º 7
0
    def sign_request(self, consumer, signature_method):
        """Add oauth parameters and sign the request with the given method.
    
    Args:
      consumer: The OAuthConsumer set with a key and secret.
      signature_method: A supported method for signing the built request.

    """
        params = {
            "oauth_consumer_key": consumer.key,
            "oauth_timestamp": oauth.generate_timestamp(),
            "oauth_nonce": oauth.generate_nonce(),
            "oauth_version": oauth.OAuthRequest.version,
        }

        self.set_parameters(params)
        self.oauth_request.sign_request(signature_method, consumer, None)
Exemplo n.º 8
0
    def make_oauth_request(self,
                           http_method='GET',
                           http_url={},
                           has_param=False,
                           parameters=None,
                           token=None):

        param = {
            'oauth_version': '1.0',
            'oauth_timestamp': int(time.time()),
            'oauth_nonce': oauth.generate_nonce(),
            'oauth_signature_method': 'HMAC-SHA1',
            'oauth_consumer_key': self.consumer.key
        }

        if (parameters):
            param.update(parameters)

        if (token):
            param.update({'oauth_token': token.key})

        oauth_request = oauth.OAuthRequest(http_method=http_method,
                                           http_url=http_url,
                                           parameters=param)
        oauth_request.sign_request(self.signature_method, self.consumer, token)

        oauth_header = oauth_request.to_header()

        if http_method == 'POST':
            postdata = oauth_request.to_postdata()
            req = urllib2.Request(http_url, postdata, oauth_header)
        else:
            if has_param:
                url = oauth_request.to_url()
                req = urllib2.Request(url)
            else:
                url = http_url
                req = urllib2.Request(url, None, oauth_header)

        try:
            req = urllib2.urlopen(req)
            return req.read()
        except urllib2.URLError as e:
            return e
        except urllib2.HTTPError as e:
            return e
Exemplo n.º 9
0
    def build_access_headers(self,
                             method,
                             resource_url,
                             params=None,
                             request_token=None):
        """Build OAuth access headers for a future request.

        Args:
            method: The HTTP method being used (e.g. 'GET' or 'POST').
            resource_url: The full url the request will be made to.
            params: A dictionary of parameters to add to what's already on the url.
                Typically, this would consist of POST parameters.

        Returns:
            A tuple of (header_dict, params) where header_dict is a dictionary
            of header names and values appropriate for passing into dropbox.rest.RESTClient
            and params is a dictionary like the one that was passed in, but augmented with
            oauth-related parameters as appropriate.
        """
        if params is None:
            params = {}
        else:
            params = params.copy()

        oauth_params = {
            'oauth_consumer_key': self.consumer.key,
            'oauth_timestamp': oauth.generate_timestamp(),
            'oauth_nonce': oauth.generate_nonce(),
            'oauth_version': oauth.OAuthRequest.version,
        }

        token = request_token if request_token else self.token

        if token:
            oauth_params['oauth_token'] = token.key

        params.update(oauth_params)

        oauth_request = oauth.OAuthRequest.from_request(method,
                                                        resource_url,
                                                        parameters=params)
        oauth_request.sign_request(self.signature_method, self.consumer, token)

        return oauth_request.to_header(), params
Exemplo n.º 10
0
    def __init__(self,
                 tokens,
                 nojsoncallback=True,
                 format='json',
                 parameters=None):

        self.keys = hidden.keys()
        self.dbtokens = tokens

        self.dbtokens["token"].encode("ascii")
        self.dbtokens["token_secret"].encode('ascii')

        if self.dbtokens is not None:

            self.consumer = oauth.OAuthConsumer(
                self.keys["oauth_consumer_key"],
                self.keys["oauth_consumer_secret"])
            self.token = oauth.OAuthToken(
                self.dbtokens["token"].encode("ascii"),
                self.dbtokens["token_secret"].encode("ascii"))

            if nojsoncallback:
                self.nojsoncallback = 1
            else:
                self.nojsoncallback = 0
            if not parameters:
                parameters = {}

            self.url = "https://api.flickr.com/services/rest"

            defaults = {
                "format": format,
                "nojsoncallback": self.nojsoncallback,
                "oauth_timestamp": oauth.generate_timestamp(),
                "oauth_nonce": oauth.generate_nonce(),
                "signature_method": "HMAC-SHA1",
                "oauth_token": self.token.key,
                "api_key": self.consumer.key
            }
            #print defaults
            self.parameters = defaults

        else:
            print "token is none"
Exemplo n.º 11
0
    def set_verifier(self,oauth_verifier):
        if self.request_token is None :
            raise AuthHandlerError("Request token is not defined. This ususally means that the access token has been loaded from a file.")
        self.request_token.set_verifier(oauth_verifier)

        access_token_parms = {
            'oauth_consumer_key': self.key,
            'oauth_nonce': oauth.generate_nonce(),
            'oauth_signature_method':"HMAC-SHA1",
            'oauth_timestamp': str(int(time.time())),
            'oauth_token': self.request_token.key,
            'oauth_verifier' : self.request_token.verifier
        }

        req = oauth.OAuthRequest(http_method="GET", http_url=ACCESS_TOKEN_URL, parameters=access_token_parms)
        req.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(),self.consumer,self.request_token)
        resp = urllib2.urlopen(req.to_url())
        access_token_resp = dict(urlparse.parse_qsl(resp.read()))
        self.access_token = oauth.OAuthToken(access_token_resp["oauth_token"],access_token_resp["oauth_token_secret"])
Exemplo n.º 12
0
def search(command,vertical="web",count=10,start=0,more={}):
  params = {
     'oauth_version': "1.0",
     'oauth_nonce': oauth.generate_nonce(),
     'oauth_timestamp': int(time.time()),
     'q': quote_plus(command),
     'count': count,
     'start': start,
     'format': 'json',
     'ads.recentSource': SOURCE_TAG 
  }
  params.update(more)
  url =  SEARCH_API_URL_V2 + vertical
  consumer = oauth.OAuthConsumer(CC_KEY,CC_SECRET)
  req = oauth.OAuthRequest.from_consumer_and_token(consumer,http_method="GET", http_url=url, parameters=params)
  signature_method = oauth.OAuthSignatureMethod_HMAC_SHA1()
  req.sign_request(signature_method, consumer, None)
  resp=req.to_url()
  return rest.load_json(resp) 
Exemplo n.º 13
0
    def sign_request(self, consumer, signature_method):
        """Add oauth parameters and sign the request with the given method.
    
    Args:
      consumer: The OAuthConsumer set with a key and secret.
      signature_method: A supported method for signing the built request.

    """
        params = {
            'oauth_consumer_key': consumer.key,
            'oauth_timestamp': oauth.generate_timestamp(),
            'oauth_nonce': oauth.generate_nonce(),
            'oauth_version': oauth.OAuthRequest.version,
        }

        if self.get_security_token():
            self.set_parameter("xoauth_requestor_id", None)

        self.set_parameters(params)
        self.oauth_request.sign_request(signature_method, consumer, None)
Exemplo n.º 14
0
  def sign_request(self, consumer, signature_method):
    """Add oauth parameters and sign the request with the given method.
    
    Args:
      consumer: The OAuthConsumer set with a key and secret.
      signature_method: A supported method for signing the built request.

    """
    params = {
      'oauth_consumer_key': consumer.key,
      'oauth_timestamp': oauth.generate_timestamp(),
      'oauth_nonce': oauth.generate_nonce(),
      'oauth_version': oauth.OAuthRequest.version,
    }
    
    if self.get_security_token():
      self.set_parameter("xoauth_requestor_id", None)
    
    self.set_parameters(params)
    self.oauth_request.sign_request(signature_method, consumer, None)
Exemplo n.º 15
0
    def complete_parameters(self,url,params = {},exclude_signature = []):

        defaults = {
            'oauth_timestamp': str(int(time.time())),
            'oauth_nonce': oauth.generate_nonce(),
            'signature_method': "HMAC-SHA1",
            'oauth_token':self.access_token.key,
            'oauth_consumer_key':self.consumer.key,
        }

        excluded = {}
        for e in exclude_signature :
            excluded[e] = params.pop(e)

        defaults.update(params)
        req = oauth.OAuthRequest(http_method="POST", http_url=url, parameters=defaults)
        req.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(),self.consumer,self.access_token)
        req.parameters.update(excluded)

        return req
    def sign_request(self, consumer, signature_method):
        """Add oauth parameters and sign the request with the given method.
    
    Args:
      consumer: The OAuthConsumer set with a key and secret.
      signature_method: A supported method for signing the built request.

    """
        params = {
            'oauth_consumer_key': consumer.key,
            'oauth_timestamp': oauth.generate_timestamp(),
            'oauth_nonce': oauth.generate_nonce(),
            'oauth_version': oauth.OAuthRequest.version,
        }

        # PHP OAuth library contains a bug which interferes with signing.  Since
        # some containers use this library, we will implement a workaround here.
        if self.use_body_as_signing_parameter:
            params[self.get_post_body()] = ""
        else:
            # Otherwise, use the oauth_body_hash extension to sign the request body.
            if self.post_body:
                if VERBOSE > 0:
                    logging.info("post_body => %s" % str(self.post_body))

                if self.add_bodyhash:
                    body_hash = b64encode(
                        hashlib.sha1(self.get_post_body()).digest())
                    params['oauth_body_hash'] = body_hash

        if self.get_security_token():
            self.set_parameter("xoauth_requestor_id", None)

        self.set_parameters(params)
        if VERBOSE > 0:
            key, raw = signature_method.build_signature_base_string(
                self.oauth_request, consumer, None)
            logging.info("build_signature key => %s" % key)
            logging.info("build_signature raw => %s" % raw)

        self.oauth_request.sign_request(signature_method, consumer, None)
Exemplo n.º 17
0
    def make_oauth_request(self, http_method = 'GET', http_url = {}, has_param = False, parameters = None, token = None):

        param = {
        'oauth_version': '1.0',
        'oauth_timestamp': int(time.time()),
        'oauth_nonce': oauth.generate_nonce(),
        'oauth_signature_method': 'HMAC-SHA1',
        'oauth_consumer_key': self.consumer.key
        }
        
        if(parameters):
            param.update(parameters)

        if(token):
            param.update({ 'oauth_token': token.key })

        oauth_request = oauth.OAuthRequest(http_method = http_method, http_url = http_url, parameters = param)
        oauth_request.sign_request(self.signature_method, self.consumer, token)

        oauth_header = oauth_request.to_header()

        if http_method == 'POST':
            postdata = oauth_request.to_postdata()
            req = urllib2.Request(http_url, postdata, oauth_header)
        else:
            if has_param:
                url = oauth_request.to_url()
                req = urllib2.Request(url)
            else:
                url = http_url
                req = urllib2.Request(url, None, oauth_header)
        
        try:
            req = urllib2.urlopen(req)
            return req.read()
        except urllib2.URLError as e:
            return e
        except urllib2.HTTPError as e:
            return e
Exemplo n.º 18
0
  def sign_request(self, consumer, signature_method):
    """Add oauth parameters and sign the request with the given method.
    
    Args:
      consumer: The OAuthConsumer set with a key and secret.
      signature_method: A supported method for signing the built request.

    """
    params = {
      'oauth_consumer_key': consumer.key,
      'oauth_timestamp': oauth.generate_timestamp(),
      'oauth_nonce': oauth.generate_nonce(),
      'oauth_version': oauth.OAuthRequest.version,
    }
          
    # PHP OAuth library contains a bug which interferes with signing.  Since
    # some containers use this library, we will implement a workaround here.
    if self.use_body_as_signing_parameter:
      params[self.get_post_body()] = ""
    else:
      # Otherwise, use the oauth_body_hash extension to sign the request body.
      if self.post_body:
        if VERBOSE > 0:
          logging.info("post_body => %s" % str(self.post_body))
          
        body_hash = b64encode(hashlib.sha1(self.get_post_body()).digest())
        params['oauth_body_hash'] = body_hash
      
    if self.get_security_token():
      self.set_parameter("xoauth_requestor_id", None)
    
    self.set_parameters(params)
    if VERBOSE > 0:
      key, raw = signature_method.build_signature_base_string(
                     self.oauth_request, consumer, None)
      logging.info("build_signature key => %s" % key)
      logging.info("build_signature raw => %s" % raw)
      
    self.oauth_request.sign_request(signature_method, consumer, None)
    def build_access_headers(self, method, resource_url, params=None, request_token=None):
        """Build OAuth access headers for a future request.

        Args:
            method: The HTTP method being used (e.g. 'GET' or 'POST').
            resource_url: The full url the request will be made to.
            params: A dictionary of parameters to add to what's already on the url.
                Typically, this would consist of POST parameters.

        Returns:
            A tuple of (header_dict, params) where header_dict is a dictionary
            of header names and values appropriate for passing into dropbox.rest.RESTClient
            and params is a dictionary like the one that was passed in, but augmented with
            oauth-related parameters as appropriate.
        """
        if params is None:
            params = {}
        else:
            params = params.copy()

        oauth_params = {
            'oauth_consumer_key': self.consumer.key,
            'oauth_timestamp': oauth.generate_timestamp(),
            'oauth_nonce': oauth.generate_nonce(),
            'oauth_version': oauth.OAuthRequest.version,
        }

        token = request_token if request_token else self.token

        if token:
            oauth_params['oauth_token'] = token.key

        params.update(oauth_params)

        oauth_request = oauth.OAuthRequest.from_request(method, resource_url, parameters=params)
        oauth_request.sign_request(self.signature_method, self.consumer, token)

        return oauth_request.to_header(), params
Exemplo n.º 20
0
    def complete_parameters(self, url, params={}, exclude_signature=[]):

        defaults = {
            'oauth_timestamp': str(int(time.time())),
            'oauth_nonce': oauth.generate_nonce(),
            'signature_method': "HMAC-SHA1",
            'oauth_token': self.access_token.key,
            'oauth_consumer_key': self.consumer.key,
        }

        excluded = {}
        for e in exclude_signature:
            excluded[e] = params.pop(e)

        defaults.update(params)
        req = oauth.OAuthRequest(http_method="POST",
                                 http_url=url,
                                 parameters=defaults)
        req.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(), self.consumer,
                         self.access_token)
        req.parameters.update(excluded)

        return req
Exemplo n.º 21
0
def oauth_get_request_token(oaConsumer, url):
    '''Get an OAuth request token URL to use for verification. Returns a
       tuple of (token, url). The 'url' parameter indicates the destination
       for redirection once the user has validated the request.'''

    oaSig = oauth.OAuthSignatureMethod_HMAC_SHA1()

    oaReq = oauth.OAuthRequest(
        http_method = 'GET',
        http_url = OAUTH2_ENDPOINT_URL + '/get_request_token',
        parameters = {
            'oauth_nonce' : oauth.generate_nonce(),
            'oauth_timestamp' : oauth.generate_timestamp(),
            'oauth_consumer_key' : oaConsumer.key,
            'oauth_version' : '1.0',
            'xoauth_lang_pref' : 'en-us',
            'oauth_callback' : url,
        }
    )

    oaReq.sign_request(oaSig, oaConsumer, None)

    reqTokenResp = None
    try:
        reqTokenResp = urllib2.urlopen(oaReq.to_url())
        reqTokenRespContent = ''.join(reqTokenResp.readlines())

        oaReqToken = oauth.OAuthToken.from_string(reqTokenRespContent)

        return (
            oaReqToken,
            OAUTH2_ENDPOINT_URL + '/request_auth?' +
                urllib.urlencode([('oauth_token', oaReqToken.key)])
        )
    except urllib2.HTTPError, e:
        raise CascadeHTTPError(e)
Exemplo n.º 22
0
    def __init__(self,key = None, secret = None, callback = None, 
                 access_token_key = None, access_token_secret = None,
                 request_token_key = None, request_token_secret = None):

        self.key = key or method_call.API_KEY
        self.secret = secret or method_call.API_SECRET

        if self.key is None or self.secret is None:
            raise ValueError("API keys have not been set.")
        
        if callback is None :
            callback = "http://api.flickr.com/services/rest/?method=flickr.test.echo&api_key=%s"%self.key

        params = {
            'oauth_timestamp': str(int(time.time())),
            'oauth_signature_method':"HMAC-SHA1",
            'oauth_version': "1.0",
            'oauth_callback': callback,
            'oauth_nonce': oauth.generate_nonce(),
            'oauth_consumer_key': self.key
        }

        self.consumer = oauth.OAuthConsumer(key=self.key, secret=self.secret)
        if (access_token_key is None) and (request_token_key is None) :
            req = oauth.OAuthRequest(http_method="GET", http_url=TOKEN_REQUEST_URL, parameters=params)
            req.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(),self.consumer,None)
            resp = urllib2.urlopen(req.to_url())
            request_token = dict(urlparse.parse_qsl(resp.read()))
            self.request_token = oauth.OAuthToken(request_token['oauth_token'],request_token['oauth_token_secret'])
            self.access_token = None
        elif request_token_key is not None :
            self.access_token = None
            self.request_token = oauth.OAuthToken(request_token_key,request_token_secret)
        else :
            self.request_token = None
            self.access_token = oauth.OAuthToken(access_token_key,access_token_secret)
Exemplo n.º 23
0
	def __init__(self, tokens, nojsoncallback=True, format='json', parameters=None):

		self.keys = hidden.keys()
		self.dbtokens = tokens

		self.dbtokens["token"].encode("ascii")
		self.dbtokens["token_secret"].encode('ascii')

		if self.dbtokens is not None:

			self.consumer = oauth.OAuthConsumer(self.keys["oauth_consumer_key"], self.keys["oauth_consumer_secret"])
			self.token = oauth.OAuthToken(self.dbtokens["token"].encode("ascii"), self.dbtokens["token_secret"].encode("ascii"))

			if nojsoncallback:
				self.nojsoncallback = 1
			else:
				self.nojsoncallback = 0
			if not parameters:
				parameters = {}

			self.url = "https://api.flickr.com/services/rest"

			defaults = {
				"format": format,
				"nojsoncallback": self.nojsoncallback,
				"oauth_timestamp": oauth.generate_timestamp(),
				"oauth_nonce": oauth.generate_nonce(),
				"signature_method": "HMAC-SHA1",
				"oauth_token": self.token.key,
				"api_key": self.consumer.key
			}
			#print defaults
			self.parameters = defaults

		else:
			print "token is none"
Exemplo n.º 24
0
    def user_authorize(self):

        defaults = hidden.keys().copy()
        defaults["oauth_timestamp"] = oauth.generate_timestamp()
        defaults["oauth_nonce"] = oauth.generate_nonce()
        defaults["oauth_signature_method"] = "HMAC-SHA1"
        defaults["oauth_version"] = "1.0"
        defaults["oauth_callback"] = "https://www.flickr.com/"

        # Setup the consumer with api_key and api_secret
        consumer = oauth.OAuthConsumer(defaults["oauth_consumer_key"],
                                       defaults["oauth_consumer_secret"])
        # Create request
        oauth_req = oauth.OAuthRequest(http_method="GET",
                                       http_url=self.url_req_token,
                                       parameters=defaults)
        # Create signature
        oauth_req.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(),
                               consumer, None)

        url = oauth_req.to_url()

        print '* Calling Flickr...'
        print
        connection = urllib.urlopen(url)
        data = connection.read()

        request_token = {
            "oauth_token": re.findall("oauth_token=(.+)&", data)[0],
            "oauth_token_secret": re.findall("oauth_token_secret=(.+)",
                                             data)[0]
        }

        #print request_token
        token = oauth.OAuthToken(request_token["oauth_token"],
                                 request_token["oauth_token_secret"])

        print "Go to the following link in your browser:"
        print "http://www.flickr.com/services/oauth/authorize?oauth_token=%s&perms=read" % request_token[
            'oauth_token']
        print

        oauth_verifier = raw_input("Enter the verifier - ")
        print

        defaults["oauth_token"] = request_token["oauth_token"]
        defaults["oauth_verifier"] = oauth_verifier

        del defaults["oauth_consumer_secret"]

        oauth_req = oauth.OAuthRequest(http_method="GET",
                                       http_url=self.url_access_token,
                                       parameters=defaults)
        oauth_req.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(),
                               consumer, token)

        url = oauth_req.to_url()
        connection = urllib.urlopen(url)
        data = connection.read()

        defaults["oauth_token"] = re.findall("oauth_token=(.+?)&", data)[0]
        defaults["oauth_token_secret"] = re.findall(
            "oauth_token_secret=(.+?)&", data)[0]
        defaults["username"] = re.findall("username=(.+)", data)[0]
        defaults["user_nsid"] = re.findall("user_nsid=(.+?)&", data)[0]

        self.tokens["token"] = defaults["oauth_token"]
        self.tokens["token_secret"] = defaults["oauth_token_secret"]

        # Replace %40 in user_id, or the request url would be wrong
        if "%40" in defaults["user_nsid"]:
            self.user_id = defaults["user_nsid"].replace("%40", "@")
            print self.user_id
        else:
            self.user_id = defaults["user_nsid"]

        cur.execute('''INSERT INTO Tokens (token, secret) VALUES (?, ?)''',
                    (defaults["oauth_token"], defaults["oauth_token_secret"]))

        # Named placeholders style
        cur.execute('SELECT id FROM Tokens WHERE token=:t AND secret=:ts', {
            "t": defaults["oauth_token"],
            "ts": defaults["oauth_token_secret"]
        })
        token_id = cur.fetchone()[0]

        # Store username in database
        cur.execute(
            '''
			INSERT OR IGNORE INTO Users (name, token_id, user_id) VALUES (?, ?, ?)''',
            (defaults["username"], token_id, self.user_id))

        conn.commit()
Exemplo n.º 25
0
    def post(self):

        # Loop around Cascade call to allow for retrying if we need to
        # refresh our OAuth access token.
        cascadeResp = None
        oaTokStr = self._oaToken.to_string()
        for attemptNo in range(0, 2):
            # We do our own Cascade request / response handling here, as the
            # API doesn't provide access to the underlying HTTP objects, which
            # we want to expose to our callers.
            oaReq = oauth.OAuthRequest(
                http_method = u'POST',
                http_url = cascade.JSON11_ENDPOINT_URL,
                parameters = {
                    u'oauth_nonce' : oauth.generate_nonce(),
                    u'oauth_timestamp' : oauth.generate_timestamp(),
                    u'oauth_consumer_key' : self._oaConsumer.key,
                    u'oauth_token' : self._oaToken.key,
                    u'oauth_version' : u'1.0'
                }
            )
            oaReq.sign_request(self._oaSig, self._oaConsumer, self._oaToken)
            headers = { 'Content-Type' : 'application/json' }
            url = oaReq.to_url();

            try:
                cascadeReq = urllib2.Request(
                    url = url,
                    data = self.request.body,
                    headers = headers
                )
                cascadeResp = urllib2.urlopen(cascadeReq)

                # We've gotten a 200 response, we're done
                break
            except urllib2.HTTPError, e:
                # Only attempt access token refresh if we haven't already done
                # so, and think that it might work.
                #
                # XXX: Note that there appears to be some bug in the Yahoo!
                #      OAuth implementation that causes really stale tokens to
                #      be rejected with 999 rather than 401.
                if attemptNo > 0 or (e.code != 401 and e.code != 999):
                    cascadeResp = e
                    break

                self._oaToken = cascade.oauth_refresh_access_token(
                    self._oaConsumer,
                    self._oaToken
                )
            except DownloadError, e:
                # We see this if we're getting throttled, wherein Yahoo!  will
                # return an HTTP status code 999 and leave the TCP connection
                # open, timing out the request.
                #
                # XXX: Because of the stale OAuth token bug mentioned above, we
                #      consider this a situation where we should refresh our
                #      OAuth token.
                if attemptNo > 0:
                    raise e

                self._oaToken = cascade.oauth_refresh_access_token(
                    self._oaConsumer,
                    self._oaToken
                )
Exemplo n.º 26
0
 def test_gen_nonce(self):
     nonce = oauth.generate_nonce()
     self.assertEqual(len(nonce), 8)
     nonce = oauth.generate_nonce(20)
     self.assertEqual(len(nonce), 20)
Exemplo n.º 27
0
	def user_authorize(self):

		defaults = hidden.keys().copy()
		defaults["oauth_timestamp"] = oauth.generate_timestamp()
		defaults["oauth_nonce"] = oauth.generate_nonce()
		defaults["oauth_signature_method"] = "HMAC-SHA1"
		defaults["oauth_version"] = "1.0"
		defaults["oauth_callback"] = "https://www.flickr.com/"

		# Setup the consumer with api_key and api_secret
		consumer = oauth.OAuthConsumer(defaults["oauth_consumer_key"], defaults["oauth_consumer_secret"])
		# Create request
		oauth_req = oauth.OAuthRequest(http_method="GET", http_url=self.url_req_token, parameters=defaults)
		# Create signature
		oauth_req.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(),consumer, None)

		url = oauth_req.to_url()

		print '* Calling Flickr...'
		print
		connection = urllib.urlopen(url)
		data = connection.read()

		request_token = {
			"oauth_token": re.findall("oauth_token=(.+)&",data)[0],
			"oauth_token_secret": re.findall("oauth_token_secret=(.+)",data)[0]
		}

		#print request_token
		token = oauth.OAuthToken(request_token["oauth_token"], request_token["oauth_token_secret"])

		print "Go to the following link in your browser:"
		print "http://www.flickr.com/services/oauth/authorize?oauth_token=%s&perms=read" % request_token['oauth_token']
		print

		oauth_verifier = raw_input("Enter the verifier - ")
		print

		defaults["oauth_token"] = request_token["oauth_token"]
		defaults["oauth_verifier"] = oauth_verifier

		del defaults["oauth_consumer_secret"]

		oauth_req = oauth.OAuthRequest(http_method="GET", http_url=self.url_access_token, parameters=defaults)
		oauth_req.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(),consumer, token)

		url = oauth_req.to_url()
		connection = urllib.urlopen(url)
		data = connection.read()

		defaults["oauth_token"] = re.findall("oauth_token=(.+?)&", data)[0]
		defaults["oauth_token_secret"] = re.findall("oauth_token_secret=(.+?)&", data)[0]
		defaults["username"] = re.findall("username=(.+)",data)[0]
		defaults["user_nsid"] = re.findall("user_nsid=(.+?)&",data)[0]

		self.tokens["token"] = defaults["oauth_token"]
		self.tokens["token_secret"] = defaults["oauth_token_secret"]

		# Replace %40 in user_id, or the request url would be wrong
		if "%40" in defaults["user_nsid"]:
			self.user_id = defaults["user_nsid"].replace("%40","@")
			print self.user_id
		else:
			self.user_id = defaults["user_nsid"]

		cur.execute('''INSERT INTO Tokens (token, secret) VALUES (?, ?)''',
			(defaults["oauth_token"], defaults["oauth_token_secret"]) )

		# Named placeholders style
		cur.execute('SELECT id FROM Tokens WHERE token=:t AND secret=:ts', {"t":defaults["oauth_token"], "ts":defaults["oauth_token_secret"]} )
		token_id = cur.fetchone()[0]

		# Store username in database
		cur.execute('''
			INSERT OR IGNORE INTO Users (name, token_id, user_id) VALUES (?, ?, ?)'''
			,(defaults["username"], token_id, self.user_id) )

		conn.commit()
Exemplo n.º 28
0
def oauth_get_access_token(oaConsumer, oaReqToken):
    '''Get an OAuth access token from the given token (either request or
       access). Returns an oauth.OAuthToken, possibly  with some extra
       instance variables set to reflect presence of OAuth extension
       attributes in the response (e.g.  session handle, expiration time,
       etc). Can be called with an access token to attempt a refresh (which
       still returns a new token).'''

    oaSig = oauth.OAuthSignatureMethod_HMAC_SHA1()

    oaReqParams = {
        'oauth_nonce' : oauth.generate_nonce(),
        'oauth_timestamp' : oauth.generate_timestamp(),
        'oauth_consumer_key' : oaConsumer.key,
        'oauth_token' : oaReqToken.key,
        'oauth_version' : '1.0',
    }

    # If our token has a session handle, add it to our parmeter dictionary.
    # This should only be the case if we're requesting a new access token
    # (i.e. not doing a token refresh, as access tokens do not have a
    # verifier).
    if 'verifier' in oaReqToken.__dict__:
        oaReqParams['oauth_verifier'] = oaReqToken.verifier

    # If our token has a session handle, add it to our parmeter dictionary.
    # This should only be the case if we're doing a token refresh from an
    # access token.
    if 'session_handle' in oaReqToken.__dict__:
        oaReqParams['oauth_session_handle'] = oaReqToken.session_handle

    oaReq = oauth.OAuthRequest(
        http_method = 'GET',
        http_url = OAUTH2_ENDPOINT_URL + '/get_token',
        parameters = oaReqParams
    )

    oaReq.sign_request(oaSig, oaConsumer, oaReqToken)

    accTokenResp = None
    try:
        accTokenResp = urllib2.urlopen(oaReq.to_url())
        accTokenRespContent = ''.join(accTokenResp.readlines())

        accTok = oauth.OAuthToken.from_string(accTokenRespContent)

        # Look for any extra query parameters that provide data from OAuth
        # extensions that we might care about. Specifically, make sure to
        # grab the session handle so that we can refresh the access token.
        accTokParams = cgi.parse_qs(
            accTokenRespContent,
            keep_blank_values = False
        )
        if 'oauth_expires_in' in accTokParams:
            accTok.expires_on = \
                int(time.time()) + \
                int(accTokParams['oauth_expires_in'][0])
        if 'oauth_session_handle' in accTokParams:
            accTok.session_handle = accTokParams['oauth_session_handle'][0]
        if 'oauth_authorization_expires_in' in accTokParams:
            accTok.authorization_expires_on = \
                int(time.time()) + \
                int(accTokParams['oauth_authorization_expires_in'][0])
        if 'xoauth_yahoo_guid' in accTokParams:
            accTok.yahoo_guid = accTokParams['xoauth_yahoo_guid'][0]

        return accTok
    except urllib2.HTTPError, e:
        raise CascadeHTTPError(e)
Exemplo n.º 29
0
def cmd_call(argv):
    '''Make a single Cascade call.'''

    op = OptionParser(
        usage = '''%prog call <method> [options]
        
Calls the Cascade method <method>. Parameters to the call should be passed on
stdin as a JSON blob. The results of the call are written to stdout.'''
    )
    op.add_option(
        '-i', dest = 'input', default = None,
        help = '''set the file from which to read input (default: stdin)'''
    )
    op.add_option(
        '-u', '--url-params', dest = 'urlParams', action = 'store_true',
        default = False,
        help = '''send OAuth parameters as URL query parameters, rather than 
using an Authorization header.'''
    )
    op.add_option(
        '-k', '--oauth-consumer-key', dest = 'oauthConsumerKey', default = None,
        help = '''the OAuth consumer key; required'''
    )
    op.add_option(
        '-s', '--oauth-consumer-secret', dest = 'oauthConsumerSecret', default = None,
        help = '''the OAuth consumer secret; required'''
    )
    op.add_option(
        '-a', '--oauth-access-token', dest = 'oauthAccessToken', default = None,
        help = '''the OAuth access token to use, in the form of a query string
from oauth_token_to_query_string(); this is the preferred method of specifying
an access token, over --oauth-access-token-* (default: %default)'''
    )
    op.add_option(
        '--oauth-access-token-key', dest = 'oauthAccessTokenKey', default = None,
        help = '''the OAuth access token key; required'''
    )
    op.add_option(
        '--oauth-access-token-secret', dest = 'oauthAccessTokenSecret',
        default = None,
        help = '''the OAuth access token secret; required'''
    )
    op.add_option(
        '--oauth-timestamp', dest = 'oauthTimestamp', type = 'int',
        default = oauth.generate_timestamp(),
        help = '''the timestamp to use for OAuth signing, in epoch seconds
(default: %default)'''
    )
    op.add_option(
        '--oauth-nonce', dest = 'oauthNonce', default = oauth.generate_nonce(),
        help = '''the nonce to use for OAuth signing (default: %default)'''
    )

    opts, args = op.parse_args(argv)
    PROG_NAME = op.get_prog_name()

    # Get our method name and parameters
    if len(args) != 1:
        op.print_usage(sys.stderr)
        sys.exit(1)

    methodName = args[0]

    inputFile = sys.stdin
    if opts.input:
        inputFile = open(opts.input, 'r')
    methodParams = simplejson.loads(''.join(inputFile.readlines()))
    if opts.input:
        inputFile.close()

    # Create our OAuth consumer
    if opts.oauthConsumerKey and \
       opts.oauthConsumerSecret:
        oaConsumer = oauth.OAuthConsumer(
            opts.oauthConsumerKey,
            opts.oauthConsumerSecret
        )
    else:
        sys.stderr.write(
            '\'%s\': consumer key options not specified\n' % (PROG_NAME)
        )
        op.print_usage(sys.stderr)
        sys.exit(1)

    # Create our OAuth access token
    if opts.oauthAccessToken:
        oaTok = oauth_token_from_query_string(opts.oauthAccessToken)
    elif opts.oauthAccessTokenKey and \
            opts.oauthAccessTokenSecret:
        oaTok = oauth.OAuthToken(
            opts.oauthAccessTokenKey,
            opts.oauthAccessTokenSecret
        )
    else:
        sys.stderr.write(
            '\'%s\': access token options not specified\n' % (PROG_NAME)
        )
        op.print_usage(sys.stderr)
        sys.exit(1)

    # Make the call, overriding any OAuth parametsrs as specified
    jc = JSON11Client(oaConsumer, oaTok, not opts.urlParams)

    oauthDefaults = {}
    if opts.oauthNonce:
        oauthDefaults['oauth_nonce'] = opts.oauthNonce
    if opts.oauthTimestamp:
        oauthDefaults['oauth_timestamp'] = opts.oauthTimestamp

    try:
        result = jc.call(
            methodName, 
            params = methodParams,
            oauthDefaults = oauthDefaults
        )
    except CascadeHTTPError, e:
        sys.stderr.write('\'%s\': call failed %s\n' % (PROG_NAME, str(e)))
        sys.exit(1)
Exemplo n.º 30
0
    def call(self, method, params = [{}], id = None, oauthDefaults = {}):
        '''Call the given method using the specified parameters (which are
           passed directly as the 'params' value in the JSON payload).
           Returns a result object derived from un-serializing the response
           JSON data. The optional 'id' value is the Cascade call ID, which
           is not sent in the request if un-specified.

           The 'oauthDefaults' dictionary can be used to specify default OAuth
           parameter values. For example, one can use this to force a specific
           nonce or timestamp value. Any parameters not specifed in this
           dictionary fall back to their OAuth defaults (e.g. generate a new
           nonce).
           
           Raises a CascadeHTTPError if problems arise.'''

        # Populate OAuth parameters
        oauthParameters = {
            'oauth_nonce' : oauth.generate_nonce(),
            'oauth_timestamp' : oauth.generate_timestamp(),
            'oauth_consumer_key' : self.__oaConsumer.key,
            'oauth_version' : '1.0'
        }
        oauthParameters.update(oauthDefaults)

        # Populate Cascade parameters
        data = {
            'method' : method,
            'params' : params
        }
        if id:
            data['id'] = id
        data = simplejson.dumps(data)

        for attemptNo in range(0, 2):
            logging.debug('Making request %d / 2' % (attemptNo + 1))

            # Set the token every time through our loop, as we may have changed
            # our token due to it being stale
            oauthParameters['oauth_token'] = self.__oaToken.key

            # Construct and sign the request within our retry loop so that
            # we pick up any refresh of the access token
            oaReq = oauth.OAuthRequest(
                http_method = 'POST',
                http_url = JSON11_ENDPOINT_URL,
                parameters = oauthParameters
            )
            oaReq.sign_request(self.__oaSig, self.__oaConsumer, self.__oaToken)

            headers = { 'Content-Type' : 'application/json' }
            url = JSON11_ENDPOINT_URL

            if self.__sendAuthorizationHeader:
                headers.update(oaReq.to_header())
            else:
                url = oaReq.to_url()

            logging.debug('HTTP headers: ' + pprint.pformat(headers))

            cascadeResp = None
            try:
                cascadeReq = urllib2.Request(
                    url = url,
                    data = data,
                    headers = headers
                )

                cascadeResp = urllib2.urlopen(cascadeReq)

                return simplejson.loads(''.join(cascadeResp.readlines()))
            except urllib2.HTTPError, e:
                logging.info(
                    'HTTP request failed: code=%d; message=\'%s\'' % (
                        e.code, e.msg
                    )
                )

                # If we see something other than a 401 on our first attempt
                # to make the call, give up. Otherwise, attempt to refresh
                # our access token and try again.
                if attemptNo > 0 or e.code != 401:
                    raise CascadeHTTPError(e)

                logging.info('Refreshing OAuth access token ' + self.__oaToken.key)

                self.__oaToken = oauth_refresh_access_token(
                    self.__oaConsumer,
                    self.__oaToken
                )

                logging.info('New OAuth access token is ' + self.__oaToken.key)
            finally: