poke-go-api 0.0.4

data/lib/poke-api/POGOProtosSource/Settings/Master/Pokemon/StatsAttributes.proto

@@ -0,0 +1,9 @@
+syntax = "proto3";
+package POGOProtos.Settings.Master.Pokemon;
+
+message StatsAttributes {
+	int32 base_stamina = 1;
+	int32 base_attack = 2;
+	int32 base_defense = 3;
+	int32 dodge_energy_delta = 8;
+}

data/lib/poke-api/POGOProtosSource/Settings/Master/PokemonSettings.proto

@@ -0,0 +1,35 @@
+syntax = "proto3";
+package POGOProtos.Settings.Master;
+
+import "POGOProtos/Enums/PokemonId.proto";
+import "POGOProtos/Enums/PokemonRarity.proto";
+import "POGOProtos/Enums/PokemonType.proto";
+import "POGOProtos/Enums/PokemonMove.proto";
+import "POGOProtos/Enums/PokemonFamilyId.proto";
+import "POGOProtos/Settings/Master/Pokemon/StatsAttributes.proto";
+import "POGOProtos/Settings/Master/Pokemon/CameraAttributes.proto";
+import "POGOProtos/Settings/Master/Pokemon/EncounterAttributes.proto";
+
+message PokemonSettings {
+	.POGOProtos.Enums.PokemonId pokemon_id = 1;
+	float model_scale = 3;
+	.POGOProtos.Enums.PokemonType type = 4;
+	.POGOProtos.Enums.PokemonType type_2 = 5;
+	.POGOProtos.Settings.Master.Pokemon.CameraAttributes camera = 6;
+	.POGOProtos.Settings.Master.Pokemon.EncounterAttributes encounter = 7;
+	.POGOProtos.Settings.Master.Pokemon.StatsAttributes stats = 8;
+	repeated .POGOProtos.Enums.PokemonMove quick_moves = 9;
+	repeated .POGOProtos.Enums.PokemonMove cinematic_moves = 10;
+	repeated float animation_time = 11;
+	repeated .POGOProtos.Enums.PokemonId evolution_ids = 12;
+	int32 evolution_pips = 13;
+	.POGOProtos.Enums.PokemonRarity rarity = 14;
+	float pokedex_height_m = 15;
+	float pokedex_weight_kg = 16;
+	.POGOProtos.Enums.PokemonId parent_pokemon_id = 17;
+	float height_std_dev = 18;
+	float weight_std_dev = 19;
+	float km_distance_to_hatch = 20;
+	.POGOProtos.Enums.PokemonFamilyId family_id = 21;
+	int32 candy_to_evolve = 22;
+}

data/lib/poke-api/POGOProtosSource/Settings/Master/PokemonUpgradeSettings.proto

@@ -0,0 +1,9 @@
+syntax = "proto3";
+package POGOProtos.Settings.Master;
+
+message PokemonUpgradeSettings {
+	int32 upgrades_per_level = 1;
+	int32 allowed_levels_above_player = 2;
+	repeated int32 candy_cost = 3;
+	repeated int32 stardust_cost = 4;
+}

data/lib/poke-api/POGOProtosSource/Settings/Master/TypeEffectiveSettings.proto

@@ -0,0 +1,9 @@
+syntax = "proto3";
+package POGOProtos.Settings.Master;
+
+import "POGOProtos/Enums/PokemonType.proto";
+
+message TypeEffectiveSettings {
+	repeated float attack_scalar = 1;
+	.POGOProtos.Enums.PokemonType attack_type = 2;
+}

data/lib/poke-api/auth/google.rb

