Merge in (and fix) KeyPhact's U6 implementation

.gitignore

@@ -89,4 +89,8 @@ ENV/
 .ropeproject
 
 # Personal load details
-config.json
+config.json
+
+# Encrpytion libs
+encrypt.dll
+libencrypt.so

config.json.example

@@ -2,5 +2,6 @@
     "auth_service": "google",
     "username": "example@gmail.com",
     "password": "password11!!",
-    "location": "New York"
+    "location": "New York",
+    "encrypt": "./libencrypt.so"
 }

pgoapi/__init__.py

@@ -31,7 +31,7 @@
 import logging
 
 __title__ = 'pgoapi'
-__version__ = '1.1.6'
+__version__ = '1.1.7'
 __author__ = 'tjado'
 __license__ = 'MIT License'
 __copyright__ = 'Copyright (c) 2016 tjado <https://github.com/tejado>'

pgoapi/auth.py

@@ -26,7 +26,7 @@
 from __future__ import absolute_import
 
 import logging
-from pgoapi.utilities import get_time_ms, get_format_time_diff
+from pgoapi.utilities import get_time, get_format_time_diff
 
 class Auth:
 
@@ -36,8 +36,21 @@ def __init__(self):
         self._auth_provider = None
 
         self._login = False
+
+        """ 
+        oauth2 uses refresh tokens (which basically never expires) 
+        to get an access_token which is only valid for a certain time)
+        """
+        self._refresh_token = None
+        self._access_token = None
+        self._access_token_expiry = 0
+        # TODO: can be removed
         self._auth_token = None
 
+        """ 
+        Pokemon Go uses internal tickets, like an internal 
+        session to keep a user logged in over a certain time (30 minutes)
+        """
         self._ticket_expire = None
         self._ticket_start = None
         self._ticket_end = None
@@ -49,7 +62,7 @@ def is_login(self):
         return self._login
 
     def get_token(self):
-        return self._auth_token
+        return self._access_token
 
     def has_ticket(self):
         if self._ticket_expire and self._ticket_start and self._ticket_end:
@@ -68,13 +81,13 @@ def is_new_ticket(self, new_ticket_time_ms):
 
     def check_ticket(self):
         if self.has_ticket():
-            now_ms = get_time_ms()
+            now_ms = get_time(ms = True)
             if now_ms < (self._ticket_expire - 10000):
                 h, m, s = get_format_time_diff(now_ms, self._ticket_expire, True)
-                self.log.debug('Auth ticket still valid for further %02d:%02d:%02d hours (%s < %s)', h, m, s, now_ms, self._ticket_expire)
+                self.log.debug('Session Ticket still valid for further %02d:%02d:%02d hours (%s < %s)', h, m, s, now_ms, self._ticket_expire)
                 return True
             else:
-                self.log.debug('Removed expired auth ticket (%s < %s)', now_ms, self._ticket_expire)
+                self.log.debug('Removed expired Session Ticket (%s < %s)', now_ms, self._ticket_expire)
                 self._ticket_expire, self._ticket_start, self._ticket_end = (None, None, None)
                 return False
         else:
@@ -86,5 +99,34 @@ def get_ticket(self):
         else:
             return False
 
-    def login(self, username, password):
-        raise NotImplementedError()
+    def user_login(self, username, password):
+        raise NotImplementedError()
+
+    def set_refresh_token(self, username, password):
+        raise NotImplementedError()
+
+    def get_access_token(self, force_refresh = False):
+        raise NotImplementedError()
+
+
+    def check_access_token(self):
+        """
+        Add few seconds to now so the token get refreshed 
+        before it invalidates in the middle of the request
+        """
+        now_s = get_time() + 120
+
+        if self._access_token is not None:
+            if self._access_token_expiry == 0:
+                self.log.debug('No Access Token Expiry found - assuming it is still valid!')
+                return True
+            elif self._access_token_expiry > now_s:
+                h, m, s = get_format_time_diff(now_s, self._access_token_expiry, False)
+                self.log.debug('Access Token still valid for further %02d:%02d:%02d hours (%s < %s)', h, m, s, now_s, self._access_token_expiry)
+                return True
+            else:
+                self.log.info('Access Token expired!')
+                return False
+        else:
+            self.log.debug('No Access Token available!')
+            return False

