def _start(self): self.cache = FileCache(path=self.cache_path) self.esi_app = EsiApp(cache=self.cache, cache_prefix=self.prefix) self.app = self.esi_app.get_latest_swagger self.security = EsiSecurity( app=self.app, redirect_uri='http://localhost/oauth-callback', # This doesnt matter headers={ 'User-Agent': 'Discord bot by Prozn: https://github.com/prozn/dankcord' }, client_id=self.client_id, secret_key=self.secret_key, ) self.esi = EsiClient( retry_requests= False, # set to retry on http 5xx error (default False) headers={ 'User-Agent': 'Discord bot by Prozn: https://github.com/prozn/dankcord' }, security=self.security) self.security.update_token({ 'access_token': '', # leave this empty 'expires_in': -1, # seconds until expiry, so we force refresh anyway 'refresh_token': self.refresh_token }) self.security.refresh()
def test_esisecurity_other_init(self): """ test security init without app and with urls """ with self.assertRaises(AttributeError): EsiSecurity( redirect_uri=TestEsiSecurity.CALLBACK_URI, client_id=TestEsiSecurity.CLIENT_ID, secret_key=TestEsiSecurity.SECRET_KEY, sso_url="" ) security = EsiSecurity( redirect_uri=TestEsiSecurity.CALLBACK_URI, client_id=TestEsiSecurity.CLIENT_ID, secret_key=TestEsiSecurity.SECRET_KEY, sso_url='foo.com', esi_url='bar.baz' ) self.assertEqual( security.oauth_verify, "bar.baz/verify/" ) self.assertEqual( security.oauth_token, "foo.com/oauth/token" ) self.assertEqual( security.oauth_authorize, "foo.com/oauth/authorize" )
def __init__(self, token_file): #Retrieve the tokens from the file with open(token_file, "rb") as fp: tokens_file = pickle.load(fp) fp.close() esi_app = EsiApp(cache=cache, cache_time=0, headers=headers) self.app = esi_app.get_latest_swagger self.security = EsiSecurity(redirect_uri=redirect_uri, client_id=client_id, secret_key=secret_key, headers=headers) self.client = EsiClient(retry_requests=True, headers=headers, security=self.security) self.security.update_token({ 'access_token': '', 'expires_in': -1, 'refresh_token': tokens_file['refresh_token'] }) tokens = self.security.refresh() api_info = self.security.verify() print("security: Authenticated for " + str(api_info['Scopes']))
def __init__(self, token, refresh=False): self.client_id = os.environ.get('EVE_SKILLS_CID') self.secret_id = os.environ.get('EVE_SKILLS_SECRET') self.redir_url = os.environ.get('EVE_SKILLS_REDIR') self.app = App.create( url= "https://esi.evetech.net/latest/swagger.json?datasource=tranquility" ) self.security = EsiSecurity( app=self.app, redirect_uri=self.redir_url, client_id=self.client_id, secret_key=self.secret_id, ) self.client = EsiClient( header={'User-Agent': 'EVE-SKILLS'}, raw_body_only= False, # parse json automatically, slow, bad performance security=self.security) self.token = None if not refresh: self.token = self.security.auth( token) # use code from login redirect if refresh: print('[I] refreshing token') self.security.update_token({ 'access_token': '', 'expires_in': -1, # force refresh anyway 'refresh_token': token }) self.token = self.security.refresh() print(self.token)
def test_esisecurity_init(self): with httmock.HTTMock(*_all_auth_mock_): with self.assertRaises(AttributeError): EsiSecurity(redirect_uri=TestEsiSecurity.CALLBACK_URI, client_id=TestEsiSecurity.CLIENT_ID, secret_key=TestEsiSecurity.SECRET_KEY, sso_endpoints_url="") with self.assertRaises(AttributeError): EsiSecurity(redirect_uri=TestEsiSecurity.CALLBACK_URI, client_id=TestEsiSecurity.CLIENT_ID) with open(TestEsiSecurity.RSC_JWKS, 'r') as jwks: jwks = json.load(jwks) EsiSecurity(redirect_uri=TestEsiSecurity.CALLBACK_URI, client_id=TestEsiSecurity.CLIENT_ID, secret_key=TestEsiSecurity.SECRET_KEY, jwks_key=jwks['keys'][0]) self.assertEqual(self.security.security_name, TestEsiSecurity.SECURITY_NAME) self.assertEqual(self.security.redirect_uri, TestEsiSecurity.CALLBACK_URI) self.assertEqual(self.security.client_id, TestEsiSecurity.CLIENT_ID) self.assertEqual(self.security.secret_key, TestEsiSecurity.SECRET_KEY) self.assertEqual(self.security.token_identifier, TestEsiSecurity.TOKEN_IDENTIFIER) self.assertEqual(self.security.oauth_issuer, self.sso_endpoints['issuer']) self.assertEqual(self.security.oauth_authorize, self.sso_endpoints['authorization_endpoint']) self.assertEqual(self.security.oauth_token, self.sso_endpoints['token_endpoint']) self.assertEqual(self.security.oauth_revoke, self.sso_endpoints['revocation_endpoint'])
def test_esisecurity_init_with_app(self): """ test security init with app and URL""" with self.assertRaises(NameError): EsiSecurity(app=self.app, redirect_uri=TestEsiSecurity.CALLBACK_URI, client_id=TestEsiSecurity.CLIENT_ID, secret_key=TestEsiSecurity.SECRET_KEY, security_name="security_name_that_does_not_exist") with self.assertRaises(AttributeError): EsiSecurity(app=self.app, redirect_uri=TestEsiSecurity.CALLBACK_URI, client_id=TestEsiSecurity.CLIENT_ID, secret_key=TestEsiSecurity.SECRET_KEY, esi_url="") self.assertEqual(self.security.security_name, TestEsiSecurity.SECURITY_NAME) self.assertEqual(self.security.redirect_uri, TestEsiSecurity.CALLBACK_URI) self.assertEqual(self.security.client_id, TestEsiSecurity.CLIENT_ID) self.assertEqual(self.security.secret_key, TestEsiSecurity.SECRET_KEY) self.assertEqual(self.security.oauth_verify, TestEsiSecurity.OAUTH_VERIFY) self.assertEqual(self.security.oauth_token, TestEsiSecurity.OAUTH_TOKEN) self.assertEqual(self.security.oauth_authorize, TestEsiSecurity.OAUTH_AUTHORIZE)
def initialize_esi_client(refresh_token=None): """ Retrieves a public or authorized ESI client. Args: auth_id (optional): refresh_token of the user whose client we want to retrieve. By default, a public ESI client is returned. Returns: esi_client (EsiClient): Client object from esipy. """ auth = EsiSecurity( headers={'User-Agent': client_name}, redirect_uri='https://localhost/callback', client_id=client_id, secret_key=secret_key, ) if refresh_token is not None: auth.refresh_token = refresh_token esi_client = EsiClient( auth, retry_requests=True, cache=DictCache(), headers={'User-Agent': client_name}, ) return esi_client
def setUp(self, urlopen_mock): # I hate those mock... thx urlopen instead of requests... urlopen_mock.return_value = open('test/resources/swagger.json') self.app = App.create('https://esi.tech.ccp.is/latest/swagger.json') self.security = EsiSecurity( app=self.app, redirect_uri=TestEsiSecurity.CALLBACK_URI, client_id=TestEsiSecurity.CLIENT_ID, secret_key=TestEsiSecurity.SECRET_KEY, )
def get_esi_security(token=None): """ EsiSecurity is used to refresh and manage EVE Token objects """ client = EveClient.get_instance() esi_security = EsiSecurity(redirect_uri=client.esi_callback_url, client_id=client.esi_client_id, secret_key=client.esi_secret_key, headers={'User-Agent': "Krypted Platform"}) if token: esi_security.update_token(token.populate()) return esi_security
def get_api(fn, scopes): esi_app = App.create( 'https://esi.tech.ccp.is/latest/swagger.json?datasource=tranquility') esi_security = EsiSecurity( app=esi_app, redirect_uri='http://localhost:8080/callback', client_id='0b9ac4978a9a4feba20a7eba4f666a46', secret_key='odtDKZWZbwbFnBHNXnOhRX50YrU49owBw1qE3v7p', ) esi_client = EsiClient(retry_requests=True, security=esi_security) def write_refresh_token(refresh_token, **kwargs): with open(fn, "w") as f: f.write(refresh_token) AFTER_TOKEN_REFRESH.add_receiver(write_refresh_token) if os.path.isfile(fn): with open(fn) as f: token = open(fn).read() esi_security.update_token({ 'access_token': '', 'expires_in': -1, 'refresh_token': token }) tokens = esi_security.refresh() else: print(esi_security.get_auth_uri(scopes=scopes)) tokens = esi_security.auth(input()) write_refresh_token(**tokens) api_info = esi_security.verify() return api_info, esi_app, esi_client
def ESIMail(self, KilledCharID): security = EsiSecurity( app=self.app, redirect_uri='http://localhost/callback/', client_id=GlobalConsts.CLIENTID, secret_key=GlobalConsts.SECRETKEY, ) print(security.get_auth_uri(scopes=GlobalConsts.REQUESTSCOPES)) try: tokens = security.auth(GlobalConsts.CHARAUTHTOKEN) except: security.refresh_token = GlobalConsts.CHARREFRESHTOKEN tokens = security.refresh() accessToken = tokens[GlobalConsts.TOKENAUTHKEY] RefreshToken = tokens[GlobalConsts.TOKENREFRESHKEY] expire_date = datetime.fromtimestamp( time.time() + tokens[GlobalConsts.TOKENEXPIRESKEY], ) api_info = security.verify() strCharacterID = api_info['CharacterID'] Response = SendMail(strCharacterID, KilledCharID, GlobalConsts.DEFAULTMESSAGE, accessToken) if Response.status_code == GlobalConsts.SUCCESSRESPONSECODE: print("Sent message to characterid {0}".format(KilledCharID)) else: print("Failed to send message to characterid {0}".format( KilledCharID))
def setUp(self): warnings.simplefilter('ignore') self.custom_refresh_token_signal = Signal() with httmock.HTTMock(*_all_auth_mock_): self.security = EsiSecurity( redirect_uri=TestEsiSecurity.CALLBACK_URI, client_id=TestEsiSecurity.CLIENT_ID, secret_key=TestEsiSecurity.SECRET_KEY, signal_token_updated=self.custom_refresh_token_signal, token_identifier=TestEsiSecurity.TOKEN_IDENTIFIER) self.security_pkce = EsiSecurity( redirect_uri=TestEsiSecurity.CALLBACK_URI, client_id=TestEsiSecurity.CLIENT_ID, code_verifier=TestEsiSecurity.CODE_VERIFIER, ) with open(TestEsiSecurity.RSC_SSO_ENDPOINTS, 'r') as sso_endpoints: self.sso_endpoints = json.load(sso_endpoints)
def setUp(self, urlopen_mock): # I hate those mock... thx urlopen instead of requests... urlopen_mock.return_value = open('test/resources/swagger.json') warnings.simplefilter('ignore') self.app = App.create( 'https://esi.evetech.net/latest/swagger.json' ) self.security = EsiSecurity( app=self.app, redirect_uri=TestEsiPy.CALLBACK_URI, client_id=TestEsiPy.CLIENT_ID, secret_key=TestEsiPy.SECRET_KEY, ) self.cache = DictCache() self.client = EsiClient(self.security, cache=self.cache) self.client_no_auth = EsiClient(cache=self.cache, retry_requests=True)
def repeated_verify(security: EsiSecurity, count: int = 0, max_count: int = 5) -> Dict: """ Calls verify up to max times or untill there is no error """ try: return security.verify() except APIException as e: if 'SSO JSON failure' in e.response.decode('utf-8'): logger.error('SSO JSON Failure, trying workaround...') resp = security.refresh() security.signal_token_updated.send( token_identifier=security.token_identifier, **resp) if count >= max_count: logger.exception('Failed to verify because of repeated errors', exc_info=True) raise e else: return repeated_verify(security, count + 1, max_count)
def setUp(self, urlopen_mock): # I hate those mock... thx urlopen instead of requests... urlopen_mock.return_value = open('test/resources/swagger.json') warnings.simplefilter('ignore') self.app = App.create('https://esi.evetech.net/latest/swagger.json') with open(TestEsiPy.RSC_SSO_ENDPOINTS, 'r') as sso_endpoints: with open(TestEsiPy.RSC_JWKS, "r") as jwks: self.security = EsiSecurity( app=self.app, redirect_uri=TestEsiPy.CALLBACK_URI, client_id=TestEsiPy.CLIENT_ID, secret_key=TestEsiPy.SECRET_KEY, sso_endpoints=json.load(sso_endpoints), jwks_key=json.load(jwks)) self.cache = DictCache() self.client = EsiClient(self.security, cache=self.cache) self.client_no_auth = EsiClient(cache=self.cache, retry_requests=True)
def do_security(tokens_file, scopes): esi_app = EsiApp(cache=cache, cache_time=0) app = esi_app.get_latest_swagger security = EsiSecurity(redirect_uri=redirect_uri, client_id=client_id, secret_key=secret_key, headers=headers) client = EsiClient(retry_requests=True, headers=headers, security=security) print("Open link in browser and authorize") print(security.get_auth_uri(scopes=scopes)) code = input("Enter in code:\n") tokens = security.auth(code) print(tokens) print("\n Writing tokens to " + str(tokens_file)) with open(tokens_file, 'wb') as fp: pickle.dump(tokens, fp) fp.close()
def authenticate(): app = App.create( url="https://esi.tech.ccp.is/latest/swagger.json?datasource=tranquility" ) security = EsiSecurity( app=app, redirect_uri='http://localhost:51350', client_id=secret['client_id'], secret_key=secret['secret_key'], ) client = EsiClient(retry_requests=True, header={'User-Agent': 'shipLocation'}, security=security) eve_sso_auth_url = security.get_auth_uri( scopes=['esi-location.read_ship_type.v1']) webbrowser.open(eve_sso_auth_url, new=2) # open in a new browser tab auth_code = fetch_auth_code( ) # fetch authentication code using a temporary web server tokens = security.auth(auth_code) return (app, client, security, tokens)
def test_esisecurity_verify(self): # this is just for coverage purpose. This doesn't work without valid # jwt token with self.assertRaises(AttributeError): self.security.verify() self.security.update_token({ 'access_token': 'access_token', 'refresh_token': 'refresh_token', 'expires_in': 60 }) with self.assertRaises(JWTError): self.security.verify() with httmock.HTTMock(*_all_auth_mock_): with open(TestEsiSecurity.RSC_JWKS, 'r') as jwks: jwks = json.load(jwks) security_nojwks = EsiSecurity( redirect_uri=TestEsiSecurity.CALLBACK_URI, client_id=TestEsiSecurity.CLIENT_ID, secret_key=TestEsiSecurity.SECRET_KEY, jwks_key=jwks['keys'][0]) security_nojwks.update_token({ 'access_token': 'access_token', 'refresh_token': 'refresh_token', 'expires_in': 60 }) with self.assertRaises(JWTError): security_nojwks.verify()
def __init__(self): self.db = Database() self.config = Config() self.scopes = self.config.getConfig()["settings"]["esiScopes"] self.esi_app = App.create( url=self.config.getConfig()["settings"]["esiURL"], ) self.security = EsiSecurity( app=self.esi_app, redirect_uri=self.config.getConfig()["settings"]["esiCallback"], client_id=self.config.getConfig()["settings"]["esiClientID"], secret_key=self.config.getConfig()["settings"]["esiSecretKey"], headers={ 'User-Agent': self.config.getConfig()["settings"]["esiCustomHeader"] }) self.client = EsiClient( security=self.security, retry_requests=True, headers={ 'User-Agent': self.config.getConfig()["settings"]["esiCustomHeader"] })
def setup_esi(app_id, app_secret, refresh_token, cache=DictCache()): """Set up the ESI client Args: app_id (string): SSO Application ID from CCP app_secret (string): SSO Application Secret from CCP refresh_token (string): SSO refresh token cache (False, optional): esipy.cache instance Returns: tuple: esi app definition, esi client >>> setup_esi(CONFIG['SSO_APP_ID'], CONFIG['SSO_APP_KEY'], ... CONFIG['SSO_REFRESH_TOKEN'], cache) # doctest: +ELLIPSIS (<pyswagger.core.App object ...>, <esipy.client.EsiClient object ...>) """ esi_meta = EsiApp(cache=cache) esi = esi_meta.get_latest_swagger esi_security = EsiSecurity( redirect_uri='http://localhost', client_id=app_id, secret_key=app_secret, headers={'User-Agent': 'https://github.com/eve-n0rman/structurebot'}) esi_security.update_token({ 'access_token': '', 'expires_in': -1, 'refresh_token': refresh_token }) esi_client = EsiClient( retry_requests=True, headers={'User-Agent': 'https://github.com/eve-n0rman/structurebot'}, raw_body_only=False, security=esi_security, cache=cache) return (esi, esi_client, esi_security)
def init_esi(): esi_app = App.create( 'https://esi.tech.ccp.is/latest/swagger.json?datasource=tranquility') esi_security = EsiSecurity( app=esi_app, redirect_uri='https://www.msully.net/stuff/get-token', client_id='fca36d677f9a4b8e8581d8cd2c738c2c', # 'The "Secret Key" should never be human-readable in your application.' secret_key=codecs.decode('AIUr5ntWiEIXiavPjKtUCiNFwlvTBlJqmElgAk4x', 'rot_13'), ) esi_client = EsiClient(esi_security) return ESI(esi_app, esi_security, esi_client)
def who_am_i(token: SSOToken) -> Dict: signal = Signal() signal.add_receiver(token_argument_update_cb) security: EsiSecurity = EsiSecurity( '', config.crest_client_id, config.crest_client_secret, headers={'User-Agent': config.user_agent}, signal_token_updated=signal, token_identifier=token.tokenID) security.update_token(token.info_for_esi_security()) return repeated_verify(security)
def save(self, *args, **kwargs): if EveClient.objects.all(): EveClient.objects.all()[0].delete() self.esi_sso_url = EsiSecurity( client_id=self.esi_client_id, redirect_uri=self.esi_callback_url, secret_key=self.esi_secret_key, headers={ 'User-Agent': "Krypted Platform" }).get_auth_uri(scopes=EveScope.get_formatted_scopes(), state=self.esi_client_id) super(EveClient, self).save(*args, **kwargs)
def authorize(code: str) -> Dict: """ Get SSO tokens using an SSO auth code. :param code: SSO auth code for getting the tokens :returns a Dict containing 'access_token', 'refresh_token', 'expires_in' """ security: EsiSecurity = EsiSecurity( '', config.crest_client_id, config.crest_client_secret, headers={'User-Agent': config.user_agent}) return security.auth(code)
import logging from flask import Flask, render_template, request, flash, redirect, url_for from esipy import App, EsiClient, EsiSecurity from lib import CharacterExplorer, all_esi_read_scopes app = Flask(__name__) app.config.from_json('config.json') esi_headers = {'User-Agent': 'EVE Character Explorer | [email protected]'} esi_app = App.create( 'https://esi.tech.ccp.is/latest/swagger.json?datasource=tranquility') esi_security = EsiSecurity(app=esi_app, client_id=app.config['CLIENT_ID'], secret_key=app.config['SECRET_KEY'], redirect_uri=app.config['REDIRECT_URI'], headers=esi_headers) esi_client = EsiClient(security=esi_security, headers=esi_headers) @app.route('/') def index(): return render_template( 'index.html', sso_go=esi_security.get_auth_uri(scopes=all_esi_read_scopes)) @app.route('/view', methods=['POST']) def view(): token = request.form.get('refresh_token')
import json from esipy import App from esipy import EsiClient from esipy import EsiSecurity app = App.create(url="https://esi.tech.ccp.is/latest/swagger.json?datasource=tranquility") # replace the redirect_uri, client_id and secret_key values # with the values you get from the STEP 1 ! security = EsiSecurity( app=app, redirect_uri='your uri', client_id='your id', secret_key='your key', ) # and the client object, replace the header user agent value with something reliable ! client = EsiClient( retry_requests=True, headers={'User-Agent': 'your app name'}, security=security ) # import scope # with open ('scopes', 'rb') as fp: # scopeslist = pickle.load(fp) sscp = app.root._Swagger__securityDefinitions['evesso']._SecurityScheme__scopes
def invalidate(self, key): cache.delete(_hash(key)) lbcache = LbCache() transport_adapter = HTTPAdapter( pool_connections=20, pool_maxsize=300, ) # ESI objects to be imported esiapp = EsiApp(cache=lbcache, cache_time=0, datasource=config.ESI_DATASOURCE) esisecurity = EsiSecurity( app=esiapp.get_latest_swagger, redirect_uri="%s%s" % ( config.ESI_REDIRECT_DOMAIN, '/sso/callback', ), client_id=config.ESI_CLIENT_ID, secret_key=config.ESI_SECRET_KEY, ) esiclient = EsiClient(security=esisecurity, transport_adapter=transport_adapter, cache=lbcache, headers={'User-Agent': config.ESI_USER_AGENT}) # register observers AFTER_TOKEN_REFRESH.add_receiver(token_update_observer)
app = Flask(__name__) if __name__ == '__main__': config = {} execfile("config.conf",config) serverIP = config['serverIP'] serverPort = config['serverPort'] debug = config['debug'] app.secret_key = config['appKey'] esi_app = App.create('https://esi.tech.ccp.is/latest/swagger.json?datasource=tranquility') security = EsiSecurity( app=esi_app, redirect_uri=config['callbackURL'], client_id=config['clientID'], secret_key=config['secretKey'] ) client = EsiClient(security=security) scopes = ['esi-location.read_location.v1'] #Example route to show how to grab data from ESI @app.route('/getLocation') def location(): if 'char' in session: security.update_token(session['token']) security.refresh() verif = security.verify() charID = verif.get('CharacterID') charLocation = esi_app.op['get_characters_character_id_location'](character_id=charID)
@login_manager.user_loader def load_user(character_id): """ Required user loader for Flask-Login """ return User.query.get(character_id) # ----------------------------------------------------------------------- # ESIPY Init # ----------------------------------------------------------------------- # create the app esiapp = App.create(config.ESI_SWAGGER_JSON) # init the security object esisecurity = EsiSecurity( app=esiapp, redirect_uri=config.ESI_CALLBACK, client_id=config.ESI_CLIENT_ID, secret_key=config.ESI_SECRET_KEY, ) # init the client esiclient = EsiClient(security=esisecurity, cache=None, headers={'User-Agent': config.ESI_USER_AGENT}) # ----------------------------------------------------------------------- # Login / Logout Routes # ----------------------------------------------------------------------- def generate_token(): """Generates a non-guessable OAuth token""" chars = ('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789')
from esipy import App, EsiClient, EsiSecurity from esipy.exceptions import APIException from .settings import ESI_URL, ESI_CONNECT_IMG_BAR, ESI_CLIENT_ID, ESI_SECRET_KEY, ESI_CALLBACK_URL, ESI_SCOPES esi_app = App.create(ESI_URL) esi_security = EsiSecurity(app=esi_app, redirect_uri=ESI_CALLBACK_URL, client_id=ESI_CLIENT_ID, secret_key=ESI_SECRET_KEY) esi_client = EsiClient(security=esi_security) esi_scopes = ESI_SCOPES esi_secure = esi_security.get_auth_uri(scopes=esi_scopes) esi_secure_url = "<a href='" + esi_secure + "'><img src='" + ESI_CONNECT_IMG_BAR + "'></a>" def esi_update_token(request): esi_security.update_token(request.session['token']) def esi_refresh_verify(request): esi_security.update_token(request.session['token']) esi_security.refresh() return esi_security.verify() def esi_verify(): return esi_security.verify()
from esipy import App from esipy import EsiClient from esipy import EsiSecurity from flask import Flask, request CLIENT_ID = '' SECRET_KEY = '' SCOPES = ['esi-universe.read_structures.v1', 'esi-markets.structure_markets.v1'] app = Flask(__name__) esi_app = App.create(url="https://esi.tech.ccp.is/latest/swagger.json?datasource=tranquility") security = EsiSecurity( app=esi_app, redirect_uri='http://127.0.0.1:5000/ESICallback', client_id=CLIENT_ID, secret_key=SECRET_KEY ) client = EsiClient( retry_requests=True, header={'User-Agent': 'ESI Token Fetcher'}, security=security ) webbrowser.open_new(security.get_auth_uri(scopes=SCOPES)) @app.route('/ESICallback') def esi_callback(): code = request.args.get('code', '')