@@ -0,0 +1,51 @@
+require 'gpsoauth'
+
+module Poke
+  module API
+    module Auth
+      class GOOGLE
+        include Logging
+        attr_reader :access_token, :provider
+
+        GOOGLE_LOGIN_ANDROID_ID = '9774d56d682e549c'
+        GOOGLE_LOGIN_SERVICE    = 'audience:server:client_id:848232511240-7so421jotr' \
+                                  '2609rmqakceuu1luuq0ptb.apps.googleusercontent.com'
+        GOOGLE_LOGIN_APP        = 'com.nianticlabs.pokemongo'
+        GOOGLE_LOGIN_CLIENT_SIG = '321187995bc7cdc2b5fc91b11a96e2baa8602c62'
+
+        def initialize(username, password)
+          @username = username
+          @password = password
+          @provider = 'google'
+        end
+
+        def connect
+          logger.debug '[>] Fetching Google access token'
+
+          token_request = perform_request('Token') do
+            Gpsoauth::Auth.performMasterLogin(@username, @password, GOOGLE_LOGIN_ANDROID_ID)
+          end
+
+          auth_request = perform_request('Auth') do
+            Gpsoauth::Auth.performOAuth(@username, token_request['Token'], GOOGLE_LOGIN_ANDROID_ID,
+                                        GOOGLE_LOGIN_SERVICE, GOOGLE_LOGIN_APP, GOOGLE_LOGIN_CLIENT_SIG)
+          end
+
+          @access_token = auth_request['Auth']
+        end
+
+        private
+
+        def perform_request(method)
+          response = yield
+
+          unless response['Token'] || response['Auth']
+            raise Errors::GoogleAuthenticationFailure.new(method, response)
+          end
+
+          response
+        end
+      end
+    end
+  end
+end

data/lib/poke-api/auth/ptc.rb

@@ -0,0 +1,69 @@
+require 'json'
+require 'httpclient'
+
+module Poke
+  module API
+    module Auth
+      class PTC
+        include Logging
+        attr_reader :access_token, :provider
+
+        PTC_LOGIN_URL = 'https://sso.pokemon.com/sso/login?service=https%3A%2F%2Fsso.pokemon.com' \
+                        '%2Fsso%2Foauth2.0%2FcallbackAuthorize'
+        PTC_LOGIN_OAUTH = 'https://sso.pokemon.com/sso/oauth2.0/accessToken'
+        PTC_LOGIN_CLIENT_SECRET = 'w8ScCUXJQc6kXKw8FiOhd8Fixzht18Dq3PEVkUCP5ZPxtgyWsbTvWHFLm2wNY0JR'
+
+        def initialize(username, password)
+          @username = username
+          @password = password
+          @provider = 'ptc'
+          @client   = HTTPClient.new(agent_name: 'PokeAPI/0.0.1')
+        end
+
+        def connect
+          resp = @client.get_content(PTC_LOGIN_URL)
+          parsed_resp = JSON.parse(resp)
+
+          data = {
+            username: @username,
+            password: @password,
+            _eventId: 'submit',
+            lt: parsed_resp['lt'],
+            execution: parsed_resp['execution']
+          }
+
+          fetch_ticket(data)
+        end
+
+        private
+
+        def fetch_ticket(data)
+          logger.debug '[>] Fetching PTC ticket'
+
+          ticket = begin
+            @client.post_content(PTC_LOGIN_URL, data)
+          rescue StandardError => ex
+            ex.res.http_header.request_uri.to_s.match(/ticket=(.*)/)[1]
+          end
+
+          fetch_access_token(ticket)
+        end
+
+        def fetch_access_token(ticket)
+          logger.debug '[>] Fetching PTC access token'
+
+          data = {
+            client_id: 'mobile-app_pokemon-go',
+            redirect_uri: 'https://www.nianticlabs.com/pokemongo/error',
+            client_secret: PTC_LOGIN_CLIENT_SECRET,
+            grant_type: 'refresh_token',
+            code: ticket
+          }
+
+          @access_token = @client.post(PTC_LOGIN_OAUTH, data).body
+                                 .match(/access_token=(.*)&expires/)[1]
+        end
+      end
+    end
+  end
+end

data/lib/poke-api/client.rb