pgoapi/auth_google.py

@@ -25,9 +25,11 @@
 
 from __future__ import absolute_import
 
+import six
 import logging
 
 from pgoapi.auth import Auth
+from pgoapi.exceptions import AuthException
 from gpsoauth import perform_master_login, perform_oauth
 
 class AuthGoogle(Auth):
@@ -39,24 +41,58 @@ class AuthGoogle(Auth):
 
     def __init__(self):
         Auth.__init__(self)
-        
+
         self._auth_provider = 'google'
 
-    def login(self, username, password):
-        self.log.info('Google login for: {}'.format(username))
-        login = perform_master_login(username, password, self.GOOGLE_LOGIN_ANDROID_ID)
-        login = perform_oauth(username, login.get('Token', ''), self.GOOGLE_LOGIN_ANDROID_ID, self.GOOGLE_LOGIN_SERVICE, self.GOOGLE_LOGIN_APP,
-            self.GOOGLE_LOGIN_CLIENT_SIG)
-
-        self._auth_token = login.get('Auth')
-
-        if self._auth_token is None:
-            self.log.info('Google Login failed.')
-            return False
-
-        self._login = True
-
-        self.log.info('Google Login successful.')
-        self.log.debug('Google Session Token: %s', self._auth_token[:25])
-
-        return True
+        self._refresh_token = None
+
+    def user_login(self, username, password):
+        self.log.info('Google User Login for: {}'.format(username))
+
+        if not isinstance(username, six.string_types) or not isinstance(password, six.string_types):
+            raise AuthException("Username/password not correctly specified")
+
+        user_login = perform_master_login(username, password, self.GOOGLE_LOGIN_ANDROID_ID)
+
+        refresh_token = user_login.get('Token', None)
+        if refresh_token is not None:
+            self._refresh_token = refresh_token
+            self.log.info('Google User Login successful.')
+        else:
+            self._refresh_token = None
+            raise AuthException("Invalid Google Username/password")
+
+        self.get_access_token()
+
+    def set_refresh_token(self, refresh_token):
+        self.log.info('Google Refresh Token provided by user')
+        self._refresh_token = refresh_token
+
+    def get_access_token(self, force_refresh = False):
+        token_validity = self.check_access_token()
+
+        if token_validity is True and force_refresh is False:
+            self.log.debug('Using cached Google Access Token')
+            return self._access_token
+        else:
+            if force_refresh:
+                self.log.info('Forced request of Google Access Token!')
+            else:
+                self.log.info('Request Google Access Token...')
+
+            token_data = perform_oauth(None, self._refresh_token, self.GOOGLE_LOGIN_ANDROID_ID, self.GOOGLE_LOGIN_SERVICE, self.GOOGLE_LOGIN_APP,
+                self.GOOGLE_LOGIN_CLIENT_SIG)
+
+            access_token = token_data.get('Auth', None)
+            if access_token is not None:
+                self._access_token = access_token
+                self._access_token_expiry = int(token_data.get('Expiry', 0))
+                self._login = True
+
+                self.log.info('Google Access Token successfully received.')
+                self.log.debug('Google Access Token: %s...', self._access_token[:25])
+                return self._access_token
+            else:
+                self._access_token = None
+                self._login = False
+                raise AuthException("Could not receive a Google Access Token")

pgoapi/auth_ptc.py

