def lookup_consumer(self, key): memkey = 'OAuthConsumerKey-' + key secret = memcache.get(memkey) if secret is not None: return oauth.OAuthConsumer(key, secret) que = db.Query(OAuthConsumerKey).filter('consumer =', key) results = que.fetch(limit=1) if len(results) > 0: secret = results[0].secret memcache.set(memkey, secret, 7200) return oauth.OAuthConsumer(key, secret) # Demo hard coded hacks if there are no keys que = db.Query(OAuthConsumerKey) results = que.fetch(limit=1) if len(results) < 1: if key == "lmsng.school.edu": memcache.set(memkey, 'secret', 7200) return oauth.OAuthConsumer(key, "secret") if key == "12345": memcache.set(memkey, 'secret', 7200) return oauth.OAuthConsumer(key, "secret") logging.info("Did not find consumer " + key) return None
def __init__(self, consumer_key, consumer_secret, oauth_token=None, oauth_token_secret=None): self.sha1_method = oauth.OAuthSignatureMethod_HMAC_SHA1() self.consumer = oauth.OAuthConsumer(consumer_key, consumer_secret) if ((oauth_token != None) and (oauth_token_secret != None)): self.token = oauth.OAuthConsumer(oauth_token, oauth_token_secret) else: self.token = None
def __init__(self, name, key, secret, extra_key=None, extra_secret=None): self.name = name self.normalized_name = self.normalize_name(name) self.consumer = oauth.OAuthConsumer(key, secret) self.consumers = dict() self.consumers[key] = self.consumer if extra_key and extra_secret: self.consumers[extra_key] = oauth.OAuthConsumer( extra_key, extra_secret)
def __init__(self, consumer_key, consumer_secret, server_params, oauth_token=None, oauth_token_secret=None): """ params should be a dictionary including root_url, request_token_path, authorize_path, authenticate_path, access_token_path """ self.server_params = server_params self.sha1_method = oauth.OAuthSignatureMethod_HMAC_SHA1() self.consumer = oauth.OAuthConsumer(consumer_key, consumer_secret) if ((oauth_token != None) and (oauth_token_secret!=None)): self.token = oauth.OAuthConsumer(oauth_token, oauth_token_secret) else: self.token = None
def augment(url, parameters): secrets = hidden.oauth() consumer = oauth.OAuthConsumer(secrets['consumer_key'], secrets['consumer_secret']) token = oauth.OAuthConsumer(secrets['token_key'], secrets['token_secret']) oauth_request = oauth.OAuthRequest.from_consumer_and_token( consumer, token=token, http_method='GET', http_url=url, parameters=parameters) oauth_request.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(), consumer, token) return oauth_request.to_url()
def augment(url, parameters, credentials, http_method='GET'): """ Create a URL for HTTP request with authentication information. These are added as extra parameters. """ # Create an object with the api key and secret key as attributes `key` and `secret`: consumer = oauth.OAuthConsumer(credentials['api_key'], credentials['api_secret_key']) # Create an object with the token and token secret as attributes; this object has to/from string methods: token = oauth.OAuthToken(credentials['access_token'], credentials['access_token_secret']) # Create an object with all the provided information plus OAuth version, timestamp and random number: oauth_request = oauth.OAuthRequest.from_consumer_and_token( consumer, token=token, http_method=http_method, http_url=url, parameters=parameters) # Create the attribute 'oauth_signature' in the object; this attribute is a authentication signature built from my secret key and the full message to be sent: oauth_request.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(), consumer, token) return oauth_request.to_url()
def bind(self, verifier): s = Session.get_by_key_name(self._jid) if s: token = oauth.OAuthToken.from_string(s.data) consumer = oauth.OAuthConsumer(config.OAUTH_CONSUMER_KEY, config.OAUTH_CONSUMER_SECRET) oauth_request = oauth.OAuthRequest.from_consumer_and_token(consumer, token=token, verifier=verifier, http_url=config.ACCESS_TOKEN_URL) signature_method_hmac_sha1 = oauth.OAuthSignatureMethod_HMAC_SHA1() oauth_request.sign_request(signature_method_hmac_sha1, consumer, token) try: result = urlfetch.fetch(oauth_request.to_url(), method=oauth_request.http_method) except urlfetch.Error: return 'Network Error!' try: token = oauth.OAuthToken.from_string(result.content) except BaseException: return 'Wrong verifier!' u = User.get_by_key_name(self._jid) if u: u.access_key = token.key u.access_secret = token.secret u.put() else: User(key_name=self._jid, access_key=token.key, access_secret=token.secret).put() s.data = None s.put() return 'Successfully bind your account.'
def oauth(self, mobile=None): consumer = oauth.OAuthConsumer(config.OAUTH_CONSUMER_KEY, config.OAUTH_CONSUMER_SECRET) params = {'xoauth_displayname': 'Gmail2GTalk', 'scope': config.RESOURCE_URL} oauth_request = oauth.OAuthRequest.from_consumer_and_token(consumer, callback='oob', parameters=params, http_url=config.REQUEST_TOKEN_URL) signature_method_hmac_sha1 = oauth.OAuthSignatureMethod_HMAC_SHA1() oauth_request.sign_request(signature_method_hmac_sha1, consumer, None) try: result = urlfetch.fetch(oauth_request.to_url(), method=oauth_request.http_method) except urlfetch.Error: return 'Network Error!' token = oauth.OAuthToken.from_string(result.content) s = Session.get_by_key_name(self._jid) if not s: Session(key_name=self._jid, data=result.content).put() else: s.data = result.content s.put() if mobile == 'mobile': params = {'btmpl': 'mobile'} else: params = None oauth_request = oauth.OAuthRequest.from_token_and_callback(token, http_url=config.AUTHORIZATION_URL, parameters=params) url = oauth_request.to_url() return 'Please visit following url to authorize:\n%s' % url
def createOauthRequest(http_url, params, default_params): validateOptions(params, default_params) default_params.update(params) params = default_params http_method = 'GET' token = params.pop('token', None) base_url = 'https://www.pesapal.com/api/' if testing: base_url = 'https://demo.pesapal.com/api/' url = base_url + http_url if not consumer_key: raise MissingKeyError('provide consumer key') if not consumer_secret: raise MissingKeyError('provide consumer consumer_secret') oauth_consumer = oauth.OAuthConsumer(consumer_key, consumer_secret) request = OAuthRequest.from_consumer_and_token(oauth_consumer, http_url=url, http_method=http_method, parameters=params) request.sign_request(SIGNATURE_METHOD, oauth_consumer, token) return request.to_url()
def __init__(self, consumer_key, consumer_secret): self.consumer_key = consumer_key self.consumer_secret = consumer_secret self.consumer = oauth.OAuthConsumer(self.consumer_key, self.consumer_secret) self.sig_method = oauth.OAuthSignatureMethod_HMAC_SHA1() self.connection = httplib.HTTPSConnection("twitter.com")
def doRequest(method, params): global config consumer = oauth.OAuthConsumer(PUBLIC_KEY, PRIVATE_KEY) token = oauth.OAuthToken(config['telldus']['token'], config['telldus']['tokenSecret']) oauth_request = oauth.OAuthRequest.from_consumer_and_token( consumer, token=token, http_method='GET', http_url="http://api.telldus.com/json/" + method, parameters=params) oauth_request.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(), consumer, token) headers = oauth_request.to_header() headers['Content-Type'] = 'application/x-www-form-urlencoded' conn = httplib.HTTPConnection("api.telldus.com:80") conn.request('GET', "/json/" + method + "?" + urllib.urlencode(params, True).replace('+', '%20'), headers=headers) response = conn.getresponse() return json.load(response)
def __init__(self, consumer_key, consumer_secret, callback=None): self._consumer = oauth.OAuthConsumer(consumer_key, consumer_secret) self._sigmethod = oauth.OAuthSignatureMethod_HMAC_SHA1() self.request_token = None self.access_token = None self.callback = callback or 'null' # fixed self.username = None
def __init__(self, twitter_config, urlToken=None): """ Initialise an instance of the TwitterAuth class that will enable us to create an oauth access token with twitter """ # initialise the configuration self.config = twitter_config self.requestToken = urlToken self.accessToken = None # create the consumer self.consumer = oauth.OAuthConsumer(self.config.consumerKey, self.config.consumerSecret) # if the oauth token is not set, then prepare the request token and authorization steps if self.requestToken is None: # create the request token self.requestToken = self._initRequestToken(URL_REQUEST_TOKEN) # authorize the request token self._authorizeToken() # otherwise, create an oauth token from the string passed to the function else: # look for the twitter user from the database requestKey = OAuthAccessKey.findByRequestKey(self.requestToken) # if we found the user if requestKey is not None: self.accessToken = oauth.OAuthToken.from_string( requestKey.requestKeyEncoded)
def __init__(self, token=None): self.consumer = oauth.OAuthConsumer(settings.TWITTERAUTH_KEY, settings.TWITTERAUTH_SECRET) self.conn = None self.conn1 = None self.signature_method = oauth.OAuthSignatureMethod_HMAC_SHA1() self.token = token
def __init__(self, use_sandbox=False, server_rpc_base=None, consumer_key='anonymous', consumer_secret='anonymous', http_post=None): """Initializes a service that can perform the various OAuth steps. Args: use_sandbox: A boolean indicating whether to use Wave Sandbox URLs server_rpc_base: optional explicit url to use for rpc, overriding use_sandbox. consumer_key: A string for the consumer key, defaults to 'anonymous' consumer_secret: A string for the consumer secret, defaults to 'anonymous' http_post: handler to call to execute a http post. """ self._consumer = oauth.OAuthConsumer(consumer_key, consumer_secret) logging.info('server_rpc_base: %s', server_rpc_base) if server_rpc_base: self._server_rpc_base = server_rpc_base elif use_sandbox: self._server_rpc_base = WaveService.SANDBOX_RPC_URL else: self._server_rpc_base = WaveService.RPC_URL logging.info('server:' + self._server_rpc_base) self._http_post = self.http_post self._connection = httplib.HTTPSConnection('www.google.com') self._access_token = None
def _generate_unittest_settings(): '''Generate a cascade_unittest_settings.py module in the current directory.''' print '>>> generating cascade_unittest_settings.py' sys.stdout.write('consumer key: ') consumerKey = sys.stdin.readline().strip() sys.stdout.write('consumer secret: ') consumerSecret = sys.stdin.readline().strip() sys.stdout.write('consumer callback URL: ') consumerCbUrl = sys.stdin.readline().strip() oaConsumer = oauth.OAuthConsumer(consumerKey, consumerSecret) reqTok, url = oauth_get_request_token(oaConsumer, consumerCbUrl) print '''>>> navigate to the following URL in your browser, then paste in token callback URL that results''' print url sys.stdout.write('token callback URL: ') tokenCbUrl = sys.stdin.readline().strip() tokenCbUrlQp = urlparse.urlsplit(tokenCbUrl).query tokenCbUrlDict = cgi.parse_qs(tokenCbUrlQp) assert(tokenCbUrlDict['oauth_token'][0] == reqTok.key) reqTok.set_verifier(tokenCbUrlDict['oauth_verifier'][0]) accTok = oauth_get_access_token(oaConsumer, reqTok) _write_unittest_settings(consumerKey, consumerSecret, accTok)
def setUp(self): # XXX: This is funky. Because we're doing an import from within the # confines of this class method, unless we're careful, the import # of this module will get bound to a local variable. Instead, we # make sure that it gets bound to a global. global cascade_unittest_settings # Load up unittest settings, creating them if non-existant. These # are stashed in cascade_unittest_settings.py and are loaded using # the standard module path. try: import cascade_unittest_settings except ImportError: _generate_unittest_settings() try: import cascade_unittest_settings except ImportError: print sys.stderr, '>>> unable to configure settings; exiting' sys.exit(1) # Create OAuth objects (a consumer, a request token, and access # token if requested) from unittest settings. self._oaConsumer = oauth.OAuthConsumer( cascade_unittest_settings.OAUTH_CONSUMER_KEY, cascade_unittest_settings.OAUTH_CONSUMER_SECRET ) self._oaAccessToken = oauth_token_from_query_string(cascade_unittest_settings.OAUTH_ACCESS_TOKEN)
def __init__(self, consumer_key, consumer_secret, account_id, username): self.consumer = oauth.OAuthConsumer(consumer_key, consumer_secret) self.signature_method_hmac_sha1 = oauth.OAuthSignatureMethod_HMAC_SHA1( ) self.oauth_token = None self.account_id = account_id self.username = username
def get(self): # setup/initial client = SimpleOAuthClient(SERVER, PORT, REQUEST_TOKEN_URL, ACCESS_TOKEN_URL, AUTHORIZATION_URL) consumer = oauth.OAuthConsumer(CONSUMER_KEY, CONSUMER_SECRET) signature_method_plaintext = oauth.OAuthSignatureMethod_PLAINTEXT() signature_method_hmac_sha1 = oauth.OAuthSignatureMethod_HMAC_SHA1() # get request token # print '* Obtain a request token ...' oauth_request = oauth.OAuthRequest.from_consumer_and_token( consumer, callback=CALLBACK_URL, http_url=client.request_token_url) oauth_request.sign_request(signature_method_plaintext, consumer, None) #print 'REQUEST (via headers)' #print 'parameters: %s' % str(oauth_request.parameters) cid = str(int(random.uniform(0, sys.maxint))) token = client.fetch_request_token(oauth_request) memcache.set("PK_" + cid, token.to_string()) PHASETWO_CALLBACK_URL = 'http://' + os.environ[ 'HTTP_HOST'] + '/oauth_authorized?id=' + cid #print '* Authorize the request token ...' oauth_request = oauth.OAuthRequest.from_token_and_callback( token=token, callback=PHASETWO_CALLBACK_URL, http_url=client.authorization_url) #??? response = client.authorize_token(oauth_request) #??? self.redirect(response) # OR USING BELOW LINES instead ? oauth_request.sign_request(signature_method_hmac_sha1, consumer, token) self.redirect(oauth_request.to_url())
def getAccessToken(): global config consumer = oauth.OAuthConsumer(PUBLIC_KEY, PRIVATE_KEY) token = oauth.OAuthToken(config['telldus']['requestToken'], config['telldus']['requestTokenSecret']) request = oauth.OAuthRequest.from_consumer_and_token( consumer, token=token, http_method='GET', http_url='http://api.telldus.com/oauth/accessToken') request.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(), consumer, token) conn = httplib.HTTPConnection('api.telldus.com:80') conn.request(request.http_method, request.to_url(), headers=request.to_header()) resp = conn.getresponse() if resp.status != 200: print('Error retrieving access token, the server replied:\n%s' % resp.read()) return token = oauth.OAuthToken.from_string(resp.read()) config['telldus']['requestToken'] = None config['telldus']['requestTokenSecret'] = None config['telldus']['token'] = str(token.key) config['telldus']['tokenSecret'] = str(token.secret) print('Authentication successful, you can now use tdtool') saveConfig()
def __init__(self, consumer_key, consumer_secret, testing=True): self.oauth_consumer = oauth.OAuthConsumer(consumer_key, consumer_secret) self.base_url = 'https://www.pesapal.com/api/' if testing: self.base_url = 'http://demo2.pesapal.com/api/'
def __init__(self, consumer_key, consumer_secret): self.consumer_key = consumer_key self.consumer_secret = consumer_secret self.oauth_consumer = oauth.OAuthConsumer(consumer_key, consumer_secret) self.signature_method = oauth.OAuthSignatureMethod_HMAC_SHA1() self.access_token = None
def __init__(self, consumer_key, consumer_secret, access_type, locale=None): """Initialize a DropboxSession object. Your consumer key and secret are available at https://www.dropbox.com/developers/apps Args: access_type: Either 'dropbox' or 'app_folder'. All path-based operations will occur relative to either the user's Dropbox root directory or your application's app folder. locale: A locale string ('en', 'pt_PT', etc.) [optional] The locale setting will be used to translate any user-facing error messages that the server generates. At this time Dropbox supports 'en', 'es', 'fr', 'de', and 'ja', though we will be supporting more languages in the future. If you send a language the server doesn't support, messages will remain in English. Look for these translated messages in rest.ErrorResponse exceptions as e.user_error_msg. """ assert access_type in [ 'dropbox', 'app_folder' ], "expected access_type of 'dropbox' or 'app_folder'" self.consumer = oauth.OAuthConsumer(consumer_key, consumer_secret) self.token = None self.request_token = None self.signature_method = oauth.OAuthSignatureMethod_PLAINTEXT() self.root = 'sandbox' if access_type == 'app_folder' else 'dropbox' self.locale = locale
def return_(request): "/return/" CONSUMER = oauth.OAuthConsumer(CONSUMER_KEY, CONSUMER_SECRET) CONNECTION = httplib.HTTPSConnection(SERVER) unauthed_token = user = getCurrentUser(request)["unauthed_token"] if not unauthed_token: return HttpResponse("No un-authed token cookie") token = oauth.OAuthToken.from_string(unauthed_token) if token.key != request.GET.get("oauth_token", "no-token"): return HttpResponse("Something went wrong! Tokens do not match") access_token = exchange_request_token_for_access_token(CONSUMER, CONNECTION, token) clog(str(access_token)) exis_user = getCollUsers().find_one({"access_token":str(access_token)}) response = HttpResponseRedirect("/") user = getCurrentUser(request); if exis_user and user["_id"]!=exis_user["_id"]: users = getCollUsers() clog("delete temp user") users.remove({"_id":user["_id"]}, safe=True) setCookie(response, "newsrivr_userid_md5", str(exis_user["newsrivr_userid_md5"])) checkDoubleUsernames(exis_user["screen_name"]) else: user["access_token"] = access_token.to_string() user["newuser"] = True users = getCollUsers() users.save(user, safe=True) return response
def get_access_token(self,token=None,verifier=None): if verifier: r = self.oauth_request(self.access_token_url(), args={'oauth_verifier': verifier}) else: r = self.oauth_request(self.access_token_url()) token = self.oauth_parse_response(r) self.token = oauth.OAuthConsumer(token['oauth_token'],token['oauth_token_secret']) return token
def get_request_token(self): response = self.oauth_request(self.request_token_url()) token = self.oauth_parse_response(response) try: self.token = oauth.OAuthConsumer(token['oauth_token'],token['oauth_token_secret']) return token except: raise oauth.OAuthError('Invalid oauth_token')
def __init__(self, consumer_key, consumer_secret, access_token=None): if access_token: Api.__init__(self, access_token.key, access_token.secret) else: Api.__init__(self) self._Consumer = oauth.OAuthConsumer(consumer_key, consumer_secret) self._signature_method = oauth.OAuthSignatureMethod_HMAC_SHA1() self._access_token = access_token
def __init__(self, ): self.client = TOAuthClient(SERVER, PORT, REQUEST_TOKEN_URL, ACCESS_TOKEN_URL, AUTHORIZATION_URL) self.consumer = oauth.OAuthConsumer(CONSUMER_KEY, CONSUMER_SECRET) self.signature_method_plaintext = oauth.OAuthSignatureMethod_PLAINTEXT( ) self.signature_method_hmac_sha1 = oauth.OAuthSignatureMethod_HMAC_SHA1( )
def _get_signed_oauth_request(key, secret, parameters, url): consumer = oauth.OAuthConsumer(key, secret) request = oauth.OAuthRequest.from_consumer_and_token(consumer, http_method=_POST, http_url=url, parameters=parameters) request.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(), consumer, None) return request
def __init__(self, uid, key=None, secret=None): self.uid = uid self.key = key self.secret = secret self.consumer = oauth.OAuthConsumer(API_KEY, API_SECRET) if key and secret: self.token = oauth.OAuthToken(key, secret) else: self.token = None