@@ -0,0 +1,83 @@
+module Poke
+  module API
+    class Client
+      include Logging
+      attr_accessor :lat, :lng, :alt
+
+      def initialize
+        @auth     = nil
+        @endpoint = 'https://pgorelease.nianticlabs.com/plfe/rpc'
+        @reqs     = []
+        @lat      = 0
+        @lng      = 0
+        @alt      = 0
+      end
+
+      def login(username, password, provider)
+        raise Errors::InvalidProvider.new(provider) unless ['PTC', 'GOOGLE'].include?(provider.upcase!)
+        logger.info "[+] Logging in user: #{username}"
+
+        begin
+          @auth = Auth.const_get(provider).new(username, password)
+          @auth.connect
+        rescue StandardError => ex
+          raise Errors::LoginFailure.new(provider, ex)
+        end
+
+        logger.info "[+] Login with #{provider} Successful"
+        fetch_endpoint
+      end
+
+      def call
+        raise Errors::LoginRequired.new unless @auth
+        req = RequestBuilder.new(@auth, [@lat, @lng, @alt], @endpoint)
+
+        begin
+          resp = req.request(@reqs)
+        rescue StandardError => ex
+          raise Errors::UnknownProtoFault.new(ex)
+        ensure
+          @reqs = []
+          logger.info '[+] Cleaning up RPC requests'
+        end
+
+        resp
+      end
+
+      def store_location(loc)
+        pos = Poke::API::Helpers.get_position(loc).first
+        logger.info "[+] Given location: #{pos.address}"
+
+        logger.info "[+] Lat/Long: #{pos.latitude}, #{pos.longitude}"
+        @lat, @lng = pos.latitude, pos.longitude
+      end
+
+      def inspect
+        "#<#{self.class.name} @auth=#{@auth} @reqs=#{@reqs} " \
+        "@lat=#{@lat} @lng=#{@lng} @alt=#{@alt}>"
+      end
+
+      private
+
+      def fetch_endpoint
+        get_player
+        get_hatched_eggs
+        get_inventory
+        check_awarded_badges
+        download_settings(hash: '4a2e9bc330dae60e7b74fc85b98868ab4700802e')
+
+        @endpoint = "https://#{call.response[:api_url]}/rpc"
+        logger.debug "[+] Setting endpoint to #{@endpoint}"
+      end
+
+      def method_missing(method, *args)
+        begin
+          POGOProtos::Networking::Requests::RequestType.const_get(method.upcase)
+          @reqs << (args.empty? ?  method.to_sym.upcase : { method.to_sym.upcase => args.first })
+        rescue NameError
+          super
+        end
+      end
+    end
+  end
+end

data/lib/poke-api/errors.rb

@@ -0,0 +1,41 @@
+module Poke
+  module API
+    class Errors
+      class InvalidProvider < StandardError
+        def initialize(provider)
+          super("Invalid provider #{provider}.")
+        end
+      end
+
+      class LoginRequired < StandardError
+        def initialize
+          super('Not logged in currently, please login.')
+        end
+      end
+
+      class InvalidRequestEntry < StandardError
+        def initialize(subreq)
+          super("Subrequest entry #{subreq} is invalid.")
+        end
+      end
+
+      class UnknownProtoFault < StandardError
+        def initialize(error)
+          super("An unknown proto fault has occured => [#{error} @ #{error.backtrace.first}]")
+        end
+      end
+
+      class GoogleAuthenticationFailure < StandardError
+        def initialize(token, response)
+          super("Unable to login to Google, could not find => #{token} in #{response}")
+        end
+      end
+
+      class LoginFailure < StandardError
+        def initialize(provider, error)
+          super("Unable to login to #{provider} => [#{error} @ #{error.backtrace.first}]")
+        end
+      end
+    end
+  end
+end

data/lib/poke-api/helpers.rb

@@ -0,0 +1,17 @@
+require 'geocoder'
+
+module Poke
+  module API
+    class Helpers
+      class << self
+        def get_position(pos)
+          Geocoder.search(pos)
+        end
+
+        def camel_case_lower(sym)
+          sym.to_s.split('_').collect(&:capitalize).join
+        end
+      end
+    end
+  end
+end

data/lib/poke-api/logging.rb