@@ -24,13 +24,20 @@
 """
 
 from __future__ import absolute_import
+from future.standard_library import install_aliases
+install_aliases()
 
 import re
+import six
 import json
 import logging
 import requests
 
+from urllib.parse import parse_qs
+
 from pgoapi.auth import Auth
+from pgoapi.utilities import get_time
+from pgoapi.exceptions import AuthException
 
 class AuthPtc(Auth):
 
@@ -46,9 +53,11 @@ def __init__(self):
         self._session = requests.session()
         self._session.verify = True
 
-    def login(self, username, password):
+    def user_login(self, username, password):
+        self.log.info('PTC User Login for: {}'.format(username))
 
-        self.log.info('Login for: %s', username)
+        if not isinstance(username, six.string_types) or not isinstance(password, six.string_types):
+            raise AuthException("Username/password not correctly specified")
 
         head = {'User-Agent': 'niantic'}
         r = self._session.get(self.PTC_LOGIN_URL, headers=head)
@@ -63,11 +72,12 @@ def login(self, username, password):
                 'password': password,
             }
         except ValueError as e:
-            self.log.error('Field missing in response: %s' % e)
+            self.log.error('PTC User Login Error - Field missing in response: %s', e)
             return False
         except KeyError as e:
-            self.log.error('Field missing in response.content: %s' % e)
+            self.log.error('PTC User Login Error - Field missing in response.content: %s', e)
             return False
+
         r1 = self._session.post(self.PTC_LOGIN_URL, data=data, headers=head)
 
         ticket = None
@@ -77,30 +87,62 @@ def login(self, username, password):
             try:
                 self.log.error('Could not retrieve token: %s', r1.json()['errors'][0])
             except Exception as e:
-                self.log.error('Could not retrieve token! (%s)', str(e))
+                self.log.error('Could not retrieve token! (%s)', e)
             return False
 
-        data1 = {
-            'client_id': 'mobile-app_pokemon-go',
-            'redirect_uri': 'https://www.nianticlabs.com/pokemongo/error',
-            'client_secret': self.PTC_LOGIN_CLIENT_SECRET,
-            'grant_type': 'refresh_token',
-            'code': ticket,
-        }
-
-        r2 = self._session.post(self.PTC_LOGIN_OAUTH, data=data1)
-        access_token = re.sub('&expires.*', '', r2.content.decode('utf-8'))
-        access_token = re.sub('.*access_token=', '', access_token)
-
-        if '-sso.pokemon.com' in access_token:
-            self.log.info('PTC Login successful')
-            self.log.debug('PTC Session Token: %s', access_token[:25])
-            self._auth_token = access_token
+        self._refresh_token = ticket
+        self.log.info('PTC User Login successful.')
+
+        self.get_access_token()
+
+    def set_refresh_token(self, refresh_token):
+        self.log.info('PTC Refresh Token provided by user')
+        self._refresh_token = refresh_token
+
+    def get_access_token(self, force_refresh = False):
+        token_validity = self.check_access_token()
+
+        if token_validity is True and force_refresh is False:
+            self.log.debug('Using cached PTC Access Token')
+            return self._access_token
         else:
-            self.log.info('Seems not to be a PTC Session Token... login failed :(')
-            return False
-
-        self._login = True
-
-        return True
+            if force_refresh:
+                self.log.info('Forced request of PTC Access Token!')
+            else:
+                self.log.info('Request PTC Access Token...')
+
+            data1 = {
+                'client_id': 'mobile-app_pokemon-go',
+                'redirect_uri': 'https://www.nianticlabs.com/pokemongo/error',
+                'client_secret': self.PTC_LOGIN_CLIENT_SECRET,
+                'grant_type': 'refresh_token',
+                'code': self._refresh_token,
+            }
+
+            r2 = self._session.post(self.PTC_LOGIN_OAUTH, data=data1)
+
+            qs = r2.content.decode('utf-8')
+            token_data = parse_qs(qs)
+
+            access_token = token_data.get('access_token', None)
+            if access_token is not None:
+                self._access_token = access_token[0]
+
+                now_s = get_time()
+                expires = int(token_data.get('expires', [0])[0])
+                if expires > 0:
+                    self._access_token_expiry = expires + now_s
+                else:
+                    self._access_token_expiry = 0
+
+                self._login = True
+
+                self.log.info('PTC Access Token successfully retrieved.')
+                self.log.debug('PTC Access Token: %s...', self._access_token[:25])
+            else:
+                self._access_token = None
+                self._login = False
+                raise AuthException("Could not retrieve a PTC Access Token")
+
+
 

pgoapi/exceptions.py

@@ -48,4 +48,17 @@ class ServerSideAccessForbiddenException(Exception):
     pass
 
 class UnexpectedResponseException(Exception):
-    pass
+    pass
+
+class AuthTokenExpiredException(Exception):
+    pass
+
+class ServerApiEndpointRedirectException(Exception):
+    def __init__(self):
+        self._api_endpoint = None
+
+    def get_redirected_endpoint(self):
+        return self._api_endpoint
+
+    def set_redirected_endpoint(self, api_endpoint):
+        self._api_endpoint = api_endpoint