def __init__(self, data_file, client_id, client_secret, from_address, header, footer): Source.__init__(self, data_file) self.consumer = Consumer(client_id, client_secret) self.from_address = from_address self.header = header self.footer = footer self.access_token = None
def getCert(self, id, cfg, token, verifier): oauthKey = cfg[OAUTH_CONSUMER_KEY] params = { 'oauth_nonce': generate_nonce(), 'oauth_token': token, 'oauth_verifier': verifier, 'oauth_timestamp': generate_timestamp(), 'oauth_signature_method': 'RSA-SHA1', 'oauth_consumer_key': oauthKey, 'oauth_version': '1.0' } consumer = Consumer(oauthKey, '') rsa_sha1 = SignatureMethod_RSA_SHA1( privateKeyFile=cfg[PRIVATE_KEY_FILE_TAG]) client = OA4MPClient(consumer=consumer) client.set_signature_method(rsa_sha1) response, content = client.request(cfg[SERVICE_URI_TAG] + '/token', parameters=params) tokens = content.split('&') access_token = urllib.unquote(tokens[0].split('=')[1]) params = { 'oauth_nonce': generate_nonce(), 'oauth_token': access_token, 'oauth_timestamp': generate_timestamp(), 'oauth_signature_method': 'RSA-SHA1', 'oauth_consumer_key': oauthKey, 'oauth_version': '1.0' } # we now have the token and the secret. consumer = Consumer(oauthKey, '') rsa_sha1 = SignatureMethod_RSA_SHA1( privateKeyFile=cfg[PRIVATE_KEY_FILE_TAG]) client = OA4MPClient(consumer=consumer) client.set_signature_method(rsa_sha1) response, content = client.request(cfg[SERVICE_URI_TAG] + '/getcert', parameters=params) tokens = content.split('\n') username = urllib.unquote(tokens[0].split('=')[1]) tokens = tokens[1:] certs = '\n'.join(tokens) fileStore = FileStore(cfg) asset = fileStore.get(id) asset[USERNAME_KEY] = username asset[CERTS_KEY] = certs fileStore.put(id, asset) return username, certs
def request(self, url, method="GET", params={}, body='', headers=''): if not self.consumer_key or not self.consumer_secret or not self.access_token or not self.access_token_secret: message = "BaseOAuth: Required parameters not provided." logger.error(message) raise Exception(message) consumer = Consumer(key=self.consumer_key, secret=self.consumer_secret) token = Token(key=self.access_token, secret=self.access_token_secret) client = Client(consumer, token) _url = url if url[-1] != '?': _url += '?' _url += '&'.join( map(lambda x: "{}={}".format(x, params[x]), params.keys())) url = _url logger.info("{}: {}, Body: {}, Headers: {}".format( method, url, body, headers)) resp, content = client.request(url, method=method, body=body, headers=headers) return content
def __init__(self, api_key: str, api_secret: str, base_url: str = "https://www.plurk.com"): self.consumer = Consumer(api_key, api_secret) # type:Consumer self.client = Client(self.consumer) # type:Client self.base_url = base_url # type:str
def authenticate(self, key, secret): consumer = Consumer(settings.TWITTER_CONSUMER_KEY, settings.TWITTER_CONSUMER_SECRET) token = Token(key, secret) client = Client(consumer, token) response, content = client.request(twitter_auth_settings.ACCESS_TOKEN_URL, "GET") if not response.get('status') == '200': raise TwitterAuthException("Invalid response from Twitter.", response) access_token = dict(cgi.parse_qsl(content)) # if we have an access token, it means we have authenticated with Twitter user, created = User.objects.get_or_create(username=access_token['screen_name']) if created: twitter_user_created.send( sender="TwitterAuth", user=user, screen_name=access_token['screen_name'], user_id=access_token['user_id'] ) # give the user a temporary password - it should never be needed since # Twitter is providing the authentication token. user.set_password(User.objects.make_random_password(length=12)) user.save() # update credentials user.twitterauth.oauth_token = access_token.get('oauth_token') user.twitterauth.oauth_secret = access_token.get('oauth_token_secret') user.twitterauth.save() twitter_user_authenticated.send(sender='TwitterAuth', user=user) return user
def main(args): conf = configparser.SafeConfigParser() try: conf.read(args.configfile) consumer_key = conf.get('general', 'consumer_key') consumer_secret = conf.get('general', 'consumer_secret') user_key = conf.get('general', 'user_key') user_secret = conf.get('general', 'user_secret') except Exception as e: print('err: (', args.configfile, ')', e, file=sys.stderr) sys.exit(1) twclient = Client( Consumer(consumer_key, consumer_secret), Token(user_key, user_secret), ) if args.replyid is None: ret = twclient.request( 'https://api.twitter.com/1.1/statuses/update.json', 'POST', urlencode({'status': args.message})) else: ret = twclient.request( 'https://api.twitter.com/1.1/statuses/update.json', 'POST', urlencode({ 'status': args.message, 'in_reply_to_status_id': args.replyid })) if int(ret[0]['status']) == 200: print(ret[1].decode('utf-8')) else: print('err:', ret[0]['status'], file=sys.stderr) print(ret[1].decode('utf-8')) sys.exit(2)
def do(config, token=None, sec=None, verifier=None): consumer = Consumer(config['consumer_key'], config['consumer_sec']) client = Client(consumer) response, content = client.request(REQUEST_TOKEN_URL, 'GET') request_token = dict(urlparse.parse_qsl(content)) print request_token['oauth_token'] print request_token['oauth_token_secret'] print '%s?oauth_token=%s' % (AUTHORIZE_URL, request_token['oauth_token'])
def get_access_token(config, token, sec, verifier): consumer = Consumer(config['consumer_key'], config['consumer_sec']) token = Token(token, sec) token.set_verifier(verifier) client = Client(consumer, token) response, content = client.request(ACCESS_TOKEN_URL) access_token = dict(urlparse.parse_qsl(content)) print access_token
def __init__(self, server, request_token_url, access_token_url, authorization_url, consumer_key, consumer_secret): self.server = server self.request_token_url = request_token_url self.access_token_url = access_token_url self.authorization_url = authorization_url self.consumer = Consumer(consumer_key, consumer_secret) self.connection = httplib.HTTPSConnection(str(self.server))
class Google(Source): def __init__(self, data_file, client_id, client_secret, from_address, header, footer): Source.__init__(self, data_file) self.consumer = Consumer(client_id, client_secret) self.from_address = from_address self.header = header self.footer = footer self.access_token = None def setUp(self): try: refresh_token = self._read_from_file('google') except (IOError, ValueError, KeyError): refresh_token = None if not refresh_token: print self.consumer.authorize( AUTH_URL, 'code', redirect_uri='urn:ietf:wg:oauth:2.0:oob', scope='%20'.join([ 'https://mail.google.com/', 'https://www.googleapis.com/auth/gmail.modify', 'https://www.googleapis.com/auth/gmail.compose' ]), login_hint=self.from_address) refresh_token = self.consumer.get_request_token( TOKEN_URL, 'authorization_code', code=raw_input( 'Please enter the code provided by the website: '), redirect_uri='urn:ietf:wg:oauth:2.0:oob') self._write_to_file('google', refresh_token) self.access_token = self.consumer.get_access_token( TOKEN_URL, refresh_token) def send_message(self, message, to_address): msg = MIMEText(self.header + message + self.footer) msg['To'] = to_address msg['From'] = self.from_address raw = base64.urlsafe_b64encode(msg.as_string()) return self.consumer.api_request_post(SEND_URL, self.access_token, raw=raw)
def __init__(self, api_key: str, api_secret: str, token_key: str, token_secret: str, base_url: str = "https://www.plurk.com"): consumer = Consumer(api_key, api_secret) # type:Consumer token = Token(token_key, token_secret) # type:Token self.client = Client(consumer, token) # type:Client self.base_url = base_url # type:str
def __init__(self, ckey, csec, ukey, usec, use_cache=True): self.client = Client(Consumer(ckey, csec), Token(ukey, usec)) self.client.to_url = self._override_tourl try: f = open(self.fnCache, 'rb') except IOError: print("no cache file") self._write_Cache() else: self.objCache = pickle.load(f)
class Imgur(Source): def __init__(self, data_file, client_id, client_secret): Source.__init__(self, data_file) self.consumer = Consumer(client_id, client_secret) self.access_token = None def setUp(self): try: refresh_token = self._read_from_file('imgur') except (IOError, ValueError, KeyError): refresh_token = None if not refresh_token: print self.consumer.authorize(AUTH_URL, 'pin') refresh_token = self.consumer.get_request_token( TOKEN_URL, 'pin', pin=raw_input('Please enter the pin: ')) self._write_to_file('imgur', refresh_token) self.access_token = self.consumer.get_access_token( TOKEN_URL, refresh_token) def get_message(self, album_name): albums = self.consumer.api_request_get(ALBUMS_URL, self.access_token)['data'] album_id = None for album in albums: if album['title'] == album_name: album_id = album['id'] images = self.consumer.api_request_get( ALBUM_URL + album_id, self.access_token)['data']['images'] links = [image['link'] for image in images] return random.sample(links, 1)[0]
def doSetup(self): print 'Running twitter setup...' consumer = Consumer(self.consumer_key, self.consumer_secret) print consumer client = Client(consumer) resp, content = client.request(TWITTER_REQUEST_TOKEN_URL, "GET") if resp['status'] != '200': raise Exception("Invalid response %s." % resp['status']) self.request_token = dict(urlparse(content)) print "Request Token:" print " - oauth_token = %s" % self.request_token[ 'oauth_token'] print " - oauth_token_secret = %s" % self.request_token[ 'oauth_token_secret'] print # Step 2: Redirect to the provider. Since this is a CLI script we do not # redirect. In a web application you would redirect the user to the URL # below. print "Go to the following link in your browser:" print "%s?oauth_token=%s" % (TWITTER_AUTHORIZE_URL, self.request_token['oauth_token']) print # After the user has granted access to you, the consumer, the provider will # redirect you to whatever URL you have told them to redirect to. You can # usually define this in the oauth_callback argument as well. accepted = 'n' while accepted.lower() == 'n': accepted = raw_input('Have you authorized me? (y/n) ') oauth_verifier = raw_input('What is the PIN? ') # Step 3: Once the consumer has redirected the user back to the oauth_callback # URL you can request the access token the user has approved. You use the # request token to sign this request. After this is done you throw away the # request token and use the access token returned. You should store this # access token somewhere safe, like a database, for future use. token = Token(self.request_token['oauth_token'], self.request_token['oauth_token_secret']) token.set_verifier(oauth_verifier) client = Client(consumer, token) resp, content = client.request(TWITTER_ACCESS_TOKEN_URL, "POST") self.access_token = dict(urlparse(content)) print "Access Token:" print " - oauth_token = %s" % self.access_token['oauth_token'] print " - oauth_token_secret = %s" % self.access_token[ 'oauth_token_secret'] print print "You may now access protected resources using the access tokens above."
def _get_auth_headers(self, method, url): oauth_params = { 'oauth_version': "1.0", 'oauth_nonce': generate_nonce(), 'oauth_timestamp': int(time.time()) } oauth_request = OAuthRequest(method, url, parameters=oauth_params) consumer = Consumer(self.client, self.oauth_secret) oauth_request.sign_request(SignatureMethod_HMAC_SHA1(), consumer, None) auth_headers = oauth_request.to_header() auth_headers['Authorization'] = auth_headers['Authorization'].encode( 'utf-8') return auth_headers
def __init__(self, customer_key=None, customer_secret=None): self.base_url = 'https://www.plurk.com' self.request_token_url = '/OAuth/request_token' self.authorization_url = '/OAuth/authorize' self.access_token_url = '/OAuth/access_token' self.customer_key = customer_key self.customer_secret = customer_secret self.sign_method = SignatureMethod_HMAC_SHA1() self.consumer = None self.token = None self.oauth_token = {} if self.customer_key and self.customer_secret: self.consumer = Consumer(self.customer_key, self.customer_secret)
def __init__(self, consumer_key, consumer_secret, token_key, token_secret): consumer = Consumer(key=consumer_key, secret=consumer_secret) token = Token(key=token_key, secret=token_secret) proxy_info = None if hasattr(settings, 'PROXY_HOST') and \ hasattr(settings, 'PROXY_PORT'): proxy_info = ProxyInfo(proxy_type=PROXY_TYPE_HTTP, proxy_host=settings.PROXY_HOST, proxy_port=settings.PROXY_PORT) self.client = Client(consumer=consumer, token=token, proxy_info=proxy_info)
def SendMsg(self, update): token = Token(key=self.access_key, secret=self.access_secret) consumer = Consumer(key=self.consumer_key, secret=self.consumer_secret) client = Client(consumer, token) request_uri = 'https://api.twitter.com/1/statuses/update.json' data = { u'status': unicodedata.normalize('NFKD', update[:140]).encode('ASCII', 'ignore') } resp = client.request(request_uri, 'POST', urllib.urlencode(data))[0] print resp.content print resp.status
def oauth_request(self, url, key, secret, http_method="GET", http_headers=None): consumer = Consumer(key=self.consumer_key, secret=self.consumer_secret) token = Token(key=key, secret=secret) client = Client(consumer, token) resp, content = client.request(url, method=http_method, headers=http_headers) return content
def invoke(self, controller, selection): target = selection[0] consumer = Consumer(target.app_id, target.app_secret) def request(client, *args, **kwargs): response, body = client.request(*args, **kwargs) if response["status"] != "200": raise TwitterAPIError(body) return body try: oauth_token = cherrypy.request.params.get("oauth_token") oauth_verifier = cherrypy.request.params.get("oauth_verifier") oauth_secret_session_key = "twitter_auth.%s.oauth_secret" % self.id if not oauth_token or not oauth_verifier: # Obtain a request token client = Client(consumer) location = Location.get_current(relative=False) location.query_string["item_action"] = self.id callback = quote_plus(str(location)) body = request( client, "https://api.twitter.com/oauth/request_token" "?oauth_callback=" + callback, "GET") data = dict(parse_qsl(body)) session[oauth_secret_session_key] = data["oauth_token_secret"] # Redirect the user to the login form auth_url = ("https://api.twitter.com/oauth/authorize?" "oauth_token=%s" "&oauth_callback=%s" % (data["oauth_token"], callback)) raise cherrypy.HTTPRedirect(auth_url) else: token = Token(oauth_token, session[oauth_secret_session_key]) token.set_verifier(oauth_verifier) client = Client(consumer, token) body = request(client, 'https://api.twitter.com/oauth/access_token', "POST") data = dict(parse_qsl(body)) target.auth_token = data["oauth_token"] target.auth_secret = data["oauth_token_secret"] datastore.commit() except TwitterAPIError, ex: notify_user(translations(ex), category="error", transient=False)
def get_consumer_token(self): # Setup print("Prepare the CONSUMER Info") verified = 'n' while verified.lower() != 'y': key = input('Input the CONSUMER_KEY: ') secret = input('Input the CONSUMER_SECRET: ') print('Consumer Key: %s' % str(key)) print('Consumer Secret: %s' % str(secret)) verified = input('Are you sure? (y/N) ') self.customer_key = key self.customer_secret = secret self.consumer = Consumer(self.customer_key, self.customer_secret)
def verifySignature(self, secret): """See L{IOAuthCredentials#verifySignature}.""" consumer = Consumer(key=self.consumerKey, secret=secret) oauthRequest = Request.from_request(self.method, self.url, headers=self.headers, query_string=self.arguments) # verify the request has been oauth authorized, we only support # HMAC-SHA1, reject OAuth signatures if they use a different method if self.signatureMethod != 'HMAC-SHA1': raise NotImplementedError('Unknown signature method: %s' % self.signatureMethod) signatureMethod = SignatureMethod_HMAC_SHA1() result = signatureMethod.check(oauthRequest, consumer, None, self.signature) return result
def get(self, ckey, csec): """ oauthを行う。 tokenを要求した後、PINの入力を受付け、 その結果、token情報を返す """ """ リプライをパースするλ式 oauth_token=IE&oauth_token_secret=0x&oauth_callback_confirmed=true' を {'oauth_token_secret': '0x', 'oauth_token': 'IEb', 'oauth_callback_confirmed': 'true'} のようにする """ parseparam = lambda x: dict(map(lambda y: y.split('='), x.split("&"))) # 設定ファイルに情報があるならそこからもらい返す ukey, usec = self.getfromcfg() if ukey != "" and usec != "": return ((ukey, usec)) # oauth用のクラス定義 client = Client(Consumer(ckey, csec), None) # トークンの要求 liRes = client.request(self.urlReqToken, 'GET') diRes = parseparam(liRes[1]) # 得たトークンを基にPINの要求を行う request_token = Token(diRes["oauth_token"], diRes["oauth_token_secret"]) print("plz access: " + self.urlReqPin + request_token.key) stPin = raw_input('PIN:') request_token.set_verifier(stPin) # 実際のキーをもらう client.token = request_token liRes = client.request(self.urlReqKey, 'POST') # 情報をパースする diRes = parseparam(liRes[1]) ukey = diRes["oauth_token"] usec = diRes["oauth_token_secret"] # 設定ファイルに書き込む self.setcfg(ukey, usec) return ((ukey, usec, diRes["user_id"], diRes["screen_name"]))
def auth(callback_url): # setup client = SimpleClient(SERVER, REQUEST_TOKEN_URL, ACCESS_TOKEN_URL) consumer = Consumer(CONSUMER_KEY, CONSUMER_SECRET) # get request token oauth_request = Request.from_consumer_and_token( consumer, http_method="POST", http_url=client.request_token_url, parameters={'oauth_callback': callback_url}) oauth_request.sign_request(SignatureMethod_HMAC_SHA1(), consumer, None) token = client.fetch_request_token(oauth_request) cache.set('app.root.view.post::oauth_token', token.key, 300) cache.set('app.root.view.post::oauth_token_secret', token.secret, 300) oauth_request = Request.from_token_and_callback(token=token, http_url=AUTHORIZATION_URL) return oauth_request.to_url()
def get_access_token(self, callback): path = self.get_oauth_path('get_access_token') url = self.get_url(path) consumer = Consumer(self.consumer.key, self.consumer.secret) request_token = self.get_request_token(callback) response = self.authorize_request_token(request_token.key) params = dict(parse_qsl(response['Location'][len(callback)+1:])) request_token.set_verifier(params['oauth_verifier']) request = Request.from_consumer_and_token(consumer, request_token, 'POST', url) request.sign_request(self.signature_method, consumer, request_token) response = self.client.post(path, request) self.assertEquals(response.status_code, 200) params = dict(parse_qsl(response.content)) return Token(params['oauth_token'], params['oauth_token_secret'])
def make_request(self, url, method="GET", body="", headers=None): """Makes a request to the TradeKing API.""" consumer = Consumer(key=TRADEKING_CONSUMER_KEY, secret=TRADEKING_CONSUMER_SECRET) token = Token(key=TRADEKING_ACCESS_TOKEN, secret=TRADEKING_ACCESS_TOKEN_SECRET) client = Client(consumer, token) self.logs.debug("TradeKing request: %s %s %s %s" % (url, method, body, headers)) response, content = client.request(url, method=method, body=body, headers=headers) self.logs.debug("TradeKing response: %s %s" % (response, content)) try: return loads(content) except ValueError: self.logs.error("Failed to decode JSON response: %s" % content) return None
def fetch(self, username): from droplet.stream.models import Location try: return self.get(username=username) except self.model.DoesNotExist: pass client = Client( Consumer(key=settings.TWITTER_CONSUMER_KEY, secret=settings.TWITTER_CONSUMER_SECRET), Token(key=settings.TWITTER_ACCESS_KEY, secret=settings.TWITTER_ACCESS_SECRET)) response, content = client.request( USER_URL + '?' + urlencode({'screen_name': username})) if response.status != 200: return try: content = simplejson.loads(content) except: return url = content.get('url') if url: try: url = urlopen(url).url except: pass return self.create(username=content.get('screen_name'), display_name=content.get('name'), description=content.get('description'), image=content.get('profile_image_url'), location=Location.objects.fetch( content.get('location')), url=url)
def publish(self, publishable): if self.auth_token is None: raise ValueError( "Can't publish %s to %s: authorization token missing" % (publishable, self)) if self.auth_secret is None: raise ValueError( "Can't publish %s to %s: authorization secret missing" % (publishable, self)) consumer = Consumer(self.app_id, self.app_secret) token = Token(self.auth_token, self.auth_secret) client = Client(consumer, token) status = self.get_status(publishable) response, body = client.request( "https://api.twitter.com/1/statuses/update.json", "POST", urlencode({"status": status.encode("utf-8")})) if response["status"] != "200": raise TwitterAPIError(body)
def __init__(self, data_file, client_id, client_secret): Source.__init__(self, data_file) self.consumer = Consumer(client_id, client_secret) self.access_token = None
def __init__(self, consumer_key, consumer_secret): self.consumer = Consumer(consumer_key, consumer_secret)