Merge in (and fix) KeyPhact's U6 implementation

pgoapi/pgoapi.py

@@ -58,6 +58,8 @@ def __init__(self, provider = None, oauth2_refresh_token = None, username = None
         self._position_lng = position_lng
         self._position_alt = position_alt
 
+        self._signature_lib = None
+
     def set_logger(self, logger = None):
         self.log = logger or logging.getLogger(__name__)
 
@@ -106,6 +108,12 @@ def create_request(self):
         request = PGoApiRequest(self, self._position_lat, self._position_lng, self._position_alt)
         return request
 
+    def activate_signature(self, lib_path):    
+        self._signature_lib = lib_path
+
+    def get_signature_lib(self):    
+        return self._signature_lib
+
     def __getattr__(self, func):
         def function(**kwargs):
             request = self.create_request()
@@ -195,6 +203,10 @@ def call(self):
             return NotLoggedInException()
 
         request = RpcApi(self._auth_provider)
+
+        lib_path = self.__parent__.get_signature_lib()
+        if lib_path is not None:
+            request.activate_signature(lib_path)
 
         self.log.info('Execution of RPC')
         response = None

pgoapi/rpc_api.py

@@ -25,7 +25,9 @@
 
 from __future__ import absolute_import
 
+import os
 import re
+import time
 import base64
 import random
 import logging
@@ -36,18 +38,23 @@
 
 from importlib import import_module
 
+
+import ctypes
+
 from pgoapi.protobuf_to_dict import protobuf_to_dict
 from pgoapi.exceptions import NotLoggedInException, ServerBusyOrOfflineException, ServerSideRequestThrottlingException, ServerSideAccessForbiddenException, UnexpectedResponseException, AuthTokenExpiredException, ServerApiEndpointRedirectException
-from pgoapi.utilities import to_camel_case, get_time, get_format_time_diff
+from pgoapi.utilities import to_camel_case, get_time, get_format_time_diff, Rand48, long_to_bytes, generateLocation1, generateLocation2, generateRequestHash, f2i
 
 from . import protos
 from POGOProtos.Networking.Envelopes_pb2 import RequestEnvelope
 from POGOProtos.Networking.Envelopes_pb2 import ResponseEnvelope
 from POGOProtos.Networking.Requests_pb2 import RequestType
+import Signature_pb2
 
 class RpcApi:
 
     RPC_ID = 0
+    START_TIME = 0
 
     def __init__(self, auth_provider):
 
@@ -59,10 +66,25 @@ def __init__(self, auth_provider):
 
         self._auth_provider = auth_provider
 
+        """ mystic unknown6 - revolved by PokemonGoDev """
+        self._signature_gen = False
+        self._signature_lib = None
+
+        if RpcApi.START_TIME == 0:
+            RpcApi.START_TIME = get_time(ms = True)
+
         if RpcApi.RPC_ID == 0:
             RpcApi.RPC_ID = int(random.random() * 10 ** 18)
             self.log.debug('Generated new random RPC Request id: %s', RpcApi.RPC_ID)
 
+    def activate_signature(self, lib_path):
+        try:
+            ctypes.cdll.LoadLibrary(lib_path)
+            self._signature_gen = True
+            self._signature_lib = lib_path
+        except:
+            raise
+
     def get_rpc_id(self):
         RpcApi.RPC_ID += 1
         self.log.debug("Incremented RPC Request ID: %s", RpcApi.RPC_ID)
@@ -146,7 +168,7 @@ def check_authentication(self, response_dict):
             else:
                 self.log.debug('Received Session Ticket valid for %02d:%02d:%02d hours (%s < %s)', h, m, s, now_ms, auth_ticket['expire_timestamp_ms'])
 
-    def _build_main_request2(self, subrequests, player_position = None):
+    def _build_main_request(self, subrequests, player_position = None):
         self.log.debug('Generating main RPC request...')
 
         request = RequestEnvelope()
@@ -155,11 +177,38 @@ def _build_main_request2(self, subrequests, player_position = None):
 
         if player_position is not None:
             request.latitude, request.longitude, request.altitude = player_position
+
+        request.altitude = 0.63
+
+        """ generate sub requests before signature generation """
+        request = self._build_sub_requests(request, subrequests)
 
         ticket = self._auth_provider.get_ticket()
         if ticket:
             self.log.debug('Found Session Ticket - using this instead of oauth token')
             request.auth_ticket.expire_timestamp_ms, request.auth_ticket.start, request.auth_ticket.end = ticket
+
+            if self._signature_gen:
+                ticket_serialized = request.auth_ticket.SerializeToString()
+
+                sig = Signature_pb2.Signature()
+
+                sig.location_hash1 = generateLocation1(ticket_serialized, request.latitude, request.longitude, request.altitude)
+                sig.location_hash2 = generateLocation2(request.latitude, request.longitude, request.altitude)
+
+                for req in request.requests:
+                    hash = generateRequestHash(ticket_serialized, req.SerializeToString())
+                    sig.request_hash.append( hash )
+
+                sig.unk22 = os.urandom(32)
+                sig.timestamp = get_time(ms=True)
+                sig.timestamp_since_start = get_time(ms=True) - RpcApi.START_TIME
+
+                signature_proto = sig.SerializeToString()
+
+                u6 = request.unknown6.add()
+                u6.request_type = 6
+                u6.unknown2.unknown1 = self._generate_signature(signature_proto, self._signature_lib)
         else:
             self.log.debug('No Session Ticket found - using OAUTH Access Token')
             request.auth_info.provider = self._auth_provider.get_name()
@@ -169,13 +218,27 @@ def _build_main_request2(self, subrequests, player_position = None):
         # unknown stuff
         request.unknown12 = 989
 
-        request = self._build_sub_requests(request, subrequests)
-
         self.log.debug('Generated protobuf request: \n\r%s', request )
 
         return request
 
-    def _build_main_request(self, subrequests, player_position = None):
+    def _generate_signature(self, signature_plain, lib_path = "encrypt.so"):
+        lib = ctypes.cdll.LoadLibrary(lib_path)
+        lib.argtypes = [ctypes.c_char_p, ctypes.c_size_t, ctypes.c_char_p, ctypes.c_size_t, ctypes.POINTER(ctypes.c_ubyte), ctypes.POINTER(ctypes.c_size_t)] 
+        lib.restype  = ctypes.c_int
+
+        iv = os.urandom(32)
+
+        output_size = ctypes.c_size_t()
+
+        ret = lib.encrypt(signature_plain, len(signature_plain), iv, 32, None, ctypes.byref(output_size))
+        output = (ctypes.c_ubyte * output_size.value)()
+        ret = lib.encrypt(signature_plain, len(signature_plain), iv, 32, ctypes.byref(output), ctypes.byref(output_size))
+
+        signature = b''.join(map(chr, output))
+        return signature
+
+    def _build_main_request_orig(self, subrequests, player_position = None):
         self.log.debug('Generating main RPC request...')
 
         request = RequestEnvelope()

pgoapi/utilities.py

@@ -26,8 +26,9 @@
 import re
 import time
 import struct
-import logging
+import ctypes
 import xxhash
+import logging
 
 from json import JSONEncoder
 from binascii import unhexlify
@@ -159,21 +160,24 @@ def long_to_bytes (val, endianness='big'):
     return s
 
 
-def generateLocation1(authticket, lat, lng, alt):                                #u10
-    firstHash = xxhash.xxh32(bytearray(authticket), seed=0x1B845238).intdigest() #Hashing the auth ticket using static seed 0x1B845238
-    locationBytes = bytearray([lat,lng,alt])                                     #Lat, long and alt as a double
-    locationHash = xxhash.xxh32(locationBytes, seed=firstHash).intdigest()       #hash of location using the hashed auth ticket as seed
-    return locationHash
-
-def generateLocation2(lat, lng, alt):                                            #u20
-    locationBytes = bytearray([lat,lng,alt])
-    locationHash = xxhash.xxh32(locationBytes, seed=0x1B845238).intdigest()      #Hash of location using static seed 0x1B845238
-    return locationHash
-
-def generateRequests(authticket, requests):                                                  #u24
-    firstHash = xxhash.xxh64(bytearray(authticket), seed=0x1B845238).intdigest() #Hashing the auth ticket using static seed 0x1B845238
-    hashList = []                                                                #Leaving as a list for now
-    for req in requests:                                                         
-        hashList.add(xxhash.xxh64(bytearray(req), seed=firstHash).intdigest())   #Hash each request with the hashed auth ticket as seed
-    hashArray = array(I, hashList)                                               #Convert the list to an array
-    return hashArray
+def generateLocation1(authticket, lat, lng, alt): 
+    firstHash = xxhash.xxh32(authticket, seed=0x1B845238).intdigest()
+    locationBytes = d2h(lat) + d2h(lng) + d2h(alt)
+    if not alt:
+        alt = "\x00\x00\x00\x00\x00\x00\x00\x00"
+    return xxhash.xxh32(locationBytes, seed=firstHash).intdigest()
+
+def generateLocation2(lat, lng, alt):
+    locationBytes = d2h(lat) + d2h(lng) + d2h(alt)
+    if not alt:
+        alt = "\x00\x00\x00\x00\x00\x00\x00\x00"
+    return xxhash.xxh32(locationBytes, seed=0x1B845238).intdigest()      #Hash of location using static seed 0x1B845238
+
+
+def generateRequestHash(authticket, request):
+    firstHash = xxhash.xxh64(authticket, seed=0x1B845238).intdigest()                      
+    return xxhash.xxh64(request, seed=firstHash).intdigest()
+
+
+def d2h(f):
+    return hex(struct.unpack('<Q', struct.pack('<d', f))[0])[2:-1].decode("hex")

pokecli.py

@@ -116,24 +116,18 @@ def main():
     # set player position on the earth
     api.set_position(*position)
 
-    if not api.login(config.auth_service, config.username, config.password, app_simulation = True):
-        return
+    # new authentication initialitation
+    api.set_authentication(provider = config.auth_service, username = config.username, password =  config.password)
 
-    # get player profile call (single command example)
-    # ----------------------
-    response_dict = api.get_player()
-    print('Response dictionary (get_player): \n\r{}'.format(pprint.PrettyPrinter(indent=4).pformat(response_dict)))
+    # provide the path for your encrypt dll
+    api.activate_signature("encrypt.dll")
 
-    # sleep due to server-side throttling
-    time.sleep(0.2)
+    # print get maps object
+    cell_ids = util.get_cell_ids(position[0], position[1])
+    timestamps = [0,] * len(cell_ids)
+    response_dict = api.get_map_objects(latitude =position[0], longitude = position[1], since_timestamp_ms = timestamps, cell_id = cell_ids)
+    print('Response dictionary (get_player): \n\r{}'.format(pprint.PrettyPrinter(indent=4).pformat(response_dict)))
 
-    # get player profile + inventory call (thread-safe/chaining example)
-    # ----------------------
-    req = api.create_request()
-    req.get_player()
-    req.get_inventory()
-    response_dict = req.call()
-    print('Response dictionary (get_player + get_inventory): \n\r{}'.format(pprint.PrettyPrinter(indent=4).pformat(response_dict)))
 
 if __name__ == '__main__':
     main()

requirements.txt

@@ -4,3 +4,4 @@ requests==2.10.0
 s2sphere==0.2.4
 gpsoauth==0.3.0
 six
+xxhash