@@ -0,0 +1,33 @@
+require 'logger'
+require 'time'
+
+module Poke
+  module API
+    module Logging
+      @@loggers = {}
+      @@log_level = :INFO
+      @@formatter = proc do |severity, datetime, progname, msg|
+        sev_color = ['INFO', 'DEBUG', 'ANY'].include?(severity) ? "\e[32m" : "\e[31m"
+
+        "[\e[36m%s\e[0m]: #{sev_color}%-5s\e[0m > \e[33m%-25s\e[0m --: %s\n" \
+          % [datetime.iso8601, severity, progname, msg]
+      end
+
+      def logger
+        @@loggers[self.class.name] ||= Logger.new(STDOUT).tap do |logger| 
+          logger.progname = self.class.name
+          logger.level = Logger.const_get(@@log_level)
+          logger.formatter = @@formatter
+        end
+      end
+
+      def self.log_level=(level)
+        @@log_level = level
+      end
+
+      def self.formatter=(formatter)
+        @@formatter = formatter
+      end
+    end
+  end
+end

data/lib/poke-api/request_builder.rb

@@ -0,0 +1,98 @@
+module Poke
+  module API
+    class RequestBuilder
+      include Logging
+
+      def initialize(auth, pos, endpoint)
+        @access_token = auth.access_token
+        @provider     = auth.provider
+        @endpoint     = endpoint
+        @position     = pos
+        @client       = HTTPClient.new(agent_name: 'PokeAPI/0.0.1')
+      end
+
+      def request(reqs)
+        logger.debug '[+] Creating new request'
+        request_proto = build_main_request(reqs)
+
+        logger.info '[+] Executing RPC request'
+        resp = execute_rpc_request(request_proto)
+
+        resp = Response.new(resp.body, reqs)
+        resp.decode_response
+
+        resp
+      end
+
+      private
+
+      def build_main_request(sub_reqs)
+        request_envelope = POGOProtos::Networking::Envelopes::RequestEnvelope
+        req = request_envelope.new(
+          status_code: 2, 
+          request_id: 814_580_613_288_820_746_0, 
+          unknown12: 989
+        )
+        req.latitude, req.longitude, req.altitude = @position
+
+        token = request_envelope::AuthInfo::JWT.new(contents: @access_token, unknown2: 59)
+        req.auth_info = request_envelope::AuthInfo.new(provider: @provider, token: token)
+
+        build_sub_request(req, sub_reqs)
+
+        logger.debug "[+] Generated RPC protobuf request \r\n#{req.inspect}"
+        req.to_proto
+      end
+
+      def build_sub_request(req, sub_reqs)
+        sub_reqs.each do |sub_req|
+          if sub_req.is_a?(Symbol)
+            append_int_request(req, sub_req)
+          elsif sub_req.is_a?(Hash)
+            append_hash_request(req, sub_req)
+          else
+            raise Errors::InvalidRequestEntry.new(sub_req)
+          end
+        end
+      end
+
+      def append_int_request(req, sub_req)
+        entry_id = fetch_request_id(sub_req)
+        int_req = POGOProtos::Networking::Requests::Request.new(request_type: entry_id)
+
+        req.requests << int_req
+        logger.info "[+] Adding '#{int_req.request_type}' to RPC request"
+      end
+
+      def append_hash_request(req, sub_req)
+        entry_name = sub_req.keys.first
+        entry_id   = fetch_request_id(entry_name)
+
+        logger.info "[+] Adding '#{entry_name}' to RPC request with arguments"
+        proto_class = fetch_proto_request_class(sub_req, entry_name)
+
+        req.requests << POGOProtos::Networking::Requests::Request.new(
+          request_type: entry_id,
+          request_message: proto_class.to_proto
+        )
+      end
+
+      def fetch_request_id(name)
+        POGOProtos::Networking::Requests::RequestType.const_get(name)
+      end
+
+      def fetch_proto_request_class(sub_req, entry_name)
+        entry_content = sub_req[entry_name]
+        proto_name    = Poke::API::Helpers.camel_case_lower(entry_name) + 'Message'
+        logger.debug "[+] #{entry_name}: #{entry_content}"
+
+        require "poke-api/POGOProtos/Networking/Requests/Messages/#{proto_name}"
+        POGOProtos::Networking::Requests::Messages.const_get(proto_name).new(entry_content)
+      end
+
+      def execute_rpc_request(request)
+        @client.post(@endpoint, request)
+      end
+    end
+  end
+end