From dce12b7e674007c5b88730e4bd447a5de2a86564 Mon Sep 17 00:00:00 2001 From: jim zhou <43537315+jimtje@users.noreply.github.com> Date: Tue, 15 Sep 2020 12:26:28 -0700 Subject: [PATCH 01/23] add protobuf-based v3 sms auth script --- authgateway.proto | 213 ++++++++++++++++++ authgateway.py | 233 ++++++++++++++++++++ google/protobuf/any.proto | 15 ++ google/protobuf/api.proto | 38 ++++ google/protobuf/compiler/plugin.proto | 34 +++ google/protobuf/descriptor.proto | 298 ++++++++++++++++++++++++++ google/protobuf/duration.proto | 16 ++ google/protobuf/empty.proto | 15 ++ google/protobuf/field_mask.proto | 15 ++ google/protobuf/source_context.proto | 14 ++ google/protobuf/struct.proto | 34 +++ google/protobuf/timestamp.proto | 16 ++ google/protobuf/type.proto | 89 ++++++++ google/protobuf/wrappers.proto | 47 ++++ requirements.txt | 18 ++ sms_auth_v3.py | 85 ++++++++ 16 files changed, 1180 insertions(+) create mode 100644 authgateway.proto create mode 100644 authgateway.py create mode 100644 google/protobuf/any.proto create mode 100644 google/protobuf/api.proto create mode 100644 google/protobuf/compiler/plugin.proto create mode 100644 google/protobuf/descriptor.proto create mode 100644 google/protobuf/duration.proto create mode 100644 google/protobuf/empty.proto create mode 100644 google/protobuf/field_mask.proto create mode 100644 google/protobuf/source_context.proto create mode 100644 google/protobuf/struct.proto create mode 100644 google/protobuf/timestamp.proto create mode 100644 google/protobuf/type.proto create mode 100644 google/protobuf/wrappers.proto create mode 100644 requirements.txt create mode 100644 sms_auth_v3.py diff --git a/authgateway.proto b/authgateway.proto new file mode 100644 index 0000000..6fc1a90 --- /dev/null +++ b/authgateway.proto @@ -0,0 +1,213 @@ +syntax = "proto3"; + +package tinder.services.authgateway; + +import "google/protobuf/wrappers.proto"; +import "google/protobuf/timestamp.proto"; + +option java_multiple_files = true; +option java_package = "com.tinder.generated.model.services.shared.authgateway"; + +message FacebookToken { + string external_token = 1; + google.protobuf.StringValue refresh_token = 2; +} + +message Phone { + string phone = 1; + google.protobuf.StringValue refresh_token = 2; +} + +message PhoneOtpResend { + google.protobuf.StringValue phone = 1; + google.protobuf.StringValue refresh_token = 2; +} + +message PhoneOtp { + google.protobuf.StringValue phone = 1; + string otp = 2; + google.protobuf.StringValue refresh_token = 3; +} + +message Email { + string email = 1; + google.protobuf.StringValue refresh_token = 2; + google.protobuf.BoolValue marketing_opt_in = 3; +} + +message EmailOtpResend { + google.protobuf.StringValue email = 1; + google.protobuf.StringValue refresh_token = 2; +} + +message GoogleToken { + string external_token = 1; + google.protobuf.StringValue refresh_token = 2; + google.protobuf.BoolValue marketing_opt_in = 3; + google.protobuf.BoolValue user_behavior = 4; +} + +message EmailOtp { + google.protobuf.StringValue email = 1; + string otp = 2; + google.protobuf.StringValue refresh_token = 3; +} + +message AppleToken { + string external_token = 1; + google.protobuf.StringValue refresh_token = 2; + google.protobuf.StringValue raw_nonce = 3; +} + +message GetInitialState { + google.protobuf.StringValue refresh_token = 1; +} + +message RefreshAuth { + string refresh_token = 1; +} + +message DismissSocialConnectionList { + string refresh_token = 1; +} + +message AuthGatewayRequest { + oneof factor { + Phone phone = 1; + PhoneOtp phone_otp = 2; + Email email = 3; + GoogleToken google_token = 4; + EmailOtp email_otp = 5; + FacebookToken facebook_token = 6; + PhoneOtpResend phone_otp_resend = 7; + EmailOtpResend email_otp_resend = 8; + GetInitialState get_initial_state = 9; + RefreshAuth refresh_auth = 10; + AppleToken apple_token = 11; + DismissSocialConnectionList dismiss_social_connection_list = 12; + } +} + + +message GetPhoneState { + google.protobuf.StringValue refresh_token = 1; +} + +message ValidatePhoneOtpState { + google.protobuf.StringValue refresh_token = 1; + string phone = 2; + google.protobuf.Int32Value otp_length = 3; + google.protobuf.BoolValue sms_sent = 4; +} + +message EmailMarketing { + google.protobuf.BoolValue show_marketing_opt_in = 2; + google.protobuf.BoolValue show_strict_opt_in = 3; + google.protobuf.BoolValue checked_by_default = 4; +} + +message GetEmailState { + google.protobuf.StringValue refresh_token = 1; + EmailMarketing email_marketing = 2; +} + +message ValidateEmailOtpState { + google.protobuf.StringValue refresh_token = 1; + google.protobuf.Int32Value otp_length = 4; + google.protobuf.BoolValue email_sent = 5; + EmailMarketing email_marketing = 6; + + oneof email { + string unmasked_email = 2; + string masked_email = 3; + } +} + +message OnboardingState { + string refresh_token = 1; + string onboarding_token = 2; +} + +message LoginResult { + string refresh_token = 1; + string auth_token = 2; + + Captcha captcha = 3; + enum Captcha { + CAPTCHA_INVALID = 0; + CAPTCHA_V1 = 1; + CAPTCHA_V2 = 2; + } + + string user_id = 4; + google.protobuf.Int64Value auth_token_ttl = 5; +} + +message AppleAccountNotFound { + bool will_link = 1; + google.protobuf.StringValue refresh_token = 2; +} + +message SocialConnection { + Service service = 1; + enum Service { + SERVICE_INVALID = 0; + SERVICE_FACEBOOK = 1; + SERVICE_GOOGLE = 2; + SERVICE_APPLE = 3; + } +} + +message SocialConnectionList { + google.protobuf.StringValue refresh_token = 1; + repeated SocialConnection connections = 2; +} + +message AuthGatewayResponse { + MetaProto meta = 1; + ErrorProto error = 2; + + oneof data { + GetPhoneState get_phone_state = 3; + ValidatePhoneOtpState validate_phone_otp_state = 4; + GetEmailState get_email_state = 5; + ValidateEmailOtpState validate_email_otp_state = 6; + OnboardingState onboarding_state = 7; + LoginResult login_result = 8; + SocialConnectionList social_connection_list = 9; + AppleAccountNotFound apple_account_not_found = 10; + } +} +message Verification { + string type = 1; + string state = 2; +} + +message UnderageBan { + google.protobuf.Int64Value underage_ttl_duration_ms = 1; + google.protobuf.StringValue underage_token = 2; + Verification verification = 3; +} + +message BanAppeal { + string challenge_type = 1; + string challenge_token = 2; + string refresh_token = 3; +} + +message BanReason { + oneof reason { + UnderageBan underage_ban = 1; + BanAppeal ban_appeal = 2; + } +} +message ErrorProto { + int32 code = 1; + string message = 2; + BanReason ban_reason = 3; +} + +message MetaProto { + google.protobuf.Timestamp upstream_time = 1; + google.protobuf.Timestamp start_time = 2; +} diff --git a/authgateway.py b/authgateway.py new file mode 100644 index 0000000..6e6e5e5 --- /dev/null +++ b/authgateway.py @@ -0,0 +1,233 @@ +# Generated by the protocol buffer compiler. DO NOT EDIT! +# sources: authgateway.proto +# plugin: python-betterproto +from dataclasses import dataclass +from datetime import datetime +from typing import List, Optional + +import betterproto + + +class LoginResultCaptcha(betterproto.Enum): + CAPTCHA_INVALID = 0 + CAPTCHA_V1 = 1 + CAPTCHA_V2 = 2 + + +class SocialConnectionService(betterproto.Enum): + SERVICE_INVALID = 0 + SERVICE_FACEBOOK = 1 + SERVICE_GOOGLE = 2 + SERVICE_APPLE = 3 + + +@dataclass +class FacebookToken(betterproto.Message): + external_token: str = betterproto.string_field(1) + refresh_token: Optional[str] = betterproto.message_field(2, wraps=betterproto.TYPE_STRING) + + +@dataclass +class Phone(betterproto.Message): + phone: str = betterproto.string_field(1) + refresh_token: Optional[str] = betterproto.message_field(2, wraps=betterproto.TYPE_STRING) + + +@dataclass +class PhoneOtpResend(betterproto.Message): + phone: Optional[str] = betterproto.message_field(1, wraps=betterproto.TYPE_STRING) + refresh_token: Optional[str] = betterproto.message_field(2, wraps=betterproto.TYPE_STRING) + + +@dataclass +class PhoneOtp(betterproto.Message): + phone: Optional[str] = betterproto.message_field(1, wraps=betterproto.TYPE_STRING) + otp: str = betterproto.string_field(2) + refresh_token: Optional[str] = betterproto.message_field(3, wraps=betterproto.TYPE_STRING) + + +@dataclass +class Email(betterproto.Message): + email: str = betterproto.string_field(1) + refresh_token: Optional[str] = betterproto.message_field(2, wraps=betterproto.TYPE_STRING) + marketing_opt_in: Optional[bool] = betterproto.message_field(3, wraps=betterproto.TYPE_BOOL) + + +@dataclass +class EmailOtpResend(betterproto.Message): + email: Optional[str] = betterproto.message_field(1, wraps=betterproto.TYPE_STRING) + refresh_token: Optional[str] = betterproto.message_field(2, wraps=betterproto.TYPE_STRING) + + +@dataclass +class GoogleToken(betterproto.Message): + external_token: str = betterproto.string_field(1) + refresh_token: Optional[str] = betterproto.message_field(2, wraps=betterproto.TYPE_STRING) + marketing_opt_in: Optional[bool] = betterproto.message_field(3, wraps=betterproto.TYPE_BOOL) + user_behavior: Optional[bool] = betterproto.message_field(4, wraps=betterproto.TYPE_BOOL) + + +@dataclass +class EmailOtp(betterproto.Message): + email: Optional[str] = betterproto.message_field(1, wraps=betterproto.TYPE_STRING) + otp: str = betterproto.string_field(2) + refresh_token: Optional[str] = betterproto.message_field(3, wraps=betterproto.TYPE_STRING) + + +@dataclass +class AppleToken(betterproto.Message): + external_token: str = betterproto.string_field(1) + refresh_token: Optional[str] = betterproto.message_field(2, wraps=betterproto.TYPE_STRING) + raw_nonce: Optional[str] = betterproto.message_field(3, wraps=betterproto.TYPE_STRING) + + +@dataclass +class GetInitialState(betterproto.Message): + refresh_token: Optional[str] = betterproto.message_field(1, wraps=betterproto.TYPE_STRING) + + +@dataclass +class RefreshAuth(betterproto.Message): + refresh_token: str = betterproto.string_field(1) + + +@dataclass +class DismissSocialConnectionList(betterproto.Message): + refresh_token: str = betterproto.string_field(1) + + +@dataclass +class AuthGatewayRequest(betterproto.Message): + phone: "Phone" = betterproto.message_field(1, group="factor") + phone_otp: "PhoneOtp" = betterproto.message_field(2, group="factor") + email: "Email" = betterproto.message_field(3, group="factor") + google_token: "GoogleToken" = betterproto.message_field(4, group="factor") + email_otp: "EmailOtp" = betterproto.message_field(5, group="factor") + facebook_token: "FacebookToken" = betterproto.message_field(6, group="factor") + phone_otp_resend: "PhoneOtpResend" = betterproto.message_field(7, group="factor") + email_otp_resend: "EmailOtpResend" = betterproto.message_field(8, group="factor") + get_initial_state: "GetInitialState" = betterproto.message_field(9, group="factor") + refresh_auth: "RefreshAuth" = betterproto.message_field(10, group="factor") + apple_token: "AppleToken" = betterproto.message_field(11, group="factor") + dismiss_social_connection_list: "DismissSocialConnectionList" = (betterproto.message_field(12, group="factor")) + + +@dataclass +class GetPhoneState(betterproto.Message): + refresh_token: Optional[str] = betterproto.message_field(1, wraps=betterproto.TYPE_STRING) + + +@dataclass +class ValidatePhoneOtpState(betterproto.Message): + refresh_token: Optional[str] = betterproto.message_field(1, wraps=betterproto.TYPE_STRING) + phone: str = betterproto.string_field(2) + otp_length: Optional[int] = betterproto.message_field(3, wraps=betterproto.TYPE_INT32) + sms_sent: Optional[bool] = betterproto.message_field(4, wraps=betterproto.TYPE_BOOL) + + +@dataclass +class EmailMarketing(betterproto.Message): + show_marketing_opt_in: Optional[bool] = betterproto.message_field(2, wraps=betterproto.TYPE_BOOL) + show_strict_opt_in: Optional[bool] = betterproto.message_field(3, wraps=betterproto.TYPE_BOOL) + checked_by_default: Optional[bool] = betterproto.message_field(4, wraps=betterproto.TYPE_BOOL) + + +@dataclass +class GetEmailState(betterproto.Message): + refresh_token: Optional[str] = betterproto.message_field(1, wraps=betterproto.TYPE_STRING) + email_marketing: "EmailMarketing" = betterproto.message_field(2) + + +@dataclass +class ValidateEmailOtpState(betterproto.Message): + refresh_token: Optional[str] = betterproto.message_field(1, wraps=betterproto.TYPE_STRING) + otp_length: Optional[int] = betterproto.message_field(4, wraps=betterproto.TYPE_INT32) + email_sent: Optional[bool] = betterproto.message_field(5, wraps=betterproto.TYPE_BOOL) + email_marketing: "EmailMarketing" = betterproto.message_field(6) + unmasked_email: str = betterproto.string_field(2, group="email") + masked_email: str = betterproto.string_field(3, group="email") + + +@dataclass +class OnboardingState(betterproto.Message): + refresh_token: str = betterproto.string_field(1) + onboarding_token: str = betterproto.string_field(2) + + +@dataclass +class LoginResult(betterproto.Message): + refresh_token: str = betterproto.string_field(1) + auth_token: str = betterproto.string_field(2) + captcha: "LoginResultCaptcha" = betterproto.enum_field(3) + user_id: str = betterproto.string_field(4) + auth_token_ttl: Optional[int] = betterproto.message_field(5, wraps=betterproto.TYPE_INT64) + + +@dataclass +class AppleAccountNotFound(betterproto.Message): + will_link: bool = betterproto.bool_field(1) + refresh_token: Optional[str] = betterproto.message_field(2, wraps=betterproto.TYPE_STRING) + + +@dataclass +class SocialConnection(betterproto.Message): + service: "SocialConnectionService" = betterproto.enum_field(1) + + +@dataclass +class SocialConnectionList(betterproto.Message): + refresh_token: Optional[str] = betterproto.message_field(1, wraps=betterproto.TYPE_STRING) + connections: List["SocialConnection"] = betterproto.message_field(2) + + +@dataclass +class AuthGatewayResponse(betterproto.Message): + meta: "MetaProto" = betterproto.message_field(1) + error: "ErrorProto" = betterproto.message_field(2) + get_phone_state: "GetPhoneState" = betterproto.message_field(3, group="data") + validate_phone_otp_state: "ValidatePhoneOtpState" = betterproto.message_field(4, group="data") + get_email_state: "GetEmailState" = betterproto.message_field(5, group="data") + validate_email_otp_state: "ValidateEmailOtpState" = betterproto.message_field(6, group="data") + onboarding_state: "OnboardingState" = betterproto.message_field(7, group="data") + login_result: "LoginResult" = betterproto.message_field(8, group="data") + social_connection_list: "SocialConnectionList" = betterproto.message_field(9, group="data") + apple_account_not_found: "AppleAccountNotFound" = betterproto.message_field(10, group="data") + + +@dataclass +class Verification(betterproto.Message): + type: str = betterproto.string_field(1) + state: str = betterproto.string_field(2) + + +@dataclass +class UnderageBan(betterproto.Message): + underage_ttl_duration_ms: Optional[int] = betterproto.message_field(1, wraps=betterproto.TYPE_INT64) + underage_token: Optional[str] = betterproto.message_field(2, wraps=betterproto.TYPE_STRING) + verification: "Verification" = betterproto.message_field(3) + + +@dataclass +class BanAppeal(betterproto.Message): + challenge_type: str = betterproto.string_field(1) + challenge_token: str = betterproto.string_field(2) + refresh_token: str = betterproto.string_field(3) + + +@dataclass +class BanReason(betterproto.Message): + underage_ban: "UnderageBan" = betterproto.message_field(1, group="reason") + ban_appeal: "BanAppeal" = betterproto.message_field(2, group="reason") + + +@dataclass +class ErrorProto(betterproto.Message): + code: int = betterproto.int32_field(1) + message: str = betterproto.string_field(2) + ban_reason: "BanReason" = betterproto.message_field(3) + + +@dataclass +class MetaProto(betterproto.Message): + upstream_time: datetime = betterproto.message_field(1) + start_time: datetime = betterproto.message_field(2) \ No newline at end of file diff --git a/google/protobuf/any.proto b/google/protobuf/any.proto new file mode 100644 index 0000000..441ae1b --- /dev/null +++ b/google/protobuf/any.proto @@ -0,0 +1,15 @@ +syntax = "proto3"; + +package google.protobuf; + +option csharp_namespace = "Google.Protobuf.WellKnownTypes"; +option objc_class_prefix = "GPB"; +option go_package = "github.com/golang/protobuf/ptypes/any"; +option java_multiple_files = true; +option java_outer_classname = "AnyProto"; +option java_package = "com.google.protobuf"; + +message Any { + string type_url = 1; + bytes value = 2; +} diff --git a/google/protobuf/api.proto b/google/protobuf/api.proto new file mode 100644 index 0000000..f9b60e0 --- /dev/null +++ b/google/protobuf/api.proto @@ -0,0 +1,38 @@ +syntax = "proto3"; + +package google.protobuf; + +import "google/protobuf/source_context.proto"; +import "google/protobuf/type.proto"; + +option csharp_namespace = "Google.Protobuf.WellKnownTypes"; +option objc_class_prefix = "GPB"; +option go_package = "google.golang.org/genproto/protobuf/api;api"; +option java_multiple_files = true; +option java_outer_classname = "ApiProto"; +option java_package = "com.google.protobuf"; + +message Api { + string name = 1; + repeated Method methods = 2; + repeated Option options = 3; + string version = 4; + SourceContext source_context = 5; + repeated Mixin mixins = 6; + Syntax syntax = 7; +} + +message Method { + string name = 1; + string request_type_url = 2; + bool request_streaming = 3; + string response_type_url = 4; + bool response_streaming = 5; + repeated Option options = 6; + Syntax syntax = 7; +} + +message Mixin { + string name = 1; + string root = 2; +} diff --git a/google/protobuf/compiler/plugin.proto b/google/protobuf/compiler/plugin.proto new file mode 100644 index 0000000..61ee7f4 --- /dev/null +++ b/google/protobuf/compiler/plugin.proto @@ -0,0 +1,34 @@ +syntax = "proto2"; + +package google.protobuf.compiler; + +import "google/protobuf/descriptor.proto"; + +option go_package = "github.com/golang/protobuf/protoc-gen-go/plugin;plugin_go"; +option java_outer_classname = "PluginProtos"; +option java_package = "com.google.protobuf.compiler"; + +message Version { + optional int32 major = 1; + optional int32 minor = 2; + optional int32 patch = 3; + optional string suffix = 4; +} + +message CodeGeneratorRequest { + repeated string file_to_generate = 1; + optional string parameter = 2; + repeated FileDescriptorProto proto_file = 15; + optional Version compiler_version = 3; +} + +message CodeGeneratorResponse { + optional string error = 1; + + repeated File file = 15; + message File { + optional string name = 1; + optional string insertion_point = 2; + optional string content = 15; + } +} diff --git a/google/protobuf/descriptor.proto b/google/protobuf/descriptor.proto new file mode 100644 index 0000000..6003bb8 --- /dev/null +++ b/google/protobuf/descriptor.proto @@ -0,0 +1,298 @@ +syntax = "proto2"; + +package google.protobuf; + +option csharp_namespace = "Google.Protobuf.Reflection"; +option objc_class_prefix = "GPB"; +option cc_enable_arenas = true; +option go_package = "github.com/golang/protobuf/protoc-gen-go/descriptor;descriptor"; +option optimize_for = SPEED; +option java_outer_classname = "DescriptorProtos"; +option java_package = "com.google.protobuf"; + +message FileDescriptorSet { + repeated FileDescriptorProto file = 1; +} + +message FileDescriptorProto { + optional string name = 1; + optional string package = 2; + repeated string dependency = 3; + repeated int32 public_dependency = 10; + repeated int32 weak_dependency = 11; + repeated DescriptorProto message_type = 4; + repeated EnumDescriptorProto enum_type = 5; + repeated ServiceDescriptorProto service = 6; + repeated FieldDescriptorProto extension = 7; + optional FileOptions options = 8; + optional SourceCodeInfo source_code_info = 9; + optional string syntax = 12; +} + +message DescriptorProto { + optional string name = 1; + repeated FieldDescriptorProto field = 2; + repeated FieldDescriptorProto extension = 6; + repeated DescriptorProto nested_type = 3; + repeated EnumDescriptorProto enum_type = 4; + + repeated ExtensionRange extension_range = 5; + message ExtensionRange { + optional int32 start = 1; + optional int32 end = 2; + optional ExtensionRangeOptions options = 3; + } + + repeated OneofDescriptorProto oneof_decl = 8; + optional MessageOptions options = 7; + + repeated ReservedRange reserved_range = 9; + message ReservedRange { + optional int32 start = 1; + optional int32 end = 2; + } + + repeated string reserved_name = 10; +} + +message ExtensionRangeOptions { + repeated UninterpretedOption uninterpreted_option = 999; + + extensions 1000 to max; +} + +message FieldDescriptorProto { + optional string name = 1; + optional int32 number = 3; + + optional Label label = 4; + enum Label { + LABEL_OPTIONAL = 1; + LABEL_REQUIRED = 2; + LABEL_REPEATED = 3; + } + + optional Type type = 5; + enum Type { + TYPE_DOUBLE = 1; + TYPE_FLOAT = 2; + TYPE_INT64 = 3; + TYPE_UINT64 = 4; + TYPE_INT32 = 5; + TYPE_FIXED64 = 6; + TYPE_FIXED32 = 7; + TYPE_BOOL = 8; + TYPE_STRING = 9; + TYPE_GROUP = 10; + TYPE_MESSAGE = 11; + TYPE_BYTES = 12; + TYPE_UINT32 = 13; + TYPE_ENUM = 14; + TYPE_SFIXED32 = 15; + TYPE_SFIXED64 = 16; + TYPE_SINT32 = 17; + TYPE_SINT64 = 18; + } + + optional string type_name = 6; + optional string extendee = 2; + optional string default_value = 7; + optional int32 oneof_index = 9; + optional string json_name = 10; + optional FieldOptions options = 8; +} + +message OneofDescriptorProto { + optional string name = 1; + optional OneofOptions options = 2; +} + +message EnumDescriptorProto { + optional string name = 1; + repeated EnumValueDescriptorProto value = 2; + optional EnumOptions options = 3; + + repeated EnumReservedRange reserved_range = 4; + message EnumReservedRange { + optional int32 start = 1; + optional int32 end = 2; + } + + repeated string reserved_name = 5; +} + +message EnumValueDescriptorProto { + optional string name = 1; + optional int32 number = 2; + optional EnumValueOptions options = 3; +} + +message ServiceDescriptorProto { + optional string name = 1; + repeated MethodDescriptorProto method = 2; + optional ServiceOptions options = 3; +} + +message MethodDescriptorProto { + optional string name = 1; + optional string input_type = 2; + optional string output_type = 3; + optional MethodOptions options = 4; + optional bool client_streaming = 5 [default = false]; + optional bool server_streaming = 6 [default = false]; +} + +message FileOptions { + optional string java_package = 1; + optional string java_outer_classname = 8; + optional bool java_multiple_files = 10 [default = false]; + optional bool java_generate_equals_and_hash = 20 [deprecated = true]; + optional bool java_string_check_utf8 = 27 [default = false]; + + optional OptimizeMode optimize_for = 9 [default = SPEED]; + enum OptimizeMode { + SPEED = 1; + CODE_SIZE = 2; + LITE_RUNTIME = 3; + } + + optional string go_package = 11; + optional bool cc_generic_services = 16 [default = false]; + optional bool java_generic_services = 17 [default = false]; + optional bool py_generic_services = 18 [default = false]; + optional bool php_generic_services = 42 [default = false]; + optional bool deprecated = 23 [default = false]; + optional bool cc_enable_arenas = 31 [default = false]; + optional string objc_class_prefix = 36; + optional string csharp_namespace = 37; + optional string swift_prefix = 39; + optional string php_class_prefix = 40; + optional string php_namespace = 41; + optional string php_metadata_namespace = 44; + optional string ruby_package = 45; + repeated UninterpretedOption uninterpreted_option = 999; + + extensions 1000 to max; + + reserved 38; +} + +message MessageOptions { + optional bool message_set_wire_format = 1 [default = false]; + optional bool no_standard_descriptor_accessor = 2 [default = false]; + optional bool deprecated = 3 [default = false]; + optional bool map_entry = 7; + repeated UninterpretedOption uninterpreted_option = 999; + + extensions 1000 to max; + + reserved 8, 9; +} + +message FieldOptions { + optional CType ctype = 1 [default = STRING]; + enum CType { + STRING = 0; + CORD = 1; + STRING_PIECE = 2; + } + + optional bool packed = 2; + + optional JSType jstype = 6 [default = JS_NORMAL]; + enum JSType { + JS_NORMAL = 0; + JS_STRING = 1; + JS_NUMBER = 2; + } + + optional bool lazy = 5 [default = false]; + optional bool deprecated = 3 [default = false]; + optional bool weak = 10 [default = false]; + repeated UninterpretedOption uninterpreted_option = 999; + + extensions 1000 to max; + + reserved 4; +} + +message OneofOptions { + repeated UninterpretedOption uninterpreted_option = 999; + + extensions 1000 to max; +} + +message EnumOptions { + optional bool allow_alias = 2; + optional bool deprecated = 3 [default = false]; + repeated UninterpretedOption uninterpreted_option = 999; + + extensions 1000 to max; + + reserved 5; +} + +message EnumValueOptions { + optional bool deprecated = 1 [default = false]; + repeated UninterpretedOption uninterpreted_option = 999; + + extensions 1000 to max; +} + +message ServiceOptions { + optional bool deprecated = 33 [default = false]; + repeated UninterpretedOption uninterpreted_option = 999; + + extensions 1000 to max; +} + +message MethodOptions { + optional bool deprecated = 33 [default = false]; + + optional IdempotencyLevel idempotency_level = 34 [default = IDEMPOTENCY_UNKNOWN]; + enum IdempotencyLevel { + IDEMPOTENCY_UNKNOWN = 0; + NO_SIDE_EFFECTS = 1; + IDEMPOTENT = 2; + } + + repeated UninterpretedOption uninterpreted_option = 999; + + extensions 1000 to max; +} + +message UninterpretedOption { + repeated NamePart name = 2; + message NamePart { + required string name_part = 1; + required bool is_extension = 2; + } + + optional string identifier_value = 3; + optional uint64 positive_int_value = 4; + optional int64 negative_int_value = 5; + optional double double_value = 6; + optional bytes string_value = 7; + optional string aggregate_value = 8; +} + +message SourceCodeInfo { + repeated Location location = 1; + message Location { + repeated int32 path = 1 [packed = true]; + repeated int32 span = 2 [packed = true]; + optional string leading_comments = 3; + optional string trailing_comments = 4; + repeated string leading_detached_comments = 6; + } +} + +message GeneratedCodeInfo { + repeated Annotation annotation = 1; + message Annotation { + repeated int32 path = 1 [packed = true]; + optional string source_file = 2; + optional int32 begin = 3; + optional int32 end = 4; + } +} diff --git a/google/protobuf/duration.proto b/google/protobuf/duration.proto new file mode 100644 index 0000000..6492685 --- /dev/null +++ b/google/protobuf/duration.proto @@ -0,0 +1,16 @@ +syntax = "proto3"; + +package google.protobuf; + +option csharp_namespace = "Google.Protobuf.WellKnownTypes"; +option objc_class_prefix = "GPB"; +option cc_enable_arenas = true; +option go_package = "github.com/golang/protobuf/ptypes/duration"; +option java_multiple_files = true; +option java_outer_classname = "DurationProto"; +option java_package = "com.google.protobuf"; + +message Duration { + int64 seconds = 1; + int32 nanos = 2; +} diff --git a/google/protobuf/empty.proto b/google/protobuf/empty.proto new file mode 100644 index 0000000..2b0503f --- /dev/null +++ b/google/protobuf/empty.proto @@ -0,0 +1,15 @@ +syntax = "proto3"; + +package google.protobuf; + +option csharp_namespace = "Google.Protobuf.WellKnownTypes"; +option objc_class_prefix = "GPB"; +option cc_enable_arenas = true; +option go_package = "github.com/golang/protobuf/ptypes/empty"; +option java_multiple_files = true; +option java_outer_classname = "EmptyProto"; +option java_package = "com.google.protobuf"; + +message Empty { + +} diff --git a/google/protobuf/field_mask.proto b/google/protobuf/field_mask.proto new file mode 100644 index 0000000..7315ad9 --- /dev/null +++ b/google/protobuf/field_mask.proto @@ -0,0 +1,15 @@ +syntax = "proto3"; + +package google.protobuf; + +option csharp_namespace = "Google.Protobuf.WellKnownTypes"; +option objc_class_prefix = "GPB"; +option cc_enable_arenas = true; +option go_package = "google.golang.org/genproto/protobuf/field_mask;field_mask"; +option java_multiple_files = true; +option java_outer_classname = "FieldMaskProto"; +option java_package = "com.google.protobuf"; + +message FieldMask { + repeated string paths = 1; +} diff --git a/google/protobuf/source_context.proto b/google/protobuf/source_context.proto new file mode 100644 index 0000000..c74b911 --- /dev/null +++ b/google/protobuf/source_context.proto @@ -0,0 +1,14 @@ +syntax = "proto3"; + +package google.protobuf; + +option csharp_namespace = "Google.Protobuf.WellKnownTypes"; +option objc_class_prefix = "GPB"; +option go_package = "google.golang.org/genproto/protobuf/source_context;source_context"; +option java_multiple_files = true; +option java_outer_classname = "SourceContextProto"; +option java_package = "com.google.protobuf"; + +message SourceContext { + string file_name = 1; +} diff --git a/google/protobuf/struct.proto b/google/protobuf/struct.proto new file mode 100644 index 0000000..dfe00af --- /dev/null +++ b/google/protobuf/struct.proto @@ -0,0 +1,34 @@ +syntax = "proto3"; + +package google.protobuf; + +option csharp_namespace = "Google.Protobuf.WellKnownTypes"; +option objc_class_prefix = "GPB"; +option cc_enable_arenas = true; +option go_package = "github.com/golang/protobuf/ptypes/struct;structpb"; +option java_multiple_files = true; +option java_outer_classname = "StructProto"; +option java_package = "com.google.protobuf"; + +message Struct { + map fields = 1; +} + +message Value { + oneof kind { + NullValue null_value = 1; + double number_value = 2; + string string_value = 3; + bool bool_value = 4; + Struct struct_value = 5; + ListValue list_value = 6; + } +} + +message ListValue { + repeated Value values = 1; +} + +enum NullValue { + NULL_VALUE = 0; +} diff --git a/google/protobuf/timestamp.proto b/google/protobuf/timestamp.proto new file mode 100644 index 0000000..50b8fa8 --- /dev/null +++ b/google/protobuf/timestamp.proto @@ -0,0 +1,16 @@ +syntax = "proto3"; + +package google.protobuf; + +option csharp_namespace = "Google.Protobuf.WellKnownTypes"; +option objc_class_prefix = "GPB"; +option cc_enable_arenas = true; +option go_package = "github.com/golang/protobuf/ptypes/timestamp"; +option java_multiple_files = true; +option java_outer_classname = "TimestampProto"; +option java_package = "com.google.protobuf"; + +message Timestamp { + int64 seconds = 1; + int32 nanos = 2; +} diff --git a/google/protobuf/type.proto b/google/protobuf/type.proto new file mode 100644 index 0000000..1587723 --- /dev/null +++ b/google/protobuf/type.proto @@ -0,0 +1,89 @@ +syntax = "proto3"; + +package google.protobuf; + +import "google/protobuf/any.proto"; +import "google/protobuf/source_context.proto"; + +option csharp_namespace = "Google.Protobuf.WellKnownTypes"; +option objc_class_prefix = "GPB"; +option cc_enable_arenas = true; +option go_package = "google.golang.org/genproto/protobuf/ptype;ptype"; +option java_multiple_files = true; +option java_outer_classname = "TypeProto"; +option java_package = "com.google.protobuf"; + +message Type { + string name = 1; + repeated Field fields = 2; + repeated string oneofs = 3; + repeated Option options = 4; + SourceContext source_context = 5; + Syntax syntax = 6; +} + +message Field { + Kind kind = 1; + enum Kind { + TYPE_UNKNOWN = 0; + TYPE_DOUBLE = 1; + TYPE_FLOAT = 2; + TYPE_INT64 = 3; + TYPE_UINT64 = 4; + TYPE_INT32 = 5; + TYPE_FIXED64 = 6; + TYPE_FIXED32 = 7; + TYPE_BOOL = 8; + TYPE_STRING = 9; + TYPE_GROUP = 10; + TYPE_MESSAGE = 11; + TYPE_BYTES = 12; + TYPE_UINT32 = 13; + TYPE_ENUM = 14; + TYPE_SFIXED32 = 15; + TYPE_SFIXED64 = 16; + TYPE_SINT32 = 17; + TYPE_SINT64 = 18; + } + + Cardinality cardinality = 2; + enum Cardinality { + CARDINALITY_UNKNOWN = 0; + CARDINALITY_OPTIONAL = 1; + CARDINALITY_REQUIRED = 2; + CARDINALITY_REPEATED = 3; + } + + int32 number = 3; + string name = 4; + string type_url = 6; + int32 oneof_index = 7; + bool packed = 8; + repeated Option options = 9; + string json_name = 10; + string default_value = 11; +} + +message Enum { + string name = 1; + repeated EnumValue enumvalue = 2; + repeated Option options = 3; + SourceContext source_context = 4; + Syntax syntax = 5; +} + +message EnumValue { + string name = 1; + int32 number = 2; + repeated Option options = 3; +} + +message Option { + string name = 1; + Any value = 2; +} + +enum Syntax { + SYNTAX_PROTO2 = 0; + SYNTAX_PROTO3 = 1; +} diff --git a/google/protobuf/wrappers.proto b/google/protobuf/wrappers.proto new file mode 100644 index 0000000..52b8179 --- /dev/null +++ b/google/protobuf/wrappers.proto @@ -0,0 +1,47 @@ +syntax = "proto3"; + +package google.protobuf; + +option csharp_namespace = "Google.Protobuf.WellKnownTypes"; +option objc_class_prefix = "GPB"; +option cc_enable_arenas = true; +option go_package = "github.com/golang/protobuf/ptypes/wrappers"; +option java_multiple_files = true; +option java_outer_classname = "WrappersProto"; +option java_package = "com.google.protobuf"; + +message DoubleValue { + double value = 1; +} + +message FloatValue { + float value = 1; +} + +message Int64Value { + int64 value = 1; +} + +message UInt64Value { + uint64 value = 1; +} + +message Int32Value { + int32 value = 1; +} + +message UInt32Value { + uint32 value = 1; +} + +message BoolValue { + bool value = 1; +} + +message StringValue { + string value = 1; +} + +message BytesValue { + bytes value = 1; +} diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..e76d2ea --- /dev/null +++ b/requirements.txt @@ -0,0 +1,18 @@ +beautifulsoup4==4.9.1 +betterproto==1.2.5 +certifi==2020.6.20 +chardet==3.0.4 +grpclib==0.4.0 +h2==3.2.0 +hpack==3.0.0 +hyperframe==5.2.0 +idna==2.10 +lxml==4.5.2 +multidict==4.7.6 +requests==2.24.0 +robobrowser==0.5.3 +six==1.15.0 +soupsieve==2.0.1 +stringcase==1.2.0 +urllib3==1.25.10 +Werkzeug==1.0.1 diff --git a/sms_auth_v3.py b/sms_auth_v3.py new file mode 100644 index 0000000..8521954 --- /dev/null +++ b/sms_auth_v3.py @@ -0,0 +1,85 @@ +import requests +import random +import string +import uuid +from authgateway import * +import secrets +from pathlib import Path + + +class SMSAuthException(BaseException): + pass + + +class TinderSMSAuth(object): + + def __init__(self, email=None): + self.installid = ''.join(random.choices(string.ascii_uppercase + string.ascii_lowercase + string.digits, k=11)) + self.session = requests.Session() + self.session.headers.update({"user-agent": "Tinder Android Version 11.23.0"}) + self.url = "https://api.gotinder.com" + self.funnelid = str(uuid.uuid4()) + self.appsessionid = str(uuid.uuid4()) + self.deviceid = secrets.token_hex(8) + self.authtoken = None + self.refreshtoken = None + self.userid = None + self.email = email + if Path("smstoken.txt").exists(): + with open("smstoken.txt", "r") as fh: + tokens = fh.read() + t = tokens.split(",") + self.authtoken = t[0] + self.refreshtoken = t[1] + print("authToken found: " + self.authtoken) + else: + self.login() + + def login(self): + payload = { + "device_id": self.installid, + "experiments": ["default_login_token", "tinder_u_verification_method", "tinder_rules", + "user_interests_available"] + } + self.session.post(self.url + "/v2/buckets", json=payload) + phonenumber = input("phone number (starting with 1, numbers only): ") + messageout = AuthGatewayRequest(Phone(phone=phonenumber)) + seconds = random.uniform(100, 250) + headers = { + 'tinder-version': "11.23.0", 'install-id': self.installid, + 'user-agent': "Tinder Android Version 11.23.0", 'connection': "close", + 'platform-variant': "Google-Play", 'persistent-device-id': self.deviceid, + 'accept-encoding': "gzip, deflate", 'appsflyer-id': "1600144077225-7971032049730563486", + 'platform': "android", 'app-version': "3994", 'os-version': "25", 'app-session-id': self.appsessionid, + 'x-supported-image-formats': "webp", 'funnel-session-id': self.funnelid, + 'app-session-time-elapsed': format(seconds, ".3f"), 'accept-language': "en-US", + 'content-type': "application/x-protobuf" + } + self.session.headers.update(headers) + r = self.session.post(self.url + "/v3/auth/login", data=bytes(messageout)) + response = AuthGatewayResponse().parse(r.content).to_dict() + print(response) + if "validatePhoneOtpState" in response.keys() and response["validatePhoneOtpState"]["smsSent"]: + otpresponse = input("OTP Response from SMS: ") + resp = PhoneOtp(phone=phonenumber, otp=otpresponse) + messageresponse = bytes(AuthGatewayRequest(phone_otp=resp)) + self.session.headers.update({"app-session-time-elapsed": format(seconds + random.uniform(30, 90), ".3f")}) + r = self.session.post(self.url + "/v3/auth/login", data=messageresponse) + response = AuthGatewayResponse().parse(r.content).to_dict() + print(response) + if "loginResult" in response.keys() and "authToken" in response["loginResult"].keys(): + self.refreshtoken = response["loginResult"]["refreshToken"] + self.authtoken = response["loginResult"]["authToken"] + userid = response["userId"] + with open("smstoken.txt", "w") as fh: + fh.write(self.authtoken + "," + self.refreshtoken) + return self.session.headers.update({"X-Auth-Token": self.authtoken}) + else: + raise SMSAuthException + else: + raise SMSAuthException + + +if __name__ == '__main__': + print("This script will use the sms login to obtain the auth token, which will be saved to smstoken.txt") + TinderSMSAuth() \ No newline at end of file From 80e190c13cefd3e03d1e91f0b1b11d2dc9d750a4 Mon Sep 17 00:00:00 2001 From: jim zhou <43537315+jimtje@users.noreply.github.com> Date: Tue, 15 Sep 2020 12:32:05 -0700 Subject: [PATCH 02/23] unnecessary userid --- sms_auth_v3.py | 1 - 1 file changed, 1 deletion(-) diff --git a/sms_auth_v3.py b/sms_auth_v3.py index 8521954..9372bba 100644 --- a/sms_auth_v3.py +++ b/sms_auth_v3.py @@ -70,7 +70,6 @@ def login(self): if "loginResult" in response.keys() and "authToken" in response["loginResult"].keys(): self.refreshtoken = response["loginResult"]["refreshToken"] self.authtoken = response["loginResult"]["authToken"] - userid = response["userId"] with open("smstoken.txt", "w") as fh: fh.write(self.authtoken + "," + self.refreshtoken) return self.session.headers.update({"X-Auth-Token": self.authtoken}) From 17d59ffe1b1b3b121dd56fb2544004b389ce3c84 Mon Sep 17 00:00:00 2001 From: jim zhou <43537315+jimtje@users.noreply.github.com> Date: Tue, 15 Sep 2020 15:29:11 -0700 Subject: [PATCH 03/23] added prompts for additional email validation --- sms_auth_v3.py | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/sms_auth_v3.py b/sms_auth_v3.py index 9372bba..b5f8037 100644 --- a/sms_auth_v3.py +++ b/sms_auth_v3.py @@ -67,6 +67,15 @@ def login(self): r = self.session.post(self.url + "/v3/auth/login", data=messageresponse) response = AuthGatewayResponse().parse(r.content).to_dict() print(response) + if "validateEmailOtpState" in response.keys(): + emailoptresponse = input("Check your email and input the verification code just sent to you: ") + refreshtoken = response["validateEmailOtpState"]["refreshToken"] + email = input("Input your email: ") + resp = bytes(AuthGatewayRequest( + email_otp=EmailOtp(otp=emailoptresponse, email=email, refresh_token=refreshtoken))) + r = self.session.post(self.url + "/v3/auth/login", data=resp) + response = AuthGatewayResponse().parse(r.content).to_dict() + print(response) if "loginResult" in response.keys() and "authToken" in response["loginResult"].keys(): self.refreshtoken = response["loginResult"]["refreshToken"] self.authtoken = response["loginResult"]["authToken"] From 28a5e8712d2c0c2aee05463c86258bbdc8656630 Mon Sep 17 00:00:00 2001 From: jim zhou <43537315+jimtje@users.noreply.github.com> Date: Tue, 15 Sep 2020 18:46:56 -0700 Subject: [PATCH 04/23] gitignore --- .gitignore | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/.gitignore b/.gitignore index d1f11ae..5a8d5de 100644 --- a/.gitignore +++ b/.gitignore @@ -6,3 +6,11 @@ __pycache__ find.py *.log *.egg-info + +.idea/ + +smstoken.txt + +google/protobuf/.DS_Store + +google/.DS_Store From 6c2e5894de10514e04479cb684b92aa6b31a8a45 Mon Sep 17 00:00:00 2001 From: jim zhou <43537315+jimtje@users.noreply.github.com> Date: Tue, 22 Sep 2020 02:22:17 -0700 Subject: [PATCH 05/23] added extraneous folder to .gitignore --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index 5a8d5de..c889d95 100644 --- a/.gitignore +++ b/.gitignore @@ -14,3 +14,4 @@ smstoken.txt google/protobuf/.DS_Store google/.DS_Store +/google/ From c1283c40a74c72f91c6047b26e7ec31b0bbfd5cf Mon Sep 17 00:00:00 2001 From: jim zhou <43537315+jimtje@users.noreply.github.com> Date: Tue, 22 Sep 2020 03:55:19 -0700 Subject: [PATCH 06/23] remove extraneous .proto files --- google/protobuf/any.proto | 15 -- google/protobuf/api.proto | 38 ---- google/protobuf/compiler/plugin.proto | 34 --- google/protobuf/descriptor.proto | 298 -------------------------- google/protobuf/duration.proto | 16 -- google/protobuf/empty.proto | 15 -- google/protobuf/field_mask.proto | 15 -- google/protobuf/source_context.proto | 14 -- google/protobuf/struct.proto | 34 --- google/protobuf/timestamp.proto | 16 -- google/protobuf/type.proto | 89 -------- google/protobuf/wrappers.proto | 47 ---- 12 files changed, 631 deletions(-) delete mode 100644 google/protobuf/any.proto delete mode 100644 google/protobuf/api.proto delete mode 100644 google/protobuf/compiler/plugin.proto delete mode 100644 google/protobuf/descriptor.proto delete mode 100644 google/protobuf/duration.proto delete mode 100644 google/protobuf/empty.proto delete mode 100644 google/protobuf/field_mask.proto delete mode 100644 google/protobuf/source_context.proto delete mode 100644 google/protobuf/struct.proto delete mode 100644 google/protobuf/timestamp.proto delete mode 100644 google/protobuf/type.proto delete mode 100644 google/protobuf/wrappers.proto diff --git a/google/protobuf/any.proto b/google/protobuf/any.proto deleted file mode 100644 index 441ae1b..0000000 --- a/google/protobuf/any.proto +++ /dev/null @@ -1,15 +0,0 @@ -syntax = "proto3"; - -package google.protobuf; - -option csharp_namespace = "Google.Protobuf.WellKnownTypes"; -option objc_class_prefix = "GPB"; -option go_package = "github.com/golang/protobuf/ptypes/any"; -option java_multiple_files = true; -option java_outer_classname = "AnyProto"; -option java_package = "com.google.protobuf"; - -message Any { - string type_url = 1; - bytes value = 2; -} diff --git a/google/protobuf/api.proto b/google/protobuf/api.proto deleted file mode 100644 index f9b60e0..0000000 --- a/google/protobuf/api.proto +++ /dev/null @@ -1,38 +0,0 @@ -syntax = "proto3"; - -package google.protobuf; - -import "google/protobuf/source_context.proto"; -import "google/protobuf/type.proto"; - -option csharp_namespace = "Google.Protobuf.WellKnownTypes"; -option objc_class_prefix = "GPB"; -option go_package = "google.golang.org/genproto/protobuf/api;api"; -option java_multiple_files = true; -option java_outer_classname = "ApiProto"; -option java_package = "com.google.protobuf"; - -message Api { - string name = 1; - repeated Method methods = 2; - repeated Option options = 3; - string version = 4; - SourceContext source_context = 5; - repeated Mixin mixins = 6; - Syntax syntax = 7; -} - -message Method { - string name = 1; - string request_type_url = 2; - bool request_streaming = 3; - string response_type_url = 4; - bool response_streaming = 5; - repeated Option options = 6; - Syntax syntax = 7; -} - -message Mixin { - string name = 1; - string root = 2; -} diff --git a/google/protobuf/compiler/plugin.proto b/google/protobuf/compiler/plugin.proto deleted file mode 100644 index 61ee7f4..0000000 --- a/google/protobuf/compiler/plugin.proto +++ /dev/null @@ -1,34 +0,0 @@ -syntax = "proto2"; - -package google.protobuf.compiler; - -import "google/protobuf/descriptor.proto"; - -option go_package = "github.com/golang/protobuf/protoc-gen-go/plugin;plugin_go"; -option java_outer_classname = "PluginProtos"; -option java_package = "com.google.protobuf.compiler"; - -message Version { - optional int32 major = 1; - optional int32 minor = 2; - optional int32 patch = 3; - optional string suffix = 4; -} - -message CodeGeneratorRequest { - repeated string file_to_generate = 1; - optional string parameter = 2; - repeated FileDescriptorProto proto_file = 15; - optional Version compiler_version = 3; -} - -message CodeGeneratorResponse { - optional string error = 1; - - repeated File file = 15; - message File { - optional string name = 1; - optional string insertion_point = 2; - optional string content = 15; - } -} diff --git a/google/protobuf/descriptor.proto b/google/protobuf/descriptor.proto deleted file mode 100644 index 6003bb8..0000000 --- a/google/protobuf/descriptor.proto +++ /dev/null @@ -1,298 +0,0 @@ -syntax = "proto2"; - -package google.protobuf; - -option csharp_namespace = "Google.Protobuf.Reflection"; -option objc_class_prefix = "GPB"; -option cc_enable_arenas = true; -option go_package = "github.com/golang/protobuf/protoc-gen-go/descriptor;descriptor"; -option optimize_for = SPEED; -option java_outer_classname = "DescriptorProtos"; -option java_package = "com.google.protobuf"; - -message FileDescriptorSet { - repeated FileDescriptorProto file = 1; -} - -message FileDescriptorProto { - optional string name = 1; - optional string package = 2; - repeated string dependency = 3; - repeated int32 public_dependency = 10; - repeated int32 weak_dependency = 11; - repeated DescriptorProto message_type = 4; - repeated EnumDescriptorProto enum_type = 5; - repeated ServiceDescriptorProto service = 6; - repeated FieldDescriptorProto extension = 7; - optional FileOptions options = 8; - optional SourceCodeInfo source_code_info = 9; - optional string syntax = 12; -} - -message DescriptorProto { - optional string name = 1; - repeated FieldDescriptorProto field = 2; - repeated FieldDescriptorProto extension = 6; - repeated DescriptorProto nested_type = 3; - repeated EnumDescriptorProto enum_type = 4; - - repeated ExtensionRange extension_range = 5; - message ExtensionRange { - optional int32 start = 1; - optional int32 end = 2; - optional ExtensionRangeOptions options = 3; - } - - repeated OneofDescriptorProto oneof_decl = 8; - optional MessageOptions options = 7; - - repeated ReservedRange reserved_range = 9; - message ReservedRange { - optional int32 start = 1; - optional int32 end = 2; - } - - repeated string reserved_name = 10; -} - -message ExtensionRangeOptions { - repeated UninterpretedOption uninterpreted_option = 999; - - extensions 1000 to max; -} - -message FieldDescriptorProto { - optional string name = 1; - optional int32 number = 3; - - optional Label label = 4; - enum Label { - LABEL_OPTIONAL = 1; - LABEL_REQUIRED = 2; - LABEL_REPEATED = 3; - } - - optional Type type = 5; - enum Type { - TYPE_DOUBLE = 1; - TYPE_FLOAT = 2; - TYPE_INT64 = 3; - TYPE_UINT64 = 4; - TYPE_INT32 = 5; - TYPE_FIXED64 = 6; - TYPE_FIXED32 = 7; - TYPE_BOOL = 8; - TYPE_STRING = 9; - TYPE_GROUP = 10; - TYPE_MESSAGE = 11; - TYPE_BYTES = 12; - TYPE_UINT32 = 13; - TYPE_ENUM = 14; - TYPE_SFIXED32 = 15; - TYPE_SFIXED64 = 16; - TYPE_SINT32 = 17; - TYPE_SINT64 = 18; - } - - optional string type_name = 6; - optional string extendee = 2; - optional string default_value = 7; - optional int32 oneof_index = 9; - optional string json_name = 10; - optional FieldOptions options = 8; -} - -message OneofDescriptorProto { - optional string name = 1; - optional OneofOptions options = 2; -} - -message EnumDescriptorProto { - optional string name = 1; - repeated EnumValueDescriptorProto value = 2; - optional EnumOptions options = 3; - - repeated EnumReservedRange reserved_range = 4; - message EnumReservedRange { - optional int32 start = 1; - optional int32 end = 2; - } - - repeated string reserved_name = 5; -} - -message EnumValueDescriptorProto { - optional string name = 1; - optional int32 number = 2; - optional EnumValueOptions options = 3; -} - -message ServiceDescriptorProto { - optional string name = 1; - repeated MethodDescriptorProto method = 2; - optional ServiceOptions options = 3; -} - -message MethodDescriptorProto { - optional string name = 1; - optional string input_type = 2; - optional string output_type = 3; - optional MethodOptions options = 4; - optional bool client_streaming = 5 [default = false]; - optional bool server_streaming = 6 [default = false]; -} - -message FileOptions { - optional string java_package = 1; - optional string java_outer_classname = 8; - optional bool java_multiple_files = 10 [default = false]; - optional bool java_generate_equals_and_hash = 20 [deprecated = true]; - optional bool java_string_check_utf8 = 27 [default = false]; - - optional OptimizeMode optimize_for = 9 [default = SPEED]; - enum OptimizeMode { - SPEED = 1; - CODE_SIZE = 2; - LITE_RUNTIME = 3; - } - - optional string go_package = 11; - optional bool cc_generic_services = 16 [default = false]; - optional bool java_generic_services = 17 [default = false]; - optional bool py_generic_services = 18 [default = false]; - optional bool php_generic_services = 42 [default = false]; - optional bool deprecated = 23 [default = false]; - optional bool cc_enable_arenas = 31 [default = false]; - optional string objc_class_prefix = 36; - optional string csharp_namespace = 37; - optional string swift_prefix = 39; - optional string php_class_prefix = 40; - optional string php_namespace = 41; - optional string php_metadata_namespace = 44; - optional string ruby_package = 45; - repeated UninterpretedOption uninterpreted_option = 999; - - extensions 1000 to max; - - reserved 38; -} - -message MessageOptions { - optional bool message_set_wire_format = 1 [default = false]; - optional bool no_standard_descriptor_accessor = 2 [default = false]; - optional bool deprecated = 3 [default = false]; - optional bool map_entry = 7; - repeated UninterpretedOption uninterpreted_option = 999; - - extensions 1000 to max; - - reserved 8, 9; -} - -message FieldOptions { - optional CType ctype = 1 [default = STRING]; - enum CType { - STRING = 0; - CORD = 1; - STRING_PIECE = 2; - } - - optional bool packed = 2; - - optional JSType jstype = 6 [default = JS_NORMAL]; - enum JSType { - JS_NORMAL = 0; - JS_STRING = 1; - JS_NUMBER = 2; - } - - optional bool lazy = 5 [default = false]; - optional bool deprecated = 3 [default = false]; - optional bool weak = 10 [default = false]; - repeated UninterpretedOption uninterpreted_option = 999; - - extensions 1000 to max; - - reserved 4; -} - -message OneofOptions { - repeated UninterpretedOption uninterpreted_option = 999; - - extensions 1000 to max; -} - -message EnumOptions { - optional bool allow_alias = 2; - optional bool deprecated = 3 [default = false]; - repeated UninterpretedOption uninterpreted_option = 999; - - extensions 1000 to max; - - reserved 5; -} - -message EnumValueOptions { - optional bool deprecated = 1 [default = false]; - repeated UninterpretedOption uninterpreted_option = 999; - - extensions 1000 to max; -} - -message ServiceOptions { - optional bool deprecated = 33 [default = false]; - repeated UninterpretedOption uninterpreted_option = 999; - - extensions 1000 to max; -} - -message MethodOptions { - optional bool deprecated = 33 [default = false]; - - optional IdempotencyLevel idempotency_level = 34 [default = IDEMPOTENCY_UNKNOWN]; - enum IdempotencyLevel { - IDEMPOTENCY_UNKNOWN = 0; - NO_SIDE_EFFECTS = 1; - IDEMPOTENT = 2; - } - - repeated UninterpretedOption uninterpreted_option = 999; - - extensions 1000 to max; -} - -message UninterpretedOption { - repeated NamePart name = 2; - message NamePart { - required string name_part = 1; - required bool is_extension = 2; - } - - optional string identifier_value = 3; - optional uint64 positive_int_value = 4; - optional int64 negative_int_value = 5; - optional double double_value = 6; - optional bytes string_value = 7; - optional string aggregate_value = 8; -} - -message SourceCodeInfo { - repeated Location location = 1; - message Location { - repeated int32 path = 1 [packed = true]; - repeated int32 span = 2 [packed = true]; - optional string leading_comments = 3; - optional string trailing_comments = 4; - repeated string leading_detached_comments = 6; - } -} - -message GeneratedCodeInfo { - repeated Annotation annotation = 1; - message Annotation { - repeated int32 path = 1 [packed = true]; - optional string source_file = 2; - optional int32 begin = 3; - optional int32 end = 4; - } -} diff --git a/google/protobuf/duration.proto b/google/protobuf/duration.proto deleted file mode 100644 index 6492685..0000000 --- a/google/protobuf/duration.proto +++ /dev/null @@ -1,16 +0,0 @@ -syntax = "proto3"; - -package google.protobuf; - -option csharp_namespace = "Google.Protobuf.WellKnownTypes"; -option objc_class_prefix = "GPB"; -option cc_enable_arenas = true; -option go_package = "github.com/golang/protobuf/ptypes/duration"; -option java_multiple_files = true; -option java_outer_classname = "DurationProto"; -option java_package = "com.google.protobuf"; - -message Duration { - int64 seconds = 1; - int32 nanos = 2; -} diff --git a/google/protobuf/empty.proto b/google/protobuf/empty.proto deleted file mode 100644 index 2b0503f..0000000 --- a/google/protobuf/empty.proto +++ /dev/null @@ -1,15 +0,0 @@ -syntax = "proto3"; - -package google.protobuf; - -option csharp_namespace = "Google.Protobuf.WellKnownTypes"; -option objc_class_prefix = "GPB"; -option cc_enable_arenas = true; -option go_package = "github.com/golang/protobuf/ptypes/empty"; -option java_multiple_files = true; -option java_outer_classname = "EmptyProto"; -option java_package = "com.google.protobuf"; - -message Empty { - -} diff --git a/google/protobuf/field_mask.proto b/google/protobuf/field_mask.proto deleted file mode 100644 index 7315ad9..0000000 --- a/google/protobuf/field_mask.proto +++ /dev/null @@ -1,15 +0,0 @@ -syntax = "proto3"; - -package google.protobuf; - -option csharp_namespace = "Google.Protobuf.WellKnownTypes"; -option objc_class_prefix = "GPB"; -option cc_enable_arenas = true; -option go_package = "google.golang.org/genproto/protobuf/field_mask;field_mask"; -option java_multiple_files = true; -option java_outer_classname = "FieldMaskProto"; -option java_package = "com.google.protobuf"; - -message FieldMask { - repeated string paths = 1; -} diff --git a/google/protobuf/source_context.proto b/google/protobuf/source_context.proto deleted file mode 100644 index c74b911..0000000 --- a/google/protobuf/source_context.proto +++ /dev/null @@ -1,14 +0,0 @@ -syntax = "proto3"; - -package google.protobuf; - -option csharp_namespace = "Google.Protobuf.WellKnownTypes"; -option objc_class_prefix = "GPB"; -option go_package = "google.golang.org/genproto/protobuf/source_context;source_context"; -option java_multiple_files = true; -option java_outer_classname = "SourceContextProto"; -option java_package = "com.google.protobuf"; - -message SourceContext { - string file_name = 1; -} diff --git a/google/protobuf/struct.proto b/google/protobuf/struct.proto deleted file mode 100644 index dfe00af..0000000 --- a/google/protobuf/struct.proto +++ /dev/null @@ -1,34 +0,0 @@ -syntax = "proto3"; - -package google.protobuf; - -option csharp_namespace = "Google.Protobuf.WellKnownTypes"; -option objc_class_prefix = "GPB"; -option cc_enable_arenas = true; -option go_package = "github.com/golang/protobuf/ptypes/struct;structpb"; -option java_multiple_files = true; -option java_outer_classname = "StructProto"; -option java_package = "com.google.protobuf"; - -message Struct { - map fields = 1; -} - -message Value { - oneof kind { - NullValue null_value = 1; - double number_value = 2; - string string_value = 3; - bool bool_value = 4; - Struct struct_value = 5; - ListValue list_value = 6; - } -} - -message ListValue { - repeated Value values = 1; -} - -enum NullValue { - NULL_VALUE = 0; -} diff --git a/google/protobuf/timestamp.proto b/google/protobuf/timestamp.proto deleted file mode 100644 index 50b8fa8..0000000 --- a/google/protobuf/timestamp.proto +++ /dev/null @@ -1,16 +0,0 @@ -syntax = "proto3"; - -package google.protobuf; - -option csharp_namespace = "Google.Protobuf.WellKnownTypes"; -option objc_class_prefix = "GPB"; -option cc_enable_arenas = true; -option go_package = "github.com/golang/protobuf/ptypes/timestamp"; -option java_multiple_files = true; -option java_outer_classname = "TimestampProto"; -option java_package = "com.google.protobuf"; - -message Timestamp { - int64 seconds = 1; - int32 nanos = 2; -} diff --git a/google/protobuf/type.proto b/google/protobuf/type.proto deleted file mode 100644 index 1587723..0000000 --- a/google/protobuf/type.proto +++ /dev/null @@ -1,89 +0,0 @@ -syntax = "proto3"; - -package google.protobuf; - -import "google/protobuf/any.proto"; -import "google/protobuf/source_context.proto"; - -option csharp_namespace = "Google.Protobuf.WellKnownTypes"; -option objc_class_prefix = "GPB"; -option cc_enable_arenas = true; -option go_package = "google.golang.org/genproto/protobuf/ptype;ptype"; -option java_multiple_files = true; -option java_outer_classname = "TypeProto"; -option java_package = "com.google.protobuf"; - -message Type { - string name = 1; - repeated Field fields = 2; - repeated string oneofs = 3; - repeated Option options = 4; - SourceContext source_context = 5; - Syntax syntax = 6; -} - -message Field { - Kind kind = 1; - enum Kind { - TYPE_UNKNOWN = 0; - TYPE_DOUBLE = 1; - TYPE_FLOAT = 2; - TYPE_INT64 = 3; - TYPE_UINT64 = 4; - TYPE_INT32 = 5; - TYPE_FIXED64 = 6; - TYPE_FIXED32 = 7; - TYPE_BOOL = 8; - TYPE_STRING = 9; - TYPE_GROUP = 10; - TYPE_MESSAGE = 11; - TYPE_BYTES = 12; - TYPE_UINT32 = 13; - TYPE_ENUM = 14; - TYPE_SFIXED32 = 15; - TYPE_SFIXED64 = 16; - TYPE_SINT32 = 17; - TYPE_SINT64 = 18; - } - - Cardinality cardinality = 2; - enum Cardinality { - CARDINALITY_UNKNOWN = 0; - CARDINALITY_OPTIONAL = 1; - CARDINALITY_REQUIRED = 2; - CARDINALITY_REPEATED = 3; - } - - int32 number = 3; - string name = 4; - string type_url = 6; - int32 oneof_index = 7; - bool packed = 8; - repeated Option options = 9; - string json_name = 10; - string default_value = 11; -} - -message Enum { - string name = 1; - repeated EnumValue enumvalue = 2; - repeated Option options = 3; - SourceContext source_context = 4; - Syntax syntax = 5; -} - -message EnumValue { - string name = 1; - int32 number = 2; - repeated Option options = 3; -} - -message Option { - string name = 1; - Any value = 2; -} - -enum Syntax { - SYNTAX_PROTO2 = 0; - SYNTAX_PROTO3 = 1; -} diff --git a/google/protobuf/wrappers.proto b/google/protobuf/wrappers.proto deleted file mode 100644 index 52b8179..0000000 --- a/google/protobuf/wrappers.proto +++ /dev/null @@ -1,47 +0,0 @@ -syntax = "proto3"; - -package google.protobuf; - -option csharp_namespace = "Google.Protobuf.WellKnownTypes"; -option objc_class_prefix = "GPB"; -option cc_enable_arenas = true; -option go_package = "github.com/golang/protobuf/ptypes/wrappers"; -option java_multiple_files = true; -option java_outer_classname = "WrappersProto"; -option java_package = "com.google.protobuf"; - -message DoubleValue { - double value = 1; -} - -message FloatValue { - float value = 1; -} - -message Int64Value { - int64 value = 1; -} - -message UInt64Value { - uint64 value = 1; -} - -message Int32Value { - int32 value = 1; -} - -message UInt32Value { - uint32 value = 1; -} - -message BoolValue { - bool value = 1; -} - -message StringValue { - string value = 1; -} - -message BytesValue { - bytes value = 1; -} From 47e66d8d88d5dbbf9a36fd495d325e16b3dc222b Mon Sep 17 00:00:00 2001 From: jim zhou <43537315+jimtje@users.noreply.github.com> Date: Mon, 28 Sep 2020 14:20:22 -0700 Subject: [PATCH 07/23] bump version, add smstoken.txt note --- sms_auth_v3.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/sms_auth_v3.py b/sms_auth_v3.py index b5f8037..5eb2e68 100644 --- a/sms_auth_v3.py +++ b/sms_auth_v3.py @@ -26,6 +26,7 @@ def __init__(self, email=None): self.userid = None self.email = email if Path("smstoken.txt").exists(): + print("smstoken.txt found, if you wish to auth again, delete smstoken.txt") with open("smstoken.txt", "r") as fh: tokens = fh.read() t = tokens.split(",") @@ -46,11 +47,11 @@ def login(self): messageout = AuthGatewayRequest(Phone(phone=phonenumber)) seconds = random.uniform(100, 250) headers = { - 'tinder-version': "11.23.0", 'install-id': self.installid, - 'user-agent': "Tinder Android Version 11.23.0", 'connection': "close", + 'tinder-version': "11.24.0", 'install-id': self.installid, + 'user-agent': "Tinder Android Version 11.24.0", 'connection': "close", 'platform-variant': "Google-Play", 'persistent-device-id': self.deviceid, 'accept-encoding': "gzip, deflate", 'appsflyer-id': "1600144077225-7971032049730563486", - 'platform': "android", 'app-version': "3994", 'os-version': "25", 'app-session-id': self.appsessionid, + 'platform': "android", 'app-version': "4023", 'os-version': "25", 'app-session-id': self.appsessionid, 'x-supported-image-formats': "webp", 'funnel-session-id': self.funnelid, 'app-session-time-elapsed': format(seconds, ".3f"), 'accept-language': "en-US", 'content-type': "application/x-protobuf" From faf8ce056e7dc3d47a232175a27829310f21af5c Mon Sep 17 00:00:00 2001 From: jim zhou <43537315+jimtje@users.noreply.github.com> Date: Mon, 28 Sep 2020 18:52:27 -0700 Subject: [PATCH 08/23] added refresh token usage, allows for commandline entry of email --- sms_auth_v3.py | 102 +++++++++++++++++++++++++++++++------------------ 1 file changed, 65 insertions(+), 37 deletions(-) diff --git a/sms_auth_v3.py b/sms_auth_v3.py index 5eb2e68..57fe53a 100644 --- a/sms_auth_v3.py +++ b/sms_auth_v3.py @@ -5,6 +5,7 @@ from authgateway import * import secrets from pathlib import Path +import sys class SMSAuthException(BaseException): @@ -16,7 +17,7 @@ class TinderSMSAuth(object): def __init__(self, email=None): self.installid = ''.join(random.choices(string.ascii_uppercase + string.ascii_lowercase + string.digits, k=11)) self.session = requests.Session() - self.session.headers.update({"user-agent": "Tinder Android Version 11.23.0"}) + self.session.headers.update({"user-agent": "Tinder Android Version 11.24.0"}) self.url = "https://api.gotinder.com" self.funnelid = str(uuid.uuid4()) self.appsessionid = str(uuid.uuid4()) @@ -25,16 +26,58 @@ def __init__(self, email=None): self.refreshtoken = None self.userid = None self.email = email + self.phonenumber = None if Path("smstoken.txt").exists(): - print("smstoken.txt found, if you wish to auth again, delete smstoken.txt") + print("smstoken.txt found, if you wish to auth again from scratch, delete smstoken.txt") with open("smstoken.txt", "r") as fh: tokens = fh.read() t = tokens.split(",") self.authtoken = t[0] self.refreshtoken = t[1] print("authToken found: " + self.authtoken) + self.login() + + def _postloginreq(self, body, headers=None): + if headers is not None: + self.session.headers.update(headers) + r = self.session.post(self.url + "/v3/auth/login", data=bytes(body)) + response = AuthGatewayResponse().parse(r.content).to_dict() + return response + + def loginwrapper(self, body, seconds, headers=None): + response = self._postloginreq(body, headers) + print(response) + if "validatePhoneOtpState" in response.keys() and response["validatePhoneOtpState"]["smsSent"]: + otpresponse = input("OTP Response from SMS: ") + if self.refreshtoken is not None: + resp = PhoneOtp(phone=self.phonenumber, otp=otpresponse, refresh_token=self.refreshtoken) + else: + resp = PhoneOtp(phone=self.phonenumber, otp=otpresponse) + messageresponse = AuthGatewayRequest(phone_otp=resp) + seconds += random.uniform(30, 90) + header_timer = {"app-session-time-elapsed": format(seconds, ".3f")} + return self.loginwrapper(messageresponse, seconds, header_timer) + elif "validateEmailOtpState" in response.keys() and response["validateEmailOtpState"]["emailSent"]: + emailoptresponse = input("Check your email and input the verification code just sent to you: ") + refreshtoken = response["validateEmailOtpState"]["refreshToken"] + if self.email is None: + self.email = input("Input your email: ") + messageresponse = AuthGatewayRequest(email_otp=EmailOtp(otp=emailoptresponse, email=self.email, refresh_token=refreshtoken)) + seconds += random.uniform(30, 90) + header_timer = {"app-session-time-elapsed": format(seconds, ".3f")} + return self.loginwrapper(messageresponse, seconds, header_timer) + elif "error" in response.keys() and response["error"]["message"] == 'INVALID_REFRESH_TOKEN': + print("Refresh token error, restarting auth") + phonenumber = input("phone number (starting with 1, numbers only): ") + self.phonenumber = phonenumber + messageresponse = AuthGatewayRequest(phone=Phone(phone=self.phonenumber)) + seconds += random.uniform(30, 90) + header_timer = {"app-session-time-elapsed": format(seconds, ".3f")} + return self.loginwrapper(messageresponse, seconds, header_timer) + elif "loginResult" in response.keys() and "authToken" in response["loginResult"].keys(): + return response else: - self.login() + raise SMSAuthException def login(self): payload = { @@ -43,8 +86,13 @@ def login(self): "user_interests_available"] } self.session.post(self.url + "/v2/buckets", json=payload) - phonenumber = input("phone number (starting with 1, numbers only): ") - messageout = AuthGatewayRequest(Phone(phone=phonenumber)) + if self.refreshtoken is not None: + print("Attempting to refresh auth token with saved refresh token") + messageout = AuthGatewayRequest(refresh_auth=RefreshAuth(refresh_token=self.refreshtoken)) + else: + phonenumber = input("phone number (starting with 1, numbers only): ") + self.phonenumber = phonenumber + messageout = AuthGatewayRequest(phone=Phone(phone=self.phonenumber)) seconds = random.uniform(100, 250) headers = { 'tinder-version': "11.24.0", 'install-id': self.installid, @@ -56,39 +104,19 @@ def login(self): 'app-session-time-elapsed': format(seconds, ".3f"), 'accept-language': "en-US", 'content-type': "application/x-protobuf" } - self.session.headers.update(headers) - r = self.session.post(self.url + "/v3/auth/login", data=bytes(messageout)) - response = AuthGatewayResponse().parse(r.content).to_dict() - print(response) - if "validatePhoneOtpState" in response.keys() and response["validatePhoneOtpState"]["smsSent"]: - otpresponse = input("OTP Response from SMS: ") - resp = PhoneOtp(phone=phonenumber, otp=otpresponse) - messageresponse = bytes(AuthGatewayRequest(phone_otp=resp)) - self.session.headers.update({"app-session-time-elapsed": format(seconds + random.uniform(30, 90), ".3f")}) - r = self.session.post(self.url + "/v3/auth/login", data=messageresponse) - response = AuthGatewayResponse().parse(r.content).to_dict() - print(response) - if "validateEmailOtpState" in response.keys(): - emailoptresponse = input("Check your email and input the verification code just sent to you: ") - refreshtoken = response["validateEmailOtpState"]["refreshToken"] - email = input("Input your email: ") - resp = bytes(AuthGatewayRequest( - email_otp=EmailOtp(otp=emailoptresponse, email=email, refresh_token=refreshtoken))) - r = self.session.post(self.url + "/v3/auth/login", data=resp) - response = AuthGatewayResponse().parse(r.content).to_dict() - print(response) - if "loginResult" in response.keys() and "authToken" in response["loginResult"].keys(): - self.refreshtoken = response["loginResult"]["refreshToken"] - self.authtoken = response["loginResult"]["authToken"] - with open("smstoken.txt", "w") as fh: - fh.write(self.authtoken + "," + self.refreshtoken) - return self.session.headers.update({"X-Auth-Token": self.authtoken}) - else: - raise SMSAuthException - else: - raise SMSAuthException + response = self.loginwrapper(messageout, seconds, headers) + self.refreshtoken = response["loginResult"]["refreshToken"] + self.authtoken = response["loginResult"]["authToken"] + self.session.headers.update({"X-AUTH-TOKEN": self.authtoken}) + with open("smstoken.txt", "w") as fh: + fh.write(self.authtoken + "," + self.refreshtoken) + print("Auth token saved to smstoken.txt") if __name__ == '__main__': print("This script will use the sms login to obtain the auth token, which will be saved to smstoken.txt") - TinderSMSAuth() \ No newline at end of file + if len(sys.argv) > 1: + emailaddy = sys.argv[1] + else: + emailaddy = None + TinderSMSAuth(email=emailaddy) \ No newline at end of file From 4efc53ce24bc22c09d6bb4ec5ae877ed27c67c48 Mon Sep 17 00:00:00 2001 From: jim zhou <43537315+jimtje@users.noreply.github.com> Date: Sat, 17 Apr 2021 08:12:24 -0700 Subject: [PATCH 09/23] updated authgateway, fixed handling of refresh token --- .gitignore | 2 + authgateway.proto | 195 ++++++++++++++++------------ authgateway.py | 316 +++++++++++++++++++++++++++++++--------------- sms_auth_v3.py | 25 +++- 4 files changed, 342 insertions(+), 196 deletions(-) diff --git a/.gitignore b/.gitignore index c889d95..ab1faa8 100644 --- a/.gitignore +++ b/.gitignore @@ -15,3 +15,5 @@ google/protobuf/.DS_Store google/.DS_Store /google/ + +.DS_Store diff --git a/authgateway.proto b/authgateway.proto index 6fc1a90..9c9426b 100644 --- a/authgateway.proto +++ b/authgateway.proto @@ -8,87 +8,11 @@ import "google/protobuf/timestamp.proto"; option java_multiple_files = true; option java_package = "com.tinder.generated.model.services.shared.authgateway"; -message FacebookToken { - string external_token = 1; - google.protobuf.StringValue refresh_token = 2; -} - -message Phone { - string phone = 1; - google.protobuf.StringValue refresh_token = 2; -} - -message PhoneOtpResend { - google.protobuf.StringValue phone = 1; - google.protobuf.StringValue refresh_token = 2; -} - -message PhoneOtp { - google.protobuf.StringValue phone = 1; - string otp = 2; - google.protobuf.StringValue refresh_token = 3; -} - -message Email { - string email = 1; - google.protobuf.StringValue refresh_token = 2; - google.protobuf.BoolValue marketing_opt_in = 3; -} - -message EmailOtpResend { - google.protobuf.StringValue email = 1; - google.protobuf.StringValue refresh_token = 2; -} - -message GoogleToken { - string external_token = 1; - google.protobuf.StringValue refresh_token = 2; - google.protobuf.BoolValue marketing_opt_in = 3; - google.protobuf.BoolValue user_behavior = 4; -} - -message EmailOtp { - google.protobuf.StringValue email = 1; - string otp = 2; - google.protobuf.StringValue refresh_token = 3; -} - -message AppleToken { - string external_token = 1; - google.protobuf.StringValue refresh_token = 2; - google.protobuf.StringValue raw_nonce = 3; -} - -message GetInitialState { - google.protobuf.StringValue refresh_token = 1; -} - -message RefreshAuth { - string refresh_token = 1; -} - -message DismissSocialConnectionList { - string refresh_token = 1; -} - -message AuthGatewayRequest { - oneof factor { - Phone phone = 1; - PhoneOtp phone_otp = 2; - Email email = 3; - GoogleToken google_token = 4; - EmailOtp email_otp = 5; - FacebookToken facebook_token = 6; - PhoneOtpResend phone_otp_resend = 7; - EmailOtpResend email_otp_resend = 8; - GetInitialState get_initial_state = 9; - RefreshAuth refresh_auth = 10; - AppleToken apple_token = 11; - DismissSocialConnectionList dismiss_social_connection_list = 12; - } +message MetaProto { + google.protobuf.Timestamp upstream_time = 1; + google.protobuf.Timestamp start_time = 2; } - message GetPhoneState { google.protobuf.StringValue refresh_token = 1; } @@ -126,6 +50,7 @@ message ValidateEmailOtpState { message OnboardingState { string refresh_token = 1; string onboarding_token = 2; + google.protobuf.StringValue user_id = 3; } message LoginResult { @@ -163,6 +88,10 @@ message SocialConnectionList { repeated SocialConnection connections = 2; } +message ValidateEmailMagicLinkOtpState { + +} + message AuthGatewayResponse { MetaProto meta = 1; ErrorProto error = 2; @@ -176,8 +105,111 @@ message AuthGatewayResponse { LoginResult login_result = 8; SocialConnectionList social_connection_list = 9; AppleAccountNotFound apple_account_not_found = 10; + ValidateEmailMagicLinkOtpState validate_email_magic_link_otp_state = 11; + } +} + +message FacebookToken { + string external_token = 1; + google.protobuf.StringValue refresh_token = 2; +} + +message Phone { + string phone = 1; + google.protobuf.StringValue refresh_token = 2; + + oneof check { + google.protobuf.StringValue captcha_token = 3; + google.protobuf.StringValue ios_device_token = 4; + google.protobuf.StringValue android_jws = 5; + } +} + +message PhoneOtpResend { + google.protobuf.StringValue phone = 1; + google.protobuf.StringValue refresh_token = 2; + + oneof check { + google.protobuf.StringValue ios_device_token = 3; + google.protobuf.StringValue android_jws = 4; + } +} + +message PhoneOtp { + google.protobuf.StringValue phone = 1; + string otp = 2; + google.protobuf.StringValue refresh_token = 3; +} + +message Email { + string email = 1; + google.protobuf.StringValue refresh_token = 2; + google.protobuf.BoolValue marketing_opt_in = 3; +} + +message EmailOtpResend { + google.protobuf.StringValue email = 1; + google.protobuf.StringValue refresh_token = 2; +} + +message GoogleToken { + string external_token = 1; + google.protobuf.StringValue refresh_token = 2; + google.protobuf.BoolValue marketing_opt_in = 3; + google.protobuf.BoolValue user_behavior = 4; +} + +message EmailOtp { + google.protobuf.StringValue email = 1; + string otp = 2; + google.protobuf.StringValue refresh_token = 3; +} + +message AppleToken { + string external_token = 1; + google.protobuf.StringValue refresh_token = 2; + google.protobuf.StringValue raw_nonce = 3; +} + +message GetInitialState { + google.protobuf.StringValue refresh_token = 1; +} + +message RefreshAuth { + string refresh_token = 1; +} + +message DismissSocialConnectionList { + string refresh_token = 1; +} + +message EmailMagicLink { + string email = 1; +} + +message EmailMagicLinkOtp { + string otp_token = 1; +} + +message AuthGatewayRequest { + oneof factor { + Phone phone = 1; + PhoneOtp phone_otp = 2; + Email email = 3; + GoogleToken google_token = 4; + EmailOtp email_otp = 5; + FacebookToken facebook_token = 6; + PhoneOtpResend phone_otp_resend = 7; + EmailOtpResend email_otp_resend = 8; + GetInitialState get_initial_state = 9; + RefreshAuth refresh_auth = 10; + AppleToken apple_token = 11; + DismissSocialConnectionList dismiss_social_connection_list = 12; + EmailMagicLink email_magic_link = 13; + EmailMagicLinkOtp email_magic_link_otp = 14; } } + message Verification { string type = 1; string state = 2; @@ -206,8 +238,3 @@ message ErrorProto { string message = 2; BanReason ban_reason = 3; } - -message MetaProto { - google.protobuf.Timestamp upstream_time = 1; - google.protobuf.Timestamp start_time = 2; -} diff --git a/authgateway.py b/authgateway.py index 6e6e5e5..6b5d102 100644 --- a/authgateway.py +++ b/authgateway.py @@ -21,69 +21,243 @@ class SocialConnectionService(betterproto.Enum): SERVICE_APPLE = 3 +@dataclass +class MetaProto(betterproto.Message): + upstream_time: datetime = betterproto.message_field(1) + start_time: datetime = betterproto.message_field(2) + + +@dataclass +class GetPhoneState(betterproto.Message): + refresh_token: Optional[str] = betterproto.message_field( + 1, wraps=betterproto.TYPE_STRING + ) + + +@dataclass +class ValidatePhoneOtpState(betterproto.Message): + refresh_token: Optional[str] = betterproto.message_field( + 1, wraps=betterproto.TYPE_STRING + ) + phone: str = betterproto.string_field(2) + otp_length: Optional[int] = betterproto.message_field( + 3, wraps=betterproto.TYPE_INT32 + ) + sms_sent: Optional[bool] = betterproto.message_field(4, wraps=betterproto.TYPE_BOOL) + + +@dataclass +class EmailMarketing(betterproto.Message): + show_marketing_opt_in: Optional[bool] = betterproto.message_field( + 2, wraps=betterproto.TYPE_BOOL + ) + show_strict_opt_in: Optional[bool] = betterproto.message_field( + 3, wraps=betterproto.TYPE_BOOL + ) + checked_by_default: Optional[bool] = betterproto.message_field( + 4, wraps=betterproto.TYPE_BOOL + ) + + +@dataclass +class GetEmailState(betterproto.Message): + refresh_token: Optional[str] = betterproto.message_field( + 1, wraps=betterproto.TYPE_STRING + ) + email_marketing: "EmailMarketing" = betterproto.message_field(2) + + +@dataclass +class ValidateEmailOtpState(betterproto.Message): + refresh_token: Optional[str] = betterproto.message_field( + 1, wraps=betterproto.TYPE_STRING + ) + otp_length: Optional[int] = betterproto.message_field( + 4, wraps=betterproto.TYPE_INT32 + ) + email_sent: Optional[bool] = betterproto.message_field( + 5, wraps=betterproto.TYPE_BOOL + ) + email_marketing: "EmailMarketing" = betterproto.message_field(6) + unmasked_email: str = betterproto.string_field(2, group="email") + masked_email: str = betterproto.string_field(3, group="email") + + +@dataclass +class OnboardingState(betterproto.Message): + refresh_token: str = betterproto.string_field(1) + onboarding_token: str = betterproto.string_field(2) + user_id: Optional[str] = betterproto.message_field(3, wraps=betterproto.TYPE_STRING) + + +@dataclass +class LoginResult(betterproto.Message): + refresh_token: str = betterproto.string_field(1) + auth_token: str = betterproto.string_field(2) + captcha: "LoginResultCaptcha" = betterproto.enum_field(3) + user_id: str = betterproto.string_field(4) + auth_token_ttl: Optional[int] = betterproto.message_field( + 5, wraps=betterproto.TYPE_INT64 + ) + + +@dataclass +class AppleAccountNotFound(betterproto.Message): + will_link: bool = betterproto.bool_field(1) + refresh_token: Optional[str] = betterproto.message_field( + 2, wraps=betterproto.TYPE_STRING + ) + + +@dataclass +class SocialConnection(betterproto.Message): + service: "SocialConnectionService" = betterproto.enum_field(1) + + +@dataclass +class SocialConnectionList(betterproto.Message): + refresh_token: Optional[str] = betterproto.message_field( + 1, wraps=betterproto.TYPE_STRING + ) + connections: List["SocialConnection"] = betterproto.message_field(2) + + +@dataclass +class ValidateEmailMagicLinkOtpState(betterproto.Message): + pass + + +@dataclass +class AuthGatewayResponse(betterproto.Message): + meta: "MetaProto" = betterproto.message_field(1) + error: "ErrorProto" = betterproto.message_field(2) + get_phone_state: "GetPhoneState" = betterproto.message_field(3, group="data") + validate_phone_otp_state: "ValidatePhoneOtpState" = betterproto.message_field( + 4, group="data" + ) + get_email_state: "GetEmailState" = betterproto.message_field(5, group="data") + validate_email_otp_state: "ValidateEmailOtpState" = betterproto.message_field( + 6, group="data" + ) + onboarding_state: "OnboardingState" = betterproto.message_field(7, group="data") + login_result: "LoginResult" = betterproto.message_field(8, group="data") + social_connection_list: "SocialConnectionList" = betterproto.message_field( + 9, group="data" + ) + apple_account_not_found: "AppleAccountNotFound" = betterproto.message_field( + 10, group="data" + ) + validate_email_magic_link_otp_state: "ValidateEmailMagicLinkOtpState" = betterproto.message_field( + 11, group="data" + ) + + @dataclass class FacebookToken(betterproto.Message): external_token: str = betterproto.string_field(1) - refresh_token: Optional[str] = betterproto.message_field(2, wraps=betterproto.TYPE_STRING) + refresh_token: Optional[str] = betterproto.message_field( + 2, wraps=betterproto.TYPE_STRING + ) @dataclass class Phone(betterproto.Message): phone: str = betterproto.string_field(1) - refresh_token: Optional[str] = betterproto.message_field(2, wraps=betterproto.TYPE_STRING) + refresh_token: Optional[str] = betterproto.message_field( + 2, wraps=betterproto.TYPE_STRING + ) + captcha_token: Optional[str] = betterproto.message_field( + 3, group="check", wraps=betterproto.TYPE_STRING + ) + ios_device_token: Optional[str] = betterproto.message_field( + 4, group="check", wraps=betterproto.TYPE_STRING + ) + android_jws: Optional[str] = betterproto.message_field( + 5, group="check", wraps=betterproto.TYPE_STRING + ) @dataclass class PhoneOtpResend(betterproto.Message): phone: Optional[str] = betterproto.message_field(1, wraps=betterproto.TYPE_STRING) - refresh_token: Optional[str] = betterproto.message_field(2, wraps=betterproto.TYPE_STRING) + refresh_token: Optional[str] = betterproto.message_field( + 2, wraps=betterproto.TYPE_STRING + ) + ios_device_token: Optional[str] = betterproto.message_field( + 3, group="check", wraps=betterproto.TYPE_STRING + ) + android_jws: Optional[str] = betterproto.message_field( + 4, group="check", wraps=betterproto.TYPE_STRING + ) @dataclass class PhoneOtp(betterproto.Message): phone: Optional[str] = betterproto.message_field(1, wraps=betterproto.TYPE_STRING) otp: str = betterproto.string_field(2) - refresh_token: Optional[str] = betterproto.message_field(3, wraps=betterproto.TYPE_STRING) + refresh_token: Optional[str] = betterproto.message_field( + 3, wraps=betterproto.TYPE_STRING + ) @dataclass class Email(betterproto.Message): email: str = betterproto.string_field(1) - refresh_token: Optional[str] = betterproto.message_field(2, wraps=betterproto.TYPE_STRING) - marketing_opt_in: Optional[bool] = betterproto.message_field(3, wraps=betterproto.TYPE_BOOL) + refresh_token: Optional[str] = betterproto.message_field( + 2, wraps=betterproto.TYPE_STRING + ) + marketing_opt_in: Optional[bool] = betterproto.message_field( + 3, wraps=betterproto.TYPE_BOOL + ) @dataclass class EmailOtpResend(betterproto.Message): email: Optional[str] = betterproto.message_field(1, wraps=betterproto.TYPE_STRING) - refresh_token: Optional[str] = betterproto.message_field(2, wraps=betterproto.TYPE_STRING) + refresh_token: Optional[str] = betterproto.message_field( + 2, wraps=betterproto.TYPE_STRING + ) @dataclass class GoogleToken(betterproto.Message): external_token: str = betterproto.string_field(1) - refresh_token: Optional[str] = betterproto.message_field(2, wraps=betterproto.TYPE_STRING) - marketing_opt_in: Optional[bool] = betterproto.message_field(3, wraps=betterproto.TYPE_BOOL) - user_behavior: Optional[bool] = betterproto.message_field(4, wraps=betterproto.TYPE_BOOL) + refresh_token: Optional[str] = betterproto.message_field( + 2, wraps=betterproto.TYPE_STRING + ) + marketing_opt_in: Optional[bool] = betterproto.message_field( + 3, wraps=betterproto.TYPE_BOOL + ) + user_behavior: Optional[bool] = betterproto.message_field( + 4, wraps=betterproto.TYPE_BOOL + ) @dataclass class EmailOtp(betterproto.Message): email: Optional[str] = betterproto.message_field(1, wraps=betterproto.TYPE_STRING) otp: str = betterproto.string_field(2) - refresh_token: Optional[str] = betterproto.message_field(3, wraps=betterproto.TYPE_STRING) + refresh_token: Optional[str] = betterproto.message_field( + 3, wraps=betterproto.TYPE_STRING + ) @dataclass class AppleToken(betterproto.Message): external_token: str = betterproto.string_field(1) - refresh_token: Optional[str] = betterproto.message_field(2, wraps=betterproto.TYPE_STRING) - raw_nonce: Optional[str] = betterproto.message_field(3, wraps=betterproto.TYPE_STRING) + refresh_token: Optional[str] = betterproto.message_field( + 2, wraps=betterproto.TYPE_STRING + ) + raw_nonce: Optional[str] = betterproto.message_field( + 3, wraps=betterproto.TYPE_STRING + ) @dataclass class GetInitialState(betterproto.Message): - refresh_token: Optional[str] = betterproto.message_field(1, wraps=betterproto.TYPE_STRING) + refresh_token: Optional[str] = betterproto.message_field( + 1, wraps=betterproto.TYPE_STRING + ) @dataclass @@ -96,6 +270,16 @@ class DismissSocialConnectionList(betterproto.Message): refresh_token: str = betterproto.string_field(1) +@dataclass +class EmailMagicLink(betterproto.Message): + email: str = betterproto.string_field(1) + + +@dataclass +class EmailMagicLinkOtp(betterproto.Message): + otp_token: str = betterproto.string_field(1) + + @dataclass class AuthGatewayRequest(betterproto.Message): phone: "Phone" = betterproto.message_field(1, group="factor") @@ -109,89 +293,13 @@ class AuthGatewayRequest(betterproto.Message): get_initial_state: "GetInitialState" = betterproto.message_field(9, group="factor") refresh_auth: "RefreshAuth" = betterproto.message_field(10, group="factor") apple_token: "AppleToken" = betterproto.message_field(11, group="factor") - dismiss_social_connection_list: "DismissSocialConnectionList" = (betterproto.message_field(12, group="factor")) - - -@dataclass -class GetPhoneState(betterproto.Message): - refresh_token: Optional[str] = betterproto.message_field(1, wraps=betterproto.TYPE_STRING) - - -@dataclass -class ValidatePhoneOtpState(betterproto.Message): - refresh_token: Optional[str] = betterproto.message_field(1, wraps=betterproto.TYPE_STRING) - phone: str = betterproto.string_field(2) - otp_length: Optional[int] = betterproto.message_field(3, wraps=betterproto.TYPE_INT32) - sms_sent: Optional[bool] = betterproto.message_field(4, wraps=betterproto.TYPE_BOOL) - - -@dataclass -class EmailMarketing(betterproto.Message): - show_marketing_opt_in: Optional[bool] = betterproto.message_field(2, wraps=betterproto.TYPE_BOOL) - show_strict_opt_in: Optional[bool] = betterproto.message_field(3, wraps=betterproto.TYPE_BOOL) - checked_by_default: Optional[bool] = betterproto.message_field(4, wraps=betterproto.TYPE_BOOL) - - -@dataclass -class GetEmailState(betterproto.Message): - refresh_token: Optional[str] = betterproto.message_field(1, wraps=betterproto.TYPE_STRING) - email_marketing: "EmailMarketing" = betterproto.message_field(2) - - -@dataclass -class ValidateEmailOtpState(betterproto.Message): - refresh_token: Optional[str] = betterproto.message_field(1, wraps=betterproto.TYPE_STRING) - otp_length: Optional[int] = betterproto.message_field(4, wraps=betterproto.TYPE_INT32) - email_sent: Optional[bool] = betterproto.message_field(5, wraps=betterproto.TYPE_BOOL) - email_marketing: "EmailMarketing" = betterproto.message_field(6) - unmasked_email: str = betterproto.string_field(2, group="email") - masked_email: str = betterproto.string_field(3, group="email") - - -@dataclass -class OnboardingState(betterproto.Message): - refresh_token: str = betterproto.string_field(1) - onboarding_token: str = betterproto.string_field(2) - - -@dataclass -class LoginResult(betterproto.Message): - refresh_token: str = betterproto.string_field(1) - auth_token: str = betterproto.string_field(2) - captcha: "LoginResultCaptcha" = betterproto.enum_field(3) - user_id: str = betterproto.string_field(4) - auth_token_ttl: Optional[int] = betterproto.message_field(5, wraps=betterproto.TYPE_INT64) - - -@dataclass -class AppleAccountNotFound(betterproto.Message): - will_link: bool = betterproto.bool_field(1) - refresh_token: Optional[str] = betterproto.message_field(2, wraps=betterproto.TYPE_STRING) - - -@dataclass -class SocialConnection(betterproto.Message): - service: "SocialConnectionService" = betterproto.enum_field(1) - - -@dataclass -class SocialConnectionList(betterproto.Message): - refresh_token: Optional[str] = betterproto.message_field(1, wraps=betterproto.TYPE_STRING) - connections: List["SocialConnection"] = betterproto.message_field(2) - - -@dataclass -class AuthGatewayResponse(betterproto.Message): - meta: "MetaProto" = betterproto.message_field(1) - error: "ErrorProto" = betterproto.message_field(2) - get_phone_state: "GetPhoneState" = betterproto.message_field(3, group="data") - validate_phone_otp_state: "ValidatePhoneOtpState" = betterproto.message_field(4, group="data") - get_email_state: "GetEmailState" = betterproto.message_field(5, group="data") - validate_email_otp_state: "ValidateEmailOtpState" = betterproto.message_field(6, group="data") - onboarding_state: "OnboardingState" = betterproto.message_field(7, group="data") - login_result: "LoginResult" = betterproto.message_field(8, group="data") - social_connection_list: "SocialConnectionList" = betterproto.message_field(9, group="data") - apple_account_not_found: "AppleAccountNotFound" = betterproto.message_field(10, group="data") + dismiss_social_connection_list: "DismissSocialConnectionList" = betterproto.message_field( + 12, group="factor" + ) + email_magic_link: "EmailMagicLink" = betterproto.message_field(13, group="factor") + email_magic_link_otp: "EmailMagicLinkOtp" = betterproto.message_field( + 14, group="factor" + ) @dataclass @@ -202,8 +310,12 @@ class Verification(betterproto.Message): @dataclass class UnderageBan(betterproto.Message): - underage_ttl_duration_ms: Optional[int] = betterproto.message_field(1, wraps=betterproto.TYPE_INT64) - underage_token: Optional[str] = betterproto.message_field(2, wraps=betterproto.TYPE_STRING) + underage_ttl_duration_ms: Optional[int] = betterproto.message_field( + 1, wraps=betterproto.TYPE_INT64 + ) + underage_token: Optional[str] = betterproto.message_field( + 2, wraps=betterproto.TYPE_STRING + ) verification: "Verification" = betterproto.message_field(3) @@ -225,9 +337,3 @@ class ErrorProto(betterproto.Message): code: int = betterproto.int32_field(1) message: str = betterproto.string_field(2) ban_reason: "BanReason" = betterproto.message_field(3) - - -@dataclass -class MetaProto(betterproto.Message): - upstream_time: datetime = betterproto.message_field(1) - start_time: datetime = betterproto.message_field(2) \ No newline at end of file diff --git a/sms_auth_v3.py b/sms_auth_v3.py index 57fe53a..e2db522 100644 --- a/sms_auth_v3.py +++ b/sms_auth_v3.py @@ -49,14 +49,17 @@ def loginwrapper(self, body, seconds, headers=None): print(response) if "validatePhoneOtpState" in response.keys() and response["validatePhoneOtpState"]["smsSent"]: otpresponse = input("OTP Response from SMS: ") - if self.refreshtoken is not None: - resp = PhoneOtp(phone=self.phonenumber, otp=otpresponse, refresh_token=self.refreshtoken) - else: - resp = PhoneOtp(phone=self.phonenumber, otp=otpresponse) + resp = PhoneOtp(phone=self.phonenumber, otp=otpresponse) messageresponse = AuthGatewayRequest(phone_otp=resp) seconds += random.uniform(30, 90) header_timer = {"app-session-time-elapsed": format(seconds, ".3f")} return self.loginwrapper(messageresponse, seconds, header_timer) + elif "getPhoneState" in response.keys(): + self.refreshtoken = response['getPhoneState']['refreshToken'] + messageresponse = AuthGatewayRequest(refresh_auth=RefreshAuth(refresh_token=self.refreshtoken)) + seconds += random.uniform(30, 90) + header_timer = {"app-session-time-elapsed": format(seconds, ".3f")} + return self.loginwrapper(messageresponse, seconds, header_timer) elif "validateEmailOtpState" in response.keys() and response["validateEmailOtpState"]["emailSent"]: emailoptresponse = input("Check your email and input the verification code just sent to you: ") refreshtoken = response["validateEmailOtpState"]["refreshToken"] @@ -66,6 +69,14 @@ def loginwrapper(self, body, seconds, headers=None): seconds += random.uniform(30, 90) header_timer = {"app-session-time-elapsed": format(seconds, ".3f")} return self.loginwrapper(messageresponse, seconds, header_timer) + elif "getEmailState" in response.keys(): + refreshtoken = response['getEmailState']['refreshToken'] + if self.email is None: + self.email = input("Input your email: ") + seconds += random.uniform(30, 90) + header_timer = {"app-session-time-elapsed": format(seconds, ".3f")} + messageresponse = AuthGatewayRequest(refresh_auth=RefreshAuth(refresh_token=refreshtoken)) + return self.loginwrapper(messageresponse, seconds, header_timer) elif "error" in response.keys() and response["error"]["message"] == 'INVALID_REFRESH_TOKEN': print("Refresh token error, restarting auth") phonenumber = input("phone number (starting with 1, numbers only): ") @@ -88,15 +99,15 @@ def login(self): self.session.post(self.url + "/v2/buckets", json=payload) if self.refreshtoken is not None: print("Attempting to refresh auth token with saved refresh token") - messageout = AuthGatewayRequest(refresh_auth=RefreshAuth(refresh_token=self.refreshtoken)) + messageout = AuthGatewayRequest(get_initial_state=GetInitialState(refresh_token=self.refreshtoken)) else: phonenumber = input("phone number (starting with 1, numbers only): ") self.phonenumber = phonenumber messageout = AuthGatewayRequest(phone=Phone(phone=self.phonenumber)) seconds = random.uniform(100, 250) headers = { - 'tinder-version': "11.24.0", 'install-id': self.installid, - 'user-agent': "Tinder Android Version 11.24.0", 'connection': "close", + 'tinder-version': "12.6.0", 'install-id': self.installid, + 'user-agent': "Tinder Android Version 12.6.0", 'connection': "close", 'platform-variant': "Google-Play", 'persistent-device-id': self.deviceid, 'accept-encoding': "gzip, deflate", 'appsflyer-id': "1600144077225-7971032049730563486", 'platform': "android", 'app-version': "4023", 'os-version': "25", 'app-session-id': self.appsessionid, From a02a446e0dc3079acdf88741a7f7d847a603948c Mon Sep 17 00:00:00 2001 From: jim zhou <43537315+jimtje@users.noreply.github.com> Date: Sat, 17 Apr 2021 20:42:53 -0700 Subject: [PATCH 10/23] testing to see which email payload triggers proper processing of token --- sms_auth_v3.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sms_auth_v3.py b/sms_auth_v3.py index e2db522..ccdef68 100644 --- a/sms_auth_v3.py +++ b/sms_auth_v3.py @@ -75,7 +75,7 @@ def loginwrapper(self, body, seconds, headers=None): self.email = input("Input your email: ") seconds += random.uniform(30, 90) header_timer = {"app-session-time-elapsed": format(seconds, ".3f")} - messageresponse = AuthGatewayRequest(refresh_auth=RefreshAuth(refresh_token=refreshtoken)) + messageresponse = AuthGatewayRequest(email=Email(email=self.email, refresh_token=refreshtoken)) return self.loginwrapper(messageresponse, seconds, header_timer) elif "error" in response.keys() and response["error"]["message"] == 'INVALID_REFRESH_TOKEN': print("Refresh token error, restarting auth") From 0b870cd196a8223566d26930075ad216ebaadaf5 Mon Sep 17 00:00:00 2001 From: "maxime.peim" Date: Wed, 13 Oct 2021 14:40:13 +0200 Subject: [PATCH 11/23] Big cleanup --- .gitignore | 5 +- LICENSE | 6 +- README.md | 56 ++--- Tinder API.ipynb | 217 ---------------- fb_auth_token.py | 41 ---- features.py => old/features.py | 50 ++-- tinder_api.py => old/tinder_api.py | 88 +++---- phone_auth_token.py | 41 ---- requirements.txt | 29 ++- setup.py | 29 ++- sms_auth_v3.py | 133 ---------- src/tinder/__init__.py | 19 ++ src/tinder/recs.py | 51 ++++ src/tinder/user.py | 51 ++++ src/tinder/v2/__init__.py | 8 + src/tinder/v2/auth/__init__.py | 16 ++ src/tinder/v2/auth/facebook.py | 88 +++++++ src/tinder/v2/auth/sms.py | 103 ++++++++ src/tinder/v3/__init__.py | 6 + src/tinder/v3/auth/__init__.py | 7 + .../tinder/v3/auth/authgateway.proto | 8 +- .../tinder/v3/auth/authgateway.py | 96 ++++---- src/tinder/v3/auth/sms.py | 177 +++++++++++++ test.py | 13 + tinder_api_sms.py | 232 ------------------ tinder_config_ex.py | 13 - 26 files changed, 726 insertions(+), 857 deletions(-) delete mode 100644 Tinder API.ipynb delete mode 100644 fb_auth_token.py rename features.py => old/features.py (74%) rename tinder_api.py => old/tinder_api.py (74%) delete mode 100644 phone_auth_token.py delete mode 100644 sms_auth_v3.py create mode 100644 src/tinder/__init__.py create mode 100644 src/tinder/recs.py create mode 100644 src/tinder/user.py create mode 100644 src/tinder/v2/__init__.py create mode 100644 src/tinder/v2/auth/__init__.py create mode 100644 src/tinder/v2/auth/facebook.py create mode 100644 src/tinder/v2/auth/sms.py create mode 100644 src/tinder/v3/__init__.py create mode 100644 src/tinder/v3/auth/__init__.py rename authgateway.proto => src/tinder/v3/auth/authgateway.proto (96%) rename authgateway.py => src/tinder/v3/auth/authgateway.py (71%) create mode 100644 src/tinder/v3/auth/sms.py create mode 100644 test.py delete mode 100644 tinder_api_sms.py delete mode 100644 tinder_config_ex.py diff --git a/.gitignore b/.gitignore index ab1faa8..211e386 100644 --- a/.gitignore +++ b/.gitignore @@ -2,14 +2,17 @@ proxying.txt config.py api_abstract.py *.pyc -__pycache__ +__pycache__/ find.py *.log *.egg-info +env/ .idea/ +.vscode/ smstoken.txt +*_token.txt google/protobuf/.DS_Store diff --git a/LICENSE b/LICENSE index b232675..328eada 100644 --- a/LICENSE +++ b/LICENSE @@ -1,9 +1,9 @@ MIT License -Copyright (c) 2017 fabien bessez +Copyright (c) 2017 Fabien Bessez Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal +of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is @@ -12,7 +12,7 @@ furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER diff --git a/README.md b/README.md index 2d0cab9..84b96d8 100644 --- a/README.md +++ b/README.md @@ -30,7 +30,7 @@ First off, I want to give a shoutout to @@ -99,7 +99,7 @@ Note: All curls must be sent with the headers as well (the only exception is tha /user/matches/_id Send Message to that id - {"message": TEXT GOES HERE} + {'message': TEXT GOES HERE} POST @@ -117,13 +117,13 @@ Note: All curls must be sent with the headers as well (the only exception is tha /user/ping Change your location - {"lat": lat, "lon": lon} + {'lat': lat, 'lon': lon} POST /updates - Get all updates since the given date -- inserting "" will give you all updates since creating a Tinder account (i.e. matches, messages sent, etc.) - {"last_activity_date": ""} Input a timestamp: '2017-03-25T20:58:00.404Z' for updates since that time. + Get all updates since the given date -- inserting '' will give you all updates since creating a Tinder account (i.e. matches, messages sent, etc.) + {'last_activity_date': ''} Input a timestamp: '2017-03-25T20:58:00.404Z' for updates since that time. POST @@ -135,49 +135,49 @@ Note: All curls must be sent with the headers as well (the only exception is tha /profile Change your search preferences - {"age_filter_min": age_filter_min, "gender_filter": gender_filter, "gender": gender, "age_filter_max": age_filter_max, "distance_filter": distance_filter} + {'age_filter_min': age_filter_min, 'gender_filter': gender_filter, 'gender': gender, 'age_filter_max': age_filter_max, 'distance_filter': distance_filter} POST /profile (Tinder Plus Only) hide/show age - {"hide_age":boolean} + {'hide_age':boolean} POST /profile (Tinder Plus Only) hide/show distance - {"hide_distance":boolean} + {'hide_distance':boolean} POST /profile (Tinder Plus Only) hide/show ads - {"hide_ads":boolean} + {'hide_ads':boolean} POST /profile - (Tinder Plus Only) Set Tinder Blend options to "Recent Activity": Shows more recently active users - {"blend":"recency"} + (Tinder Plus Only) Set Tinder Blend options to 'Recent Activity': Shows more recently active users + {'blend':'recency'} POST /profile - (Tinder Plus Only) Set Tinder Blend options to "Optimal": Scientifically proven to get you more matches - {"blend":"optimal"} + (Tinder Plus Only) Set Tinder Blend options to 'Optimal': Scientifically proven to get you more matches + {'blend':'optimal'} POST /profile (Tinder Plus Only) Set discovery settings to only people who already liked you - {"discoverable_party":"liked"} + {'discoverable_party':'liked'} POST /passport/user/travel (Tinder Plus Only) Travel to coordinate - {"lat":lat,"lon":lon} + {'lat':lat,'lon':lon} POST @@ -200,13 +200,13 @@ Note: All curls must be sent with the headers as well (the only exception is tha /v2/profile/spotify/theme Set Spotify song - {"id":song_id} + {'id':song_id} PUT /profile/username Change your webprofile username - {"username": username} + {'username': username} PUT @@ -223,14 +223,14 @@ Note: All curls must be sent with the headers as well (the only exception is tha /v2/meta - Get your own meta data from V2 API (extra data like "top_picks" info) + Get your own meta data from V2 API (extra data like 'top_picks' info) {} GET /report/_id Report someone --> There are only a few accepted causes... (see tinder_api.py for options) - {"cause": cause, "text": explanation} + {'cause': cause, 'text': explanation} POST @@ -253,13 +253,13 @@ Note: All curls must be sent with the headers as well (the only exception is tha /matches/{match id} - Get a match from its id (thanks @jtabet ) + Get a match from its id (thanks @jtabet ) {} GET /message/{message id} - Get a message from its id (thanks @jtabet ) + Get a message from its id (thanks @jtabet ) {} GET @@ -272,7 +272,7 @@ Note: All curls must be sent with the headers as well (the only exception is tha /passport/user/travel Change your swiping location - {"lat": latitutde, "lon": longitude} + {'lat': latitutde, 'lon': longitude} POST @@ -284,7 +284,7 @@ Note: All curls must be sent with the headers as well (the only exception is tha /profile/job Set job - {"company":{"id":"17767109610","name":"University of Miami","displayed":true},"title":{"id":"106123522751852","name":"Research Assistant","displayed":true}} + {'company':{'id':'17767109610','name':'University of Miami','displayed':true},'title':{'id':'106123522751852','name':'Research Assistant','displayed':true}} PUT @@ -296,7 +296,7 @@ Note: All curls must be sent with the headers as well (the only exception is tha /profile/school Set school(s) - {"schools":[{"id":school_id}]} + {'schools':[{'id':school_id}]} PUT @@ -425,7 +425,7 @@ With your token ready, add it to tinder_config_ex.py (value for tinder_token). Y ```

Sorting:

-

Sorting matches by "age", "message_count", and "gender"

+

Sorting matches by 'age', 'message_count', and 'gender'

```javascript [ @@ -459,12 +459,12 @@ With your token ready, add it to tinder_config_ex.py (value for tinder_token). Y

Friends' Pingtimes:

friends_pingtimes() will return the following for each facebook friend of yours who has a Tinder -friend_pingtime_by_name("Joakim Noah") will return the pingtime for only that particular friend. +friend_pingtime_by_name('Joakim Noah') will return the pingtime for only that particular friend. The following is a sample result for friends_pingtimes():

` - "Joakim Noah -----> 15 days, 16 hrs 46 min 57 sec" - "Carmelo Anthony ------> 0 days, 22 hrs 23 min 45 sec" + 'Joakim Noah -----> 15 days, 16 hrs 46 min 57 sec' + 'Carmelo Anthony ------> 0 days, 22 hrs 23 min 45 sec' ... ` diff --git a/Tinder API.ipynb b/Tinder API.ipynb deleted file mode 100644 index d210d4e..0000000 --- a/Tinder API.ipynb +++ /dev/null @@ -1,217 +0,0 @@ -{ - "cells": [ - { - "attachments": { - "image.png": { - "image/png": "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" - } - }, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "![image.png](attachment:image.png)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import tinder_api\n", - "import fb_auth_token" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "host = 'https://api.gotinder.com' #thanks to this line you do not need to import config.py or tinder_config_ex.py" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Enter your facebook email \n", - "fb_username = 'email@gmail.com'\n", - "# Enter your facebook password \n", - "fb_password = 'password'\n", - "\n", - "fb_access_token = fb_auth_token.get_fb_access_token(fb_username, fb_password)\n", - "fb_user_id = fb_auth_token.get_fb_id(fb_access_token)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "fb_access_token" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "fb_user_id" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#tinder_auth_token = tinder_api.get_auth_token(config.fb_auth_token, config.fb_user_id)\n", - "tinder_api.get_auth_token(fb_access_token, fb_user_id)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# To check you are authorized \n", - "# tinder_api.authverif()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Get Tinder Recommendations of people around you \n", - "recommendations = tinder_api.get_recommendations()\n", - "# print(recommendations['status']) # 200 = successs \n", - "# len(recommendations['results']) # len of batches are 12\n", - "recommendations" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Get updates since certain date\n", - "tinder_api.get_updates(\"2017-11-18T10:28:13.392Z\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# select one recommended individual \n", - "testid=recommendations['results'][0]['_id']\n", - "print(testid)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Retrieve profile from id \n", - "testperson=tinder_api.get_person(testid)\n", - "testperson" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Can also play a bit with your own profile\n", - "myself = tinder_api.get_self()\n", - "for p in myself['photos']:\n", - " print(p['url'])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "myself" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# and maybe experiment a bit with your own gender ;) \n", - "tinder_api.change_preferences(gender_filter='1')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Like a user \n", - "tinder_api.like('5a10ae3c8802dc4401463712')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# message a match \n", - "tinder_api.send_msg('59ff7c30117d37c0572338d55a10ae3c8802dc4401463712', 'Hi, boy! Gloria Tinder-Robot here')" - ] - }, - { - "attachments": { - "image.png": { - "image/png": "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" - } - }, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "![image.png](attachment:image.png)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.5.2" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/fb_auth_token.py b/fb_auth_token.py deleted file mode 100644 index fcede72..0000000 --- a/fb_auth_token.py +++ /dev/null @@ -1,41 +0,0 @@ -# Used from https://github.com/philipperemy/Deep-Learning-Tinder/blob/master/tinder_token.py - -import re - -import requests -import robobrowser - -MOBILE_USER_AGENT = "Tinder/7.5.3 (iPhone; iOS 10.3.2; Scale/2.00)" -FB_AUTH = "https://www.facebook.com/v2.6/dialog/oauth?redirect_uri=fb464891386855067%3A%2F%2Fauthorize%2F&display=touch&state=%7B%22challenge%22%3A%22IUUkEUqIGud332lfu%252BMJhxL4Wlc%253D%22%2C%220_auth_logger_id%22%3A%2230F06532-A1B9-4B10-BB28-B29956C71AB1%22%2C%22com.facebook.sdk_client_state%22%3Atrue%2C%223_method%22%3A%22sfvc_auth%22%7D&scope=user_birthday%2Cuser_photos%2Cuser_education_history%2Cemail%2Cuser_relationship_details%2Cuser_friends%2Cuser_work_history%2Cuser_likes&response_type=token%2Csigned_request&default_audience=friends&return_scopes=true&auth_type=rerequest&client_id=464891386855067&ret=login&sdk=ios&logger_id=30F06532-A1B9-4B10-BB28-B29956C71AB1&ext=1470840777&hash=AeZqkIcf-NEW6vBd" - - -def get_fb_access_token(email, password): - s = robobrowser.RoboBrowser(user_agent=MOBILE_USER_AGENT, parser="lxml") - s.open(FB_AUTH) - f = s.get_form() - f["pass"] = password - f["email"] = email - s.submit_form(f) - f = s.get_form() - try: - s.submit_form(f, submit=f.submit_fields['__CONFIRM__']) - access_token = re.search( - r"access_token=([\w\d]+)", s.response.content.decode()).groups()[0] - return access_token - except requests.exceptions.InvalidSchema as browserAddress: - access_token = re.search( - r"access_token=([\w\d]+)",str(browserAddress)).groups()[0] - return access_token - except Exception as ex: - print("access token could not be retrieved. Check your username and password.") - print("Official error: %s" % ex) - return {"error": "access token could not be retrieved. Check your username and password."} - - -def get_fb_id(access_token): - if "error" in access_token: - return {"error": "access token could not be retrieved"} - """Gets facebook ID from access token""" - req = requests.get( - 'https://graph.facebook.com/me?access_token=' + access_token) - return req.json()["id"] diff --git a/features.py b/old/features.py similarity index 74% rename from features.py rename to old/features.py index a07ee4c..db4dd30 100644 --- a/features.py +++ b/old/features.py @@ -5,7 +5,7 @@ from time import sleep import config -import tinder_api as api +import tinder_api as tinder ''' @@ -16,7 +16,7 @@ def get_match_info(): - matches = api.get_updates()['matches'] + matches = tinder.get_updates()['matches'] now = datetime.utcnow() match_info = {} for match in matches[:len(matches)]: @@ -24,24 +24,24 @@ def get_match_info(): person = match['person'] person_id = person['_id'] # This ID for looking up person match_info[person_id] = { - "name": person['name'], - "match_id": match['id'], # This ID for messaging - "message_count": match['message_count'], - "photos": get_photos(person), - "bio": person['bio'], - "gender": person['gender'], - "avg_successRate": get_avg_successRate(person), - "messages": match['messages'], - "age": calculate_age(match['person']['birth_date']), - "distance": api.get_person(person_id)['results']['distance_mi'], - "last_activity_date": match['last_activity_date'], + 'name': person['name'], + 'match_id': match['id'], # This ID for messaging + 'message_count': match['message_count'], + 'photos': get_photos(person), + 'bio': person['bio'], + 'gender': person['gender'], + 'avg_successRate': get_avg_successRate(person), + 'messages': match['messages'], + 'age': calculate_age(match['person']['birth_date']), + 'distance': tinder.get_person(person_id)['results']['distance_mi'], + 'last_activity_date': match['last_activity_date'], } except Exception as ex: - template = "An exception of type {0} occurred. Arguments:\n{1!r}" + template = 'An exception of type {0} occurred. Arguments:\n{1!r}' message = template.format(type(ex).__name__, ex.args) print(message) # continue - print("All data stored in variable: match_info") + print('All data stored in variable: match_info') return match_info @@ -56,7 +56,7 @@ def get_match_id_by_name(name): list_of_ids.append(match_info[match]['match_id']) if len(list_of_ids) > 0: return list_of_ids - return {"error": "No matches by name of %s" % name} + return {'error': 'No matches by name of %s' % name} def get_photos(person): @@ -106,17 +106,17 @@ def sort_by_value(sortType): def see_friends_profiles(name=None): - friends = api.see_friends() + friends = tinder.see_friends() if name == None: return friends else: result_dict = {} name = name.title() # upcases first character of each word for friend in friends: - if name in friend["name"]: - result_dict[friend["name"]] = friend + if name in friend['name']: + result_dict[friend['name']] = friend if result_dict == {}: - return "No friends by that name" + return 'No friends by that name' return result_dict @@ -125,7 +125,7 @@ def convert_from_datetime(difference): days = difference.days m, s = divmod(secs, 60) h, m = divmod(m, 60) - return ("%d days, %d hrs %02d min %02d sec" % (days, h, m, s)) + return ('%d days, %d hrs %02d min %02d sec' % (days, h, m, s)) def get_last_activity_date(now, ping_time): @@ -145,7 +145,7 @@ def how_long_has_it_been(): ping_time = match_info[person]['last_activity_date'] since = get_last_activity_date(now, ping_time) times[name] = since - print(name, "----->", since) + print(name, '----->', since) return times @@ -161,8 +161,8 @@ def pause(): sleep(nap_length) if __name__ == '__main__': - if api.authverif() == True: - print("Gathering Data on your matches...") + if tinder.authverif() == True: + print('Gathering Data on your matches...') match_info = get_match_info() else: - print("Something went wrong. You were not authorized.") + print('Something went wrong. You were not authorized.') diff --git a/tinder_api.py b/old/tinder_api.py similarity index 74% rename from tinder_api.py rename to old/tinder_api.py index 6398fc0..243987e 100644 --- a/tinder_api.py +++ b/old/tinder_api.py @@ -7,17 +7,17 @@ get_headers = { 'app_version': '6.9.4', 'platform': 'ios', - "User-agent": "Tinder/7.5.3 (iPhone; iOS 10.3.2; Scale/2.00)", - "Accept": "application/json" + 'User-agent': 'Tinder/7.5.3 (iPhone; iOS 10.3.2; Scale/2.00)', + 'Accept': 'application/json' } headers = get_headers.copy() -headers['content-type'] = "application/json" +headers['content-type'] = 'application/json' def get_auth_token(fb_auth_token, fb_user_id): - if "error" in fb_auth_token: - return {"error": "could not retrieve fb_auth_token"} - if "error" in fb_user_id: - return {"error": "could not retrieve fb_user_id"} + if 'error' in fb_auth_token: + return {'error': 'could not retrieve fb_auth_token'} + if 'error' in fb_user_id: + return {'error': 'could not retrieve fb_user_id'} url = config.host + '/v2/auth/login/facebook' req = requests.post(url, headers=headers, @@ -25,19 +25,19 @@ def get_auth_token(fb_auth_token, fb_user_id): {'token': fb_auth_token, 'facebook_id': fb_user_id}) ) try: - tinder_auth_token = req.json()["data"]["api_token"] - headers.update({"X-Auth-Token": tinder_auth_token}) - get_headers.update({"X-Auth-Token": tinder_auth_token}) - print("You have been successfully authorized!") + tinder_auth_token = req.json()['data']['api_token'] + headers.update({'X-Auth-Token': tinder_auth_token}) + get_headers.update({'X-Auth-Token': tinder_auth_token}) + print('You have been successfully authorized!') return tinder_auth_token except Exception as e: print(e) - return {"error": "Something went wrong. Sorry, but we could not authorize you."} + return {'error': 'Something went wrong. Sorry, but we could not authorize you.'} def authverif(): res = get_auth_token(config.fb_access_token, config.fb_user_id) - if "error" in res: + if 'error' in res: return False return True @@ -50,23 +50,23 @@ def get_recommendations(): r = requests.get('https://api.gotinder.com/user/recs', headers=headers) return r.json() except requests.exceptions.RequestException as e: - print("Something went wrong with getting recomendations:", e) + print('Something went wrong with getting recomendations:', e) -def get_updates(last_activity_date=""): +def get_updates(last_activity_date=''): ''' Returns all updates since the given activity date. The last activity date is defaulted at the beginning of time. - Format for last_activity_date: "2017-07-09T10:28:13.392Z" + Format for last_activity_date: '2017-07-09T10:28:13.392Z' ''' try: url = config.host + '/updates' r = requests.post(url, headers=headers, - data=json.dumps({"last_activity_date": last_activity_date})) + data=json.dumps({'last_activity_date': last_activity_date})) return r.json() except requests.exceptions.RequestException as e: - print("Something went wrong with getting updates:", e) + print('Something went wrong with getting updates:', e) def get_self(): @@ -78,7 +78,7 @@ def get_self(): r = requests.get(url, headers=headers) return r.json() except requests.exceptions.RequestException as e: - print("Something went wrong. Could not get your data:", e) + print('Something went wrong. Could not get your data:', e) def change_preferences(**kwargs): @@ -91,14 +91,14 @@ def change_preferences(**kwargs): gender: 0 == seeking males, 1 == seeking females distance_filter: 1..100 discoverable: true | false - {"photo_optimizer_enabled":false} + {'photo_optimizer_enabled':false} ''' try: url = config.host + '/profile' r = requests.post(url, headers=headers, data=json.dumps(kwargs)) return r.json() except requests.exceptions.RequestException as e: - print("Something went wrong. Could not change your preferences:", e) + print('Something went wrong. Could not change your preferences:', e) def get_meta(): @@ -113,7 +113,7 @@ def get_meta(): r = requests.get(url, headers=headers) return r.json() except requests.exceptions.RequestException as e: - print("Something went wrong. Could not get your metadata:", e) + print('Something went wrong. Could not get your metadata:', e) def get_meta_v2(): ''' @@ -127,7 +127,7 @@ def get_meta_v2(): r = requests.get(url, headers=headers) return r.json() except requests.exceptions.RequestException as e: - print("Something went wrong. Could not get your metadata:", e) + print('Something went wrong. Could not get your metadata:', e) def update_location(lat, lon): ''' @@ -136,10 +136,10 @@ def update_location(lat, lon): ''' try: url = config.host + '/passport/user/travel' - r = requests.post(url, headers=headers, data=json.dumps({"lat": lat, "lon": lon})) + r = requests.post(url, headers=headers, data=json.dumps({'lat': lat, 'lon': lon})) return r.json() except requests.exceptions.RequestException as e: - print("Something went wrong. Could not update your location:", e) + print('Something went wrong. Could not update your location:', e) def reset_real_location(): try: @@ -147,7 +147,7 @@ def reset_real_location(): r = requests.post(url, headers=headers) return r.json() except requests.exceptions.RequestException as e: - print("Something went wrong. Could not update your location:", e) + print('Something went wrong. Could not update your location:', e) def get_recs_v2(): @@ -168,10 +168,10 @@ def set_webprofileusername(username): try: url = config.host + '/profile/username' r = requests.put(url, headers=headers, - data=json.dumps({"username": username})) + data=json.dumps({'username': username})) return r.json() except requests.exceptions.RequestException as e: - print("Something went wrong. Could not set webprofile username:", e) + print('Something went wrong. Could not set webprofile username:', e) def reset_webprofileusername(username): ''' @@ -182,7 +182,7 @@ def reset_webprofileusername(username): r = requests.delete(url, headers=headers) return r.json() except requests.exceptions.RequestException as e: - print("Something went wrong. Could not delete webprofile username:", e) + print('Something went wrong. Could not delete webprofile username:', e) def get_person(id): ''' @@ -193,17 +193,17 @@ def get_person(id): r = requests.get(url, headers=headers) return r.json() except requests.exceptions.RequestException as e: - print("Something went wrong. Could not get that person:", e) + print('Something went wrong. Could not get that person:', e) def send_msg(match_id, msg): try: url = config.host + '/user/matches/%s' % match_id r = requests.post(url, headers=headers, - data=json.dumps({"message": msg})) + data=json.dumps({'message': msg})) return r.json() except requests.exceptions.RequestException as e: - print("Something went wrong. Could not send your message:", e) + print('Something went wrong. Could not send your message:', e) def unmatch(match_id): try: @@ -211,7 +211,7 @@ def unmatch(match_id): r = requests.delete(url, headers=headers) return r.json() except requests.exceptions.RequestException as e: - print("Something went wrong. Could not unmatch person:", e) + print('Something went wrong. Could not unmatch person:', e) def superlike(person_id): try: @@ -219,7 +219,7 @@ def superlike(person_id): r = requests.post(url, headers=headers) return r.json() except requests.exceptions.RequestException as e: - print("Something went wrong. Could not superlike:", e) + print('Something went wrong. Could not superlike:', e) def like(person_id): @@ -228,7 +228,7 @@ def like(person_id): r = requests.get(url, headers=get_headers) return r.json() except requests.exceptions.RequestException as e: - print("Something went wrong. Could not like:", e) + print('Something went wrong. Could not like:', e) def dislike(person_id): @@ -237,7 +237,7 @@ def dislike(person_id): r = requests.get(url, headers=get_headers) return r.json() except requests.exceptions.RequestException as e: - print("Something went wrong. Could not dislike:", e) + print('Something went wrong. Could not dislike:', e) def report(person_id, cause, explanation=''): @@ -250,10 +250,10 @@ def report(person_id, cause, explanation=''): try: url = config.host + '/report/%s' % person_id r = requests.post(url, headers=headers, data={ - "cause": cause, "text": explanation}) + 'cause': cause, 'text': explanation}) return r.json() except requests.exceptions.RequestException as e: - print("Something went wrong. Could not report:", e) + print('Something went wrong. Could not report:', e) def match_info(match_id): @@ -262,7 +262,7 @@ def match_info(match_id): r = requests.get(url, headers=headers) return r.json() except requests.exceptions.RequestException as e: - print("Something went wrong. Could not get your match info:", e) + print('Something went wrong. Could not get your match info:', e) def all_matches(): try: @@ -270,7 +270,7 @@ def all_matches(): r = requests.get(url, headers=headers) return r.json() except requests.exceptions.RequestException as e: - print("Something went wrong. Could not get your match info:", e) + print('Something went wrong. Could not get your match info:', e) def fast_match_info(): try: @@ -280,7 +280,7 @@ def fast_match_info(): # image is in the response but its in hex.. return count except requests.exceptions.RequestException as e: - print("Something went wrong. Could not get your fast-match count:", e) + print('Something went wrong. Could not get your fast-match count:', e) def trending_gifs(limit=3): try: @@ -288,7 +288,7 @@ def trending_gifs(limit=3): r = requests.get(url, headers=headers) return r.json() except requests.exceptions.RequestException as e: - print("Something went wrong. Could not get the trending gifs:", e) + print('Something went wrong. Could not get the trending gifs:', e) def gif_query(query, limit=3): try: @@ -296,7 +296,7 @@ def gif_query(query, limit=3): r = requests.get(url, headers=headers) return r.json() except requests.exceptions.RequestException as e: - print("Something went wrong. Could not get your gifs:", e) + print('Something went wrong. Could not get your gifs:', e) # def see_friends(): @@ -305,4 +305,4 @@ def gif_query(query, limit=3): # r = requests.get(url, headers=headers) # return r.json()['results'] # except requests.exceptions.RequestException as e: -# print("Something went wrong. Could not get your Facebook friends:", e) +# print('Something went wrong. Could not get your Facebook friends:', e) diff --git a/phone_auth_token.py b/phone_auth_token.py deleted file mode 100644 index ea3e483..0000000 --- a/phone_auth_token.py +++ /dev/null @@ -1,41 +0,0 @@ -import requests -import json - -CODE_REQUEST_URL = "https://api.gotinder.com/v2/auth/sms/send?auth_type=sms" -CODE_VALIDATE_URL = "https://api.gotinder.com/v2/auth/sms/validate?auth_type=sms" -TOKEN_URL = "https://api.gotinder.com/v2/auth/login/sms" - -HEADERS = {'user-agent': 'Tinder/11.4.0 (iPhone; iOS 12.4.1; Scale/2.00)', 'content-type': 'application/json'} - -def send_otp_code(phone_number): - data = {'phone_number': phone_number} - r = requests.post(CODE_REQUEST_URL, headers=HEADERS, data=json.dumps(data), verify=False) - print(r.url) - response = r.json() - if(response.get("data")['sms_sent'] == False): - return False - else: - return True - -def get_refresh_token(otp_code, phone_number): - data = {'otp_code': otp_code, 'phone_number': phone_number} - r = requests.post(CODE_VALIDATE_URL, headers=HEADERS, data=json.dumps(data), verify=False) - print(r.url) - response = r.json() - if(response.get("data")["validated"] == False): - return False - else: - return response.get("data")["refresh_token"] - -def get_api_token(refresh_token): - data = {'refresh_token': refresh_token } - r = requests.post(TOKEN_URL, headers=HEADERS, data=json.dumps(data), verify=False) - print(r.url) - response = r.json() - return response.get("data")["api_token"] - -phone_number = input("Please enter your phone number under the international format (country code + number): ") -log_code = send_otp_code(phone_number) -otp_code = input("Please enter the code you've received by sms: ") -refresh_token = get_refresh_token(otp_code, phone_number) -print("Here is your Tinder token: " + str(get_api_token(refresh_token))) \ No newline at end of file diff --git a/requirements.txt b/requirements.txt index e76d2ea..51f009c 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,18 +1,17 @@ -beautifulsoup4==4.9.1 +beautifulsoup4==4.10.0 betterproto==1.2.5 -certifi==2020.6.20 -chardet==3.0.4 -grpclib==0.4.0 -h2==3.2.0 -hpack==3.0.0 -hyperframe==5.2.0 -idna==2.10 -lxml==4.5.2 -multidict==4.7.6 -requests==2.24.0 +certifi==2021.10.8 +charset-normalizer==2.0.7 +grpclib==0.4.2 +h2==4.1.0 +hpack==4.0.0 +hyperframe==6.0.1 +idna==3.3 +multidict==5.2.0 +requests==2.26.0 robobrowser==0.5.3 -six==1.15.0 -soupsieve==2.0.1 +six==1.16.0 +soupsieve==2.2.1 stringcase==1.2.0 -urllib3==1.25.10 -Werkzeug==1.0.1 +urllib3==1.26.7 +Werkzeug==2.0.2 diff --git a/setup.py b/setup.py index adeb59f..647463d 100644 --- a/setup.py +++ b/setup.py @@ -1,18 +1,23 @@ -from setuptools import setup +import setuptools -setup(name='Tinder', - version='2018.6', +with open('README.md') as desc_file: + long_desc = desc_file.read().strip() + +setuptools.setup( + name='Tinder', + version='2021.1', description='Tinder API for Python', - long_description=open('README.md').read().strip(), - author='fabien bessez', - #author_email='', + long_description=long_desc, + author='Fabien Bessez', url='https://github.com/fbessez/Tinder', - py_modules=['tinder_api', 'tinder_api_sms', 'fb_auth_token'], - install_requires=['requests', - 'robobrowser', - 'lxml'], license='MIT License', zip_safe=False, keywords=['tinder-api', 'tinder', 'python-3', 'robobrowser'], - #classifiers=[] - ) + classifiers=[ + 'Programming Language :: Python :: 3', + 'License :: OSI Approved :: MIT License', + 'Operating System :: OS Independent', + ], + package_dir={"": "src"}, + packages=setuptools.find_packages(where="src") +) diff --git a/sms_auth_v3.py b/sms_auth_v3.py deleted file mode 100644 index ccdef68..0000000 --- a/sms_auth_v3.py +++ /dev/null @@ -1,133 +0,0 @@ -import requests -import random -import string -import uuid -from authgateway import * -import secrets -from pathlib import Path -import sys - - -class SMSAuthException(BaseException): - pass - - -class TinderSMSAuth(object): - - def __init__(self, email=None): - self.installid = ''.join(random.choices(string.ascii_uppercase + string.ascii_lowercase + string.digits, k=11)) - self.session = requests.Session() - self.session.headers.update({"user-agent": "Tinder Android Version 11.24.0"}) - self.url = "https://api.gotinder.com" - self.funnelid = str(uuid.uuid4()) - self.appsessionid = str(uuid.uuid4()) - self.deviceid = secrets.token_hex(8) - self.authtoken = None - self.refreshtoken = None - self.userid = None - self.email = email - self.phonenumber = None - if Path("smstoken.txt").exists(): - print("smstoken.txt found, if you wish to auth again from scratch, delete smstoken.txt") - with open("smstoken.txt", "r") as fh: - tokens = fh.read() - t = tokens.split(",") - self.authtoken = t[0] - self.refreshtoken = t[1] - print("authToken found: " + self.authtoken) - self.login() - - def _postloginreq(self, body, headers=None): - if headers is not None: - self.session.headers.update(headers) - r = self.session.post(self.url + "/v3/auth/login", data=bytes(body)) - response = AuthGatewayResponse().parse(r.content).to_dict() - return response - - def loginwrapper(self, body, seconds, headers=None): - response = self._postloginreq(body, headers) - print(response) - if "validatePhoneOtpState" in response.keys() and response["validatePhoneOtpState"]["smsSent"]: - otpresponse = input("OTP Response from SMS: ") - resp = PhoneOtp(phone=self.phonenumber, otp=otpresponse) - messageresponse = AuthGatewayRequest(phone_otp=resp) - seconds += random.uniform(30, 90) - header_timer = {"app-session-time-elapsed": format(seconds, ".3f")} - return self.loginwrapper(messageresponse, seconds, header_timer) - elif "getPhoneState" in response.keys(): - self.refreshtoken = response['getPhoneState']['refreshToken'] - messageresponse = AuthGatewayRequest(refresh_auth=RefreshAuth(refresh_token=self.refreshtoken)) - seconds += random.uniform(30, 90) - header_timer = {"app-session-time-elapsed": format(seconds, ".3f")} - return self.loginwrapper(messageresponse, seconds, header_timer) - elif "validateEmailOtpState" in response.keys() and response["validateEmailOtpState"]["emailSent"]: - emailoptresponse = input("Check your email and input the verification code just sent to you: ") - refreshtoken = response["validateEmailOtpState"]["refreshToken"] - if self.email is None: - self.email = input("Input your email: ") - messageresponse = AuthGatewayRequest(email_otp=EmailOtp(otp=emailoptresponse, email=self.email, refresh_token=refreshtoken)) - seconds += random.uniform(30, 90) - header_timer = {"app-session-time-elapsed": format(seconds, ".3f")} - return self.loginwrapper(messageresponse, seconds, header_timer) - elif "getEmailState" in response.keys(): - refreshtoken = response['getEmailState']['refreshToken'] - if self.email is None: - self.email = input("Input your email: ") - seconds += random.uniform(30, 90) - header_timer = {"app-session-time-elapsed": format(seconds, ".3f")} - messageresponse = AuthGatewayRequest(email=Email(email=self.email, refresh_token=refreshtoken)) - return self.loginwrapper(messageresponse, seconds, header_timer) - elif "error" in response.keys() and response["error"]["message"] == 'INVALID_REFRESH_TOKEN': - print("Refresh token error, restarting auth") - phonenumber = input("phone number (starting with 1, numbers only): ") - self.phonenumber = phonenumber - messageresponse = AuthGatewayRequest(phone=Phone(phone=self.phonenumber)) - seconds += random.uniform(30, 90) - header_timer = {"app-session-time-elapsed": format(seconds, ".3f")} - return self.loginwrapper(messageresponse, seconds, header_timer) - elif "loginResult" in response.keys() and "authToken" in response["loginResult"].keys(): - return response - else: - raise SMSAuthException - - def login(self): - payload = { - "device_id": self.installid, - "experiments": ["default_login_token", "tinder_u_verification_method", "tinder_rules", - "user_interests_available"] - } - self.session.post(self.url + "/v2/buckets", json=payload) - if self.refreshtoken is not None: - print("Attempting to refresh auth token with saved refresh token") - messageout = AuthGatewayRequest(get_initial_state=GetInitialState(refresh_token=self.refreshtoken)) - else: - phonenumber = input("phone number (starting with 1, numbers only): ") - self.phonenumber = phonenumber - messageout = AuthGatewayRequest(phone=Phone(phone=self.phonenumber)) - seconds = random.uniform(100, 250) - headers = { - 'tinder-version': "12.6.0", 'install-id': self.installid, - 'user-agent': "Tinder Android Version 12.6.0", 'connection': "close", - 'platform-variant': "Google-Play", 'persistent-device-id': self.deviceid, - 'accept-encoding': "gzip, deflate", 'appsflyer-id': "1600144077225-7971032049730563486", - 'platform': "android", 'app-version': "4023", 'os-version': "25", 'app-session-id': self.appsessionid, - 'x-supported-image-formats': "webp", 'funnel-session-id': self.funnelid, - 'app-session-time-elapsed': format(seconds, ".3f"), 'accept-language': "en-US", - 'content-type': "application/x-protobuf" - } - response = self.loginwrapper(messageout, seconds, headers) - self.refreshtoken = response["loginResult"]["refreshToken"] - self.authtoken = response["loginResult"]["authToken"] - self.session.headers.update({"X-AUTH-TOKEN": self.authtoken}) - with open("smstoken.txt", "w") as fh: - fh.write(self.authtoken + "," + self.refreshtoken) - print("Auth token saved to smstoken.txt") - - -if __name__ == '__main__': - print("This script will use the sms login to obtain the auth token, which will be saved to smstoken.txt") - if len(sys.argv) > 1: - emailaddy = sys.argv[1] - else: - emailaddy = None - TinderSMSAuth(email=emailaddy) \ No newline at end of file diff --git a/src/tinder/__init__.py b/src/tinder/__init__.py new file mode 100644 index 0000000..e474921 --- /dev/null +++ b/src/tinder/__init__.py @@ -0,0 +1,19 @@ +from __future__ import annotations + +from urllib.parse import urlparse + +class APIException(Exception): + pass + +class Url(str): + + def __new__(cls, *args, **kwargs): + return str.__new__(cls, *args, **kwargs) + + def __truediv__(self, other_part: str = '') -> Url: + url = self + '/' + other_part + return Url(url) + +URL = Url('https://api.gotinder.com') +RECS_EP = URL / 'user' / 'recs' +LIKE_EP = URL / 'like' \ No newline at end of file diff --git a/src/tinder/recs.py b/src/tinder/recs.py new file mode 100644 index 0000000..ea6e40a --- /dev/null +++ b/src/tinder/recs.py @@ -0,0 +1,51 @@ +from typing import Any + +import tinder + +class Rec: + + _subclasses = {} + + def __init_subclass__(cls, **kwargs): + super().__init_subclass__(**kwargs) + cls._subclasses[cls._TYPE] = cls + + def __init__(self, infos: dict[str, Any]) -> None: + self._infos = infos + + @classmethod + def create(cls, infos: dict[str, Any]) -> Any: + rec_type = infos['type'] + if rec_type not in cls._subclasses: + return Rec(infos) + + return cls._subclasses[rec_type](infos[rec_type]) + + @property + def rec_type(self) -> str: + return self._infos['type'] + + +class UserRec(Rec): + + _TYPE = 'user' + + @property + def rec_type(self) -> str: + return self._TYPE + + @property + def infos(self) -> dict: + return self._infos + + @property + def name(self) -> str: + return self._infos['name'] + + @property + def bio(self) -> str: + return self._infos['bio'] + + @property + def id(self) -> str: + return self._infos['_id'] diff --git a/src/tinder/user.py b/src/tinder/user.py new file mode 100644 index 0000000..fc9f054 --- /dev/null +++ b/src/tinder/user.py @@ -0,0 +1,51 @@ +import requests + +import tinder +from tinder.recs import Rec + +class UserNotLoggedException(tinder.APIException): + pass + +class User: + + def __init__(self) -> None: + self._logged = False + self._session = requests.Session() + + def need_logged(func): + def wrapper(self, *args, **kwargs): + if not self._logged: + raise UserNotLoggedException(f'The user need to be logged to call the function {func}') + return func(self, *args, **kwargs) + return wrapper + + @property + def logged(self) -> bool: + return self._logged + + @property + @need_logged + def recs(self) -> dict: + r = self._session.get(tinder.RECS_EP) + result = r.json()['results'] + recs = [ + Rec.create(infos) + for infos in result + ] + return recs + + @need_logged + def like(self, user_rec) -> dict: + r = self._session.get(tinder.LIKE_EP / self.id) + return r.json() + + @need_logged + def like_all(self) -> None: + for rec in self.recs: + if rec.rec_type == 'user': + print(rec.name) + print(self.like(rec)) + print() + + def login(self) -> None: + raise NotImplementedError \ No newline at end of file diff --git a/src/tinder/v2/__init__.py b/src/tinder/v2/__init__.py new file mode 100644 index 0000000..def5696 --- /dev/null +++ b/src/tinder/v2/__init__.py @@ -0,0 +1,8 @@ +import tinder + +class V2Exception(tinder.APIException): + pass + +URL = tinder.URL / 'v2' +BUCKET_EP = URL / 'buckets' +RECS_EP = URL / 'user' / 'recs' \ No newline at end of file diff --git a/src/tinder/v2/auth/__init__.py b/src/tinder/v2/auth/__init__.py new file mode 100644 index 0000000..4046628 --- /dev/null +++ b/src/tinder/v2/auth/__init__.py @@ -0,0 +1,16 @@ +import tinder.v2 +from tinder import Url + +class AuthException(tinder.v2.V2Exception): + pass + +URL = tinder.v2.URL / 'auth' +LOGIN_EP = URL / 'login' +LOGIN_FB_EP = LOGIN_EP / 'facebook' + +CODE_REQUEST_EP = URL / 'sms' / 'send?auth_type=sms' +CODE_VALIDATE_EP = URL / 'sms' / 'validate?auth_type=sms' +TOKEN_EP = LOGIN_EP / 'sms' + +FB_AUTH = Url('https://www.facebook.com/v2.6/dialog/oauth?redirect_uri=fb464891386855067%3A%2F%2Fauthorize%2F&display=touch&state=%7B%22challenge%22%3A%22IUUkEUqIGud332lfu%252BMJhxL4Wlc%253D%22%2C%220_auth_logger_id%22%3A%2230F06532-A1B9-4B10-BB28-B29956C71AB1%22%2C%22com.facebook.sdk_client_state%22%3Atrue%2C%223_method%22%3A%22sfvc_auth%22%7D&scope=user_birthday%2Cuser_photos%2Cuser_education_history%2Cemail%2Cuser_relationship_details%2Cuser_friends%2Cuser_work_history%2Cuser_likes&response_type=token%2Csigned_request&default_audience=friends&return_scopes=true&auth_type=rerequest&client_id=464891386855067&ret=login&sdk=ios&logger_id=30F06532-A1B9-4B10-BB28-B29956C71AB1&ext=1470840777&hash=AeZqkIcf-NEW6vBd') +FB_ID = Url('https://graph.facebook.com/me') \ No newline at end of file diff --git a/src/tinder/v2/auth/facebook.py b/src/tinder/v2/auth/facebook.py new file mode 100644 index 0000000..ef4201d --- /dev/null +++ b/src/tinder/v2/auth/facebook.py @@ -0,0 +1,88 @@ + + +import sys +import string +import random +import secrets +import uuid +from typing import Any +from pathlib import Path + +import requests +import robobrowser + +import tinder.v2.auth as auth +from tinder.user import User + + +class FBAuthException(auth.AuthException): + pass + +class FBTokenException(auth.AuthException): + pass + +class FBIdException(auth.AuthException): + pass + + +class FBUSer(User): + + def __init__(self, email: str, password: str) -> None: + super().__init__() + + self._email = email + self._password = password + + def _get_fb_token(self) -> str: + USER_AGENT = 'Tinder/7.5.3 (iPhone; iOS 10.3.2; Scale/2.00)' + + session = robobrowser.RoboBrowser(user_agent=USER_AGENT, parser='lxml') + session.open(auth.FB_AUTH) + + connection_form = session.get_form() + connection_form['pass'] = self._password + connection_form['email'] = self._email + session.submit_form(connection_form) + + confirmation_form = session.get_form() + try: + submit_value = confirmation_form.submit_fields['__CONFIRM__'] + session.submit_form(confirmation_form, submit=submit_value) + response = session.response.content.decode() + access_token = re.search( + r'access_token=([\w\d]+)', response).groups()[0] + return access_token + except requests.exceptions.InvalidSchema as browser_address: + access_token = re.search( + r'access_token=([\w\d]+)', str(browser_address)).groups()[0] + return access_token + except Exception as e: + raise FBTokenException(f'Access token could not be retrieved. Check your username and password.\n{e}') + + def _get_fb_id(self, fb_token: str): + try: + r = requests.get( + auth.FB_ID + f'?access_token={fb_token}') + return r.json()['id'] + except Exception as e: + raise FBIdException(f'An error occured while retrieving fb id.\n{e}') + + def login(self): + fb_token = self._get_fb_token() + fb_id = self._get_fb_id(fb_token) + + try: + r = self._session.post( + auth.LOGIN_FB_EP, + data=json.dumps( + {'token': fb_token, 'facebook_id': fb_id} + ) + ) + + print(r.json()) + tinder_auth_token = r.json()['data']['api_token'] + self._session.headers.update({'X-Auth-Token': tinder_auth_token}) + self._logged = True + except Exception as e: + raise FBAuthException(f'An error occured while auth with fb.\n{e}') + diff --git a/src/tinder/v2/auth/sms.py b/src/tinder/v2/auth/sms.py new file mode 100644 index 0000000..bace572 --- /dev/null +++ b/src/tinder/v2/auth/sms.py @@ -0,0 +1,103 @@ +import sys +import string +import random +import secrets +import uuid +from typing import Any +from pathlib import Path + +import requests + +import tinder.v2.auth as auth +from tinder.user import User + +class SMSAuthException(auth.AuthException): + pass + +class SMSNotSent(SMSAuthException): + pass + +class ValidationFailed(SMSAuthException): + pass + +class SMSUser(User): + + def __init__(self, phone_number: str, email: str = None, token_fn: str = None) -> None: + super().__init__() + + self._auth_token: str = None + self._refresh_token: str = None + self._user_id: str = None + + self._session.headers.update( + {'user-agent': 'Tinder/11.4.0 (iPhone; iOS 12.4.1; Scale/2.00)', + 'content-type': 'application/json'} + ) + + self.load_token(token_fn) + + def load_token(self, token_fn: str) -> None: + token_fn = token_fn or self._phone_number + '_token.txt' + + token_file = Path(token_fn) + if token_file.exists(): + print(f'[+] `{token_fn}` found.\n[+] If you wish to auth again from scratch, delete it.') + with token_file.open() as fh: + tokens = fh.read() + auth_token, refresh_token = tokens.split(',') + self._auth_token = auth_token + self._refresh_token = refresh_token + + def save_token(self, token_fn: str = None) -> None: + if self._auth_token is None or self._refresh_token is None: + print('[!] Missing tokens to save.') + return + + token_fn = token_fn or self._phone_number + '_token.txt' + token_file = Path(token_fn) + + if token_file.exists(): + token_file.unlink() + + with token_file.open('w', encoding='utf-8') as fh: + fh.write(self._auth_token + ',' + self._refresh_token) + print(f'[+] Auth tokens saved to `{token_fn}`') + + def _get_otp(self) -> str: + data = {'phone_number': self._phone_number} + r = self._session.post(auth.CODE_REQUEST_EP, data=json.dumps(data), verify=False) + response = r.json() + + if not response['data']['sms_sent']: + raise SMSNotSent + + otp_code = input('[?] OTP Response from SMS: ') + return otp_code + + def _get_refresh_token(self, otp_code: str) -> str: + data = {'otp_code': otp_code, 'phone_number': self._phone_number} + r = self._session.post(auth.CODE_VALIDATE_EP, data=json.dumps(data), verify=False) + response = r.json() + + if not response['data']['validated']: + raise ValidationFailed + + return response['data']['refresh_token'] + + def _get_api_token(self) -> str: + data = {'refresh_token': self._refresh_token} + r = self._session.post(auth.TOKEN_EP, data=json.dumps(data), verify=False) + response = r.json() + + return response['data']['api_token'] + + def login(self) -> None: + otp_code = self._get_otp() + self._refresh_token = self._get_refresh_token(otp_code) + self._auth_token = self._get_api_token() + + self._session.headers.update({'X-Auth-Token': self._auth_token}) + + self._logged = True + + self.save_token() diff --git a/src/tinder/v3/__init__.py b/src/tinder/v3/__init__.py new file mode 100644 index 0000000..b402b45 --- /dev/null +++ b/src/tinder/v3/__init__.py @@ -0,0 +1,6 @@ +import tinder + +class V3Exception(tinder.APIException): + pass + +URL = tinder.URL / 'v3' \ No newline at end of file diff --git a/src/tinder/v3/auth/__init__.py b/src/tinder/v3/auth/__init__.py new file mode 100644 index 0000000..9aba711 --- /dev/null +++ b/src/tinder/v3/auth/__init__.py @@ -0,0 +1,7 @@ +import tinder.v3 + +class AuthException(tinder.v3.V3Exception): + pass + +URL = tinder.v3.URL / 'auth' +LOGIN_EP = URL / 'login' \ No newline at end of file diff --git a/authgateway.proto b/src/tinder/v3/auth/authgateway.proto similarity index 96% rename from authgateway.proto rename to src/tinder/v3/auth/authgateway.proto index 9c9426b..4b8f638 100644 --- a/authgateway.proto +++ b/src/tinder/v3/auth/authgateway.proto @@ -1,12 +1,12 @@ -syntax = "proto3"; +syntax = 'proto3'; package tinder.services.authgateway; -import "google/protobuf/wrappers.proto"; -import "google/protobuf/timestamp.proto"; +import 'google/protobuf/wrappers.proto'; +import 'google/protobuf/timestamp.proto'; option java_multiple_files = true; -option java_package = "com.tinder.generated.model.services.shared.authgateway"; +option java_package = 'com.tinder.generated.model.services.shared.authgateway'; message MetaProto { google.protobuf.Timestamp upstream_time = 1; diff --git a/authgateway.py b/src/tinder/v3/auth/authgateway.py similarity index 71% rename from authgateway.py rename to src/tinder/v3/auth/authgateway.py index 6b5d102..d26b407 100644 --- a/authgateway.py +++ b/src/tinder/v3/auth/authgateway.py @@ -64,7 +64,7 @@ class GetEmailState(betterproto.Message): refresh_token: Optional[str] = betterproto.message_field( 1, wraps=betterproto.TYPE_STRING ) - email_marketing: "EmailMarketing" = betterproto.message_field(2) + email_marketing: 'EmailMarketing' = betterproto.message_field(2) @dataclass @@ -78,9 +78,9 @@ class ValidateEmailOtpState(betterproto.Message): email_sent: Optional[bool] = betterproto.message_field( 5, wraps=betterproto.TYPE_BOOL ) - email_marketing: "EmailMarketing" = betterproto.message_field(6) - unmasked_email: str = betterproto.string_field(2, group="email") - masked_email: str = betterproto.string_field(3, group="email") + email_marketing: 'EmailMarketing' = betterproto.message_field(6) + unmasked_email: str = betterproto.string_field(2, group='email') + masked_email: str = betterproto.string_field(3, group='email') @dataclass @@ -94,7 +94,7 @@ class OnboardingState(betterproto.Message): class LoginResult(betterproto.Message): refresh_token: str = betterproto.string_field(1) auth_token: str = betterproto.string_field(2) - captcha: "LoginResultCaptcha" = betterproto.enum_field(3) + captcha: 'LoginResultCaptcha' = betterproto.enum_field(3) user_id: str = betterproto.string_field(4) auth_token_ttl: Optional[int] = betterproto.message_field( 5, wraps=betterproto.TYPE_INT64 @@ -111,7 +111,7 @@ class AppleAccountNotFound(betterproto.Message): @dataclass class SocialConnection(betterproto.Message): - service: "SocialConnectionService" = betterproto.enum_field(1) + service: 'SocialConnectionService' = betterproto.enum_field(1) @dataclass @@ -119,7 +119,7 @@ class SocialConnectionList(betterproto.Message): refresh_token: Optional[str] = betterproto.message_field( 1, wraps=betterproto.TYPE_STRING ) - connections: List["SocialConnection"] = betterproto.message_field(2) + connections: List['SocialConnection'] = betterproto.message_field(2) @dataclass @@ -129,26 +129,26 @@ class ValidateEmailMagicLinkOtpState(betterproto.Message): @dataclass class AuthGatewayResponse(betterproto.Message): - meta: "MetaProto" = betterproto.message_field(1) - error: "ErrorProto" = betterproto.message_field(2) - get_phone_state: "GetPhoneState" = betterproto.message_field(3, group="data") - validate_phone_otp_state: "ValidatePhoneOtpState" = betterproto.message_field( - 4, group="data" + meta: 'MetaProto' = betterproto.message_field(1) + error: 'ErrorProto' = betterproto.message_field(2) + get_phone_state: 'GetPhoneState' = betterproto.message_field(3, group='data') + validate_phone_otp_state: 'ValidatePhoneOtpState' = betterproto.message_field( + 4, group='data' ) - get_email_state: "GetEmailState" = betterproto.message_field(5, group="data") - validate_email_otp_state: "ValidateEmailOtpState" = betterproto.message_field( - 6, group="data" + get_email_state: 'GetEmailState' = betterproto.message_field(5, group='data') + validate_email_otp_state: 'ValidateEmailOtpState' = betterproto.message_field( + 6, group='data' ) - onboarding_state: "OnboardingState" = betterproto.message_field(7, group="data") - login_result: "LoginResult" = betterproto.message_field(8, group="data") - social_connection_list: "SocialConnectionList" = betterproto.message_field( - 9, group="data" + onboarding_state: 'OnboardingState' = betterproto.message_field(7, group='data') + login_result: 'LoginResult' = betterproto.message_field(8, group='data') + social_connection_list: 'SocialConnectionList' = betterproto.message_field( + 9, group='data' ) - apple_account_not_found: "AppleAccountNotFound" = betterproto.message_field( - 10, group="data" + apple_account_not_found: 'AppleAccountNotFound' = betterproto.message_field( + 10, group='data' ) - validate_email_magic_link_otp_state: "ValidateEmailMagicLinkOtpState" = betterproto.message_field( - 11, group="data" + validate_email_magic_link_otp_state: 'ValidateEmailMagicLinkOtpState' = betterproto.message_field( + 11, group='data' ) @@ -167,13 +167,13 @@ class Phone(betterproto.Message): 2, wraps=betterproto.TYPE_STRING ) captcha_token: Optional[str] = betterproto.message_field( - 3, group="check", wraps=betterproto.TYPE_STRING + 3, group='check', wraps=betterproto.TYPE_STRING ) ios_device_token: Optional[str] = betterproto.message_field( - 4, group="check", wraps=betterproto.TYPE_STRING + 4, group='check', wraps=betterproto.TYPE_STRING ) android_jws: Optional[str] = betterproto.message_field( - 5, group="check", wraps=betterproto.TYPE_STRING + 5, group='check', wraps=betterproto.TYPE_STRING ) @@ -184,10 +184,10 @@ class PhoneOtpResend(betterproto.Message): 2, wraps=betterproto.TYPE_STRING ) ios_device_token: Optional[str] = betterproto.message_field( - 3, group="check", wraps=betterproto.TYPE_STRING + 3, group='check', wraps=betterproto.TYPE_STRING ) android_jws: Optional[str] = betterproto.message_field( - 4, group="check", wraps=betterproto.TYPE_STRING + 4, group='check', wraps=betterproto.TYPE_STRING ) @@ -282,23 +282,23 @@ class EmailMagicLinkOtp(betterproto.Message): @dataclass class AuthGatewayRequest(betterproto.Message): - phone: "Phone" = betterproto.message_field(1, group="factor") - phone_otp: "PhoneOtp" = betterproto.message_field(2, group="factor") - email: "Email" = betterproto.message_field(3, group="factor") - google_token: "GoogleToken" = betterproto.message_field(4, group="factor") - email_otp: "EmailOtp" = betterproto.message_field(5, group="factor") - facebook_token: "FacebookToken" = betterproto.message_field(6, group="factor") - phone_otp_resend: "PhoneOtpResend" = betterproto.message_field(7, group="factor") - email_otp_resend: "EmailOtpResend" = betterproto.message_field(8, group="factor") - get_initial_state: "GetInitialState" = betterproto.message_field(9, group="factor") - refresh_auth: "RefreshAuth" = betterproto.message_field(10, group="factor") - apple_token: "AppleToken" = betterproto.message_field(11, group="factor") - dismiss_social_connection_list: "DismissSocialConnectionList" = betterproto.message_field( - 12, group="factor" + phone: 'Phone' = betterproto.message_field(1, group='factor') + phone_otp: 'PhoneOtp' = betterproto.message_field(2, group='factor') + email: 'Email' = betterproto.message_field(3, group='factor') + google_token: 'GoogleToken' = betterproto.message_field(4, group='factor') + email_otp: 'EmailOtp' = betterproto.message_field(5, group='factor') + facebook_token: 'FacebookToken' = betterproto.message_field(6, group='factor') + phone_otp_resend: 'PhoneOtpResend' = betterproto.message_field(7, group='factor') + email_otp_resend: 'EmailOtpResend' = betterproto.message_field(8, group='factor') + get_initial_state: 'GetInitialState' = betterproto.message_field(9, group='factor') + refresh_auth: 'RefreshAuth' = betterproto.message_field(10, group='factor') + apple_token: 'AppleToken' = betterproto.message_field(11, group='factor') + dismiss_social_connection_list: 'DismissSocialConnectionList' = betterproto.message_field( + 12, group='factor' ) - email_magic_link: "EmailMagicLink" = betterproto.message_field(13, group="factor") - email_magic_link_otp: "EmailMagicLinkOtp" = betterproto.message_field( - 14, group="factor" + email_magic_link: 'EmailMagicLink' = betterproto.message_field(13, group='factor') + email_magic_link_otp: 'EmailMagicLinkOtp' = betterproto.message_field( + 14, group='factor' ) @@ -316,7 +316,7 @@ class UnderageBan(betterproto.Message): underage_token: Optional[str] = betterproto.message_field( 2, wraps=betterproto.TYPE_STRING ) - verification: "Verification" = betterproto.message_field(3) + verification: 'Verification' = betterproto.message_field(3) @dataclass @@ -328,12 +328,12 @@ class BanAppeal(betterproto.Message): @dataclass class BanReason(betterproto.Message): - underage_ban: "UnderageBan" = betterproto.message_field(1, group="reason") - ban_appeal: "BanAppeal" = betterproto.message_field(2, group="reason") + underage_ban: 'UnderageBan' = betterproto.message_field(1, group='reason') + ban_appeal: 'BanAppeal' = betterproto.message_field(2, group='reason') @dataclass class ErrorProto(betterproto.Message): code: int = betterproto.int32_field(1) message: str = betterproto.string_field(2) - ban_reason: "BanReason" = betterproto.message_field(3) + ban_reason: 'BanReason' = betterproto.message_field(3) diff --git a/src/tinder/v3/auth/sms.py b/src/tinder/v3/auth/sms.py new file mode 100644 index 0000000..8927a1d --- /dev/null +++ b/src/tinder/v3/auth/sms.py @@ -0,0 +1,177 @@ +import sys +import string +import random +import secrets +import uuid +from typing import Any +from pathlib import Path + +import requests + +import tinder.v2 as v2 +import tinder.v3.auth as auth +import tinder.v3.auth.authgateway as agw +from tinder.user import User + +class SMSAuthException(auth.AuthException): + pass + +class SMSNotSent(SMSAuthException): + pass + +class SMSUser(User): + + def __init__(self, phone_number: str, email: str = None, token_fn: str = None) -> None: + super().__init__() + + self._install_id = ''.join(random.choices(string.ascii_uppercase + string.ascii_lowercase + string.digits, k=11)) + + self._funnel_id = str(uuid.uuid4()) + self._app_session_id = str(uuid.uuid4()) + self._device_id = secrets.token_hex(8) + self._phone_number = phone_number + self._email = email + + self._auth_token: str = None + self._refresh_token: str = None + self._user_id: str = None + + self._session.headers.update({'user-agent': 'Tinder Android Version 11.24.0'}) + + self.load_token(token_fn) + + def load_token(self, token_fn: str) -> None: + token_fn = token_fn or self._phone_number + '_token.txt' + + token_file = Path(token_fn) + if token_file.exists(): + print(f'[+] `{token_fn}` found.\n[+] If you wish to auth again from scratch, delete it.') + with token_file.open() as fh: + tokens = fh.read() + auth_token, refresh_token = tokens.split(',') + self._auth_token = auth_token + self._refresh_token = refresh_token + + def save_token(self, token_fn: str = None) -> None: + if self._auth_token is None or self._refresh_token is None: + print('[!] Missing tokens to save.') + return + + token_fn = token_fn or self._phone_number + '_token.txt' + token_file = Path(token_fn) + + if token_file.exists(): + token_file.unlink() + + with token_file.open('w', encoding='utf-8') as fh: + fh.write(self._auth_token + ',' + self._refresh_token) + print(f'[+] Auth tokens saved to `{token_fn}`') + + def _post_login(self, body: agw.AuthGatewayRequest, headers: dict[str, Any] = None) -> agw.AuthGatewayResponse: + if headers is not None: + self._session.headers.update(headers) + + r = self._session.post(auth.LOGIN_EP, data=bytes(body)) + response = agw.AuthGatewayResponse().parse(r.content).to_dict() + return response + + def _login_wrapper(self, body: agw.AuthGatewayRequest, seconds: int, headers: dict[str, Any] = None) -> dict[str, Any]: + response = self._post_login(body, headers) + message_response: Optionnal[agw.AuthGatewayRequest] = None + + if 'validatePhoneOtpState' in response: + if not response['validatePhoneOtpState']['smsSent']: + raise SMSNotSent + + otp_code = input('[?] OTP Response from SMS: ') + otp = agw.PhoneOtp(phone=self._phone_number, otp=otp_code) + message_response = agw.AuthGatewayRequest(phone_otp=otp) + + elif 'getPhoneState' in response: + self._refresh_token = response['getPhoneState']['refreshToken'] + refresh_token = agw.RefreshAuth(refresh_token=self._refresh_token) + message_response = agw.AuthGatewayRequest(refresh_auth=refresh_token) + + elif 'validateEmailOtpState' in response and response['validateEmailOtpState']['emailSent']: + email_opt_code = input('[?] Check your email and input the verification code just sent to you: ') + email_refresh_token = response['validateEmailOtpState']['refreshToken'] + + if self._email is None: + self._email = input('[?] Input your email: ') + + email_otp = agw.EmailOtp(otp=email_opt_code, email=self._email, refresh_token=email_refresh_token) + message_response = agw.AuthGatewayRequest(email_otp=email_otp) + + elif 'getEmailState' in response: + email_refresh_token = response['getEmailState']['refreshToken'] + if self.email is None: + self.email = input('Input your email: ') + email = agw.Email(email=self._email, refresh_token=email_refresh_token) + message_response = agw.AuthGatewayRequest(email=email) + + elif 'error' in response and response['error']['message'] == 'INVALID_REFRESH_TOKEN': + print('[!] Refresh token error, restarting auth.') + self._phone_number = input('[?] Phone number (starting with 1, numbers only): ') + phone = agw.Phone(phone=self._phone_number) + message_response = agw.AuthGatewayRequest(phone=phone) + + elif 'error' in response: + raise SMSAuthException(response['error']['message']) + + elif 'loginResult' in response and 'authToken' in response['loginResult']: + return response + + if message_response is not None: + seconds += random.uniform(30, 90) + header_timer = {'app-session-time-elapsed': format(seconds, '.3f')} + return self._login_wrapper(message_response, seconds, header_timer) + + raise SMSAuthException('Unknown error.') + + def login(self) -> None: + payload = { + 'device_id': self._install_id, + 'experiments': ['default_login_token', + 'tinder_u_verification_method', + 'tinder_rules', + 'user_interests_available'] + } + self._session.post(v2.BUCKET_EP, json=payload) + + if self._refresh_token is not None: + print('[+] Attempting to refresh auth token with saved refresh token.') + initial_state = agw.GetInitialState(refresh_token=self._refresh_token) + message_out = agw.AuthGatewayRequest(get_initial_state=initial_state) + else: + phone = agw.Phone(phone=self._phone_number) + message_out = agw.AuthGatewayRequest(phone=phone) + + seconds = random.uniform(100, 250) + headers = { + 'tinder-version': '12.6.0', + 'install-id': self._install_id, + 'user-agent': 'Tinder Android Version 12.6.0', + 'connection': 'close', + 'platform-variant': 'Google-Play', + 'persistent-device-id': self._device_id, + 'accept-encoding': 'gzip, deflate', + 'appsflyer-id': '1600144077225-7971032049730563486', + 'platform': 'android', + 'app-version': '4023', + 'os-version': '25', + 'app-session-id': self._app_session_id, + 'x-supported-image-formats': 'webp', + 'funnel-session-id': self._funnel_id, + 'app-session-time-elapsed': format(seconds, '.3f'), + 'accept-language': 'en-US', + 'content-type': 'application/x-protobuf' + } + response = self._login_wrapper(message_out, seconds, headers) + + self._refresh_token = response['loginResult']['refreshToken'] + self._auth_token = response['loginResult']['authToken'] + self._session.headers.update({'X-Auth-Token': self._auth_token}) + + self._logged = True + + self.save_token() diff --git a/test.py b/test.py new file mode 100644 index 0000000..857a28a --- /dev/null +++ b/test.py @@ -0,0 +1,13 @@ +from tinder.v3.auth.sms import SMSUser +from tinder.v2.auth.facebook import FBUSer + +if __name__ == '__main__': + # v3 SMS authentication + user = SMSUser('phone', email='email') + user.login() + user.like_all() + + # v2 FB authentication + user = FBUSer('fb email', 'fb password') + user.login() + user.like_all() \ No newline at end of file diff --git a/tinder_api_sms.py b/tinder_api_sms.py deleted file mode 100644 index 2419e61..0000000 --- a/tinder_api_sms.py +++ /dev/null @@ -1,232 +0,0 @@ -# coding=utf-8 -import json - -import config -import requests - -headers = { - 'app_version': '6.9.4', - 'platform': 'ios', - "content-type": "application/json", - "User-agent": "Tinder/7.5.3 (iPhone; iOS 10.3.2; Scale/2.00)", - "X-Auth-Token": config.tinder_token, -} - - - -def get_recommendations(): - ''' - Returns a list of users that you can swipe on - ''' - try: - r = requests.get('https://api.gotinder.com/user/recs', headers=headers) - return r.json() - except requests.exceptions.RequestException as e: - print("Something went wrong with getting recomendations:", e) - - -def get_updates(last_activity_date=""): - ''' - Returns all updates since the given activity date. - The last activity date is defaulted at the beginning of time. - Format for last_activity_date: "2017-07-09T10:28:13.392Z" - ''' - try: - url = config.host + '/updates' - r = requests.post(url, - headers=headers, - data=json.dumps({"last_activity_date": last_activity_date})) - return r.json() - except requests.exceptions.RequestException as e: - print("Something went wrong with getting updates:", e) - - -def get_self(): - ''' - Returns your own profile data - ''' - try: - url = config.host + '/profile' - r = requests.get(url, headers=headers) - return r.json() - except requests.exceptions.RequestException as e: - print("Something went wrong. Could not get your data:", e) - - -def change_preferences(**kwargs): - ''' - ex: change_preferences(age_filter_min=30, gender=0) - kwargs: a dictionary - whose keys become separate keyword arguments and the values become values of these arguments - age_filter_min: 18..46 - age_filter_max: 22..55 - age_filter_min <= age_filter_max - 4 - gender: 0 == seeking males, 1 == seeking females - distance_filter: 1..100 - discoverable: true | false - {"photo_optimizer_enabled":false} - ''' - try: - url = config.host + '/profile' - r = requests.post(url, headers=headers, data=json.dumps(kwargs)) - return r.json() - except requests.exceptions.RequestException as e: - print("Something went wrong. Could not change your preferences:", e) - - -def get_meta(): - ''' - Returns meta data on yourself. Including the following keys: - ['globals', 'client_resources', 'versions', 'purchases', - 'status', 'groups', 'products', 'rating', 'tutorials', - 'travel', 'notifications', 'user'] - ''' - try: - url = config.host + '/meta' - r = requests.get(url, headers=headers) - return r.json() - except requests.exceptions.RequestException as e: - print("Something went wrong. Could not get your metadata:", e) - -def update_location(lat, lon): - ''' - Updates your location to the given float inputs - Note: Requires a passport / Tinder Plus - ''' - try: - url = config.host + '/passport/user/travel' - r = requests.post(url, headers=headers, data=json.dumps({"lat": lat, "lon": lon})) - return r.json() - except requests.exceptions.RequestException as e: - print("Something went wrong. Could not update your location:", e) - -def reset_real_location(): - try: - url = config.host + '/passport/user/reset' - r = requests.post(url, headers=headers) - return r.json() - except requests.exceptions.RequestException as e: - print("Something went wrong. Could not update your location:", e) - - -def get_recs_v2(): - ''' - This works more consistently then the normal get_recommendations becuase it seeems to check new location - ''' - try: - url = config.host + '/v2/recs/core?locale=en-US' - r = requests.get(url, headers=headers) - return r.json() - except Exception as e: - print('excepted') - -def set_webprofileusername(username): - ''' - Sets the username for the webprofile: https://www.gotinder.com/@YOURUSERNAME - ''' - try: - url = config.host + '/profile/username' - r = requests.put(url, headers=headers, - data=json.dumps({"username": username})) - return r.json() - except requests.exceptions.RequestException as e: - print("Something went wrong. Could not set webprofile username:", e) - -def reset_webprofileusername(username): - ''' - Resets the username for the webprofile - ''' - try: - url = config.host + '/profile/username' - r = requests.delete(url, headers=headers) - return r.json() - except requests.exceptions.RequestException as e: - print("Something went wrong. Could not delete webprofile username:", e) - -def get_person(id): - ''' - Gets a user's profile via their id - ''' - try: - url = config.host + '/user/%s' % id - r = requests.get(url, headers=headers) - return r.json() - except requests.exceptions.RequestException as e: - print("Something went wrong. Could not get that person:", e) - - -def send_msg(match_id, msg): - try: - url = config.host + '/user/matches/%s' % match_id - r = requests.post(url, headers=headers, - data=json.dumps({"message": msg})) - return r.json() - except requests.exceptions.RequestException as e: - print("Something went wrong. Could not send your message:", e) - - -def superlike(person_id): - try: - url = config.host + '/like/%s/super' % person_id - r = requests.post(url, headers=headers) - return r.json() - except requests.exceptions.RequestException as e: - print("Something went wrong. Could not superlike:", e) - - -def like(person_id): - try: - url = config.host + '/like/%s' % person_id - r = requests.get(url, headers=headers) - return r.json() - except requests.exceptions.RequestException as e: - print("Something went wrong. Could not like:", e) - - -def dislike(person_id): - try: - url = config.host + '/pass/%s' % person_id - r = requests.get(url, headers=headers) - return r.json() - except requests.exceptions.RequestException as e: - print("Something went wrong. Could not dislike:", e) - - -def report(person_id, cause, explanation=''): - ''' - There are three options for cause: - 0 : Other and requires an explanation - 1 : Feels like spam and no explanation - 4 : Inappropriate Photos and no explanation - ''' - try: - url = config.host + '/report/%s' % person_id - r = requests.post(url, headers=headers, data={ - "cause": cause, "text": explanation}) - return r.json() - except requests.exceptions.RequestException as e: - print("Something went wrong. Could not report:", e) - - -def match_info(match_id): - try: - url = config.host + '/matches/%s' % match_id - r = requests.get(url, headers=headers) - return r.json() - except requests.exceptions.RequestException as e: - print("Something went wrong. Could not get your match info:", e) - -def all_matches(): - try: - url = config.host + '/v2/matches' - r = requests.get(url, headers=headers) - return r.json() - except requests.exceptions.RequestException as e: - print("Something went wrong. Could not get your match info:", e) - -# def see_friends(): -# try: -# url = config.host + '/group/friends' -# r = requests.get(url, headers=headers) -# return r.json()['results'] -# except requests.exceptions.RequestException as e: -# print("Something went wrong. Could not get your Facebook friends:", e) diff --git a/tinder_config_ex.py b/tinder_config_ex.py deleted file mode 100644 index 454a284..0000000 --- a/tinder_config_ex.py +++ /dev/null @@ -1,13 +0,0 @@ -import fb_auth_token - -fb_username = """Your fb username goes here.""" -fb_password = """Your fb password goes here.""" -fb_access_token = fb_auth_token.get_fb_access_token(fb_username, fb_password) -fb_user_id = fb_auth_token.get_fb_id(fb_access_token) -host = 'https://api.gotinder.com' -#leave tinder_token empty if you don't use phone verification -tinder_token = "Your tinder token goes here" - -# Your real config file should simply be named "config.py" -# Just insert your fb_username and fb_password in string format -# and the fb_auth_token.py module will do the rest! From 334d22c602c18dcc66780197deeb12da972b3928 Mon Sep 17 00:00:00 2001 From: "maxime.peim" Date: Wed, 13 Oct 2021 16:11:02 +0200 Subject: [PATCH 12/23] Correction on v2 --- src/tinder/v2/auth/facebook.py | 5 ++--- src/tinder/v2/auth/sms.py | 22 ++++++++++++++++------ test.py | 4 +++- 3 files changed, 21 insertions(+), 10 deletions(-) diff --git a/src/tinder/v2/auth/facebook.py b/src/tinder/v2/auth/facebook.py index ef4201d..59bb27b 100644 --- a/src/tinder/v2/auth/facebook.py +++ b/src/tinder/v2/auth/facebook.py @@ -70,13 +70,12 @@ def _get_fb_id(self, fb_token: str): def login(self): fb_token = self._get_fb_token() fb_id = self._get_fb_id(fb_token) + data = {'token': fb_token, 'facebook_id': fb_id} try: r = self._session.post( auth.LOGIN_FB_EP, - data=json.dumps( - {'token': fb_token, 'facebook_id': fb_id} - ) + json=data ) print(r.json()) diff --git a/src/tinder/v2/auth/sms.py b/src/tinder/v2/auth/sms.py index bace572..9d67c95 100644 --- a/src/tinder/v2/auth/sms.py +++ b/src/tinder/v2/auth/sms.py @@ -10,6 +10,7 @@ import tinder.v2.auth as auth from tinder.user import User +from tinder import Url class SMSAuthException(auth.AuthException): pass @@ -25,6 +26,9 @@ class SMSUser(User): def __init__(self, phone_number: str, email: str = None, token_fn: str = None) -> None: super().__init__() + self._phone_number = phone_number + self._email = email + self._auth_token: str = None self._refresh_token: str = None self._user_id: str = None @@ -63,10 +67,18 @@ def save_token(self, token_fn: str = None) -> None: fh.write(self._auth_token + ',' + self._refresh_token) print(f'[+] Auth tokens saved to `{token_fn}`') + def _post_login(self, url: Url, payload: dict) -> dict: + r = self._session.post(url, json=payload) + response = r.json() + + if 'error' in response: + raise SMSAuthException(response['error']['message']) + + return response + def _get_otp(self) -> str: data = {'phone_number': self._phone_number} - r = self._session.post(auth.CODE_REQUEST_EP, data=json.dumps(data), verify=False) - response = r.json() + response = self._post_login(auth.CODE_REQUEST_EP, data) if not response['data']['sms_sent']: raise SMSNotSent @@ -76,8 +88,7 @@ def _get_otp(self) -> str: def _get_refresh_token(self, otp_code: str) -> str: data = {'otp_code': otp_code, 'phone_number': self._phone_number} - r = self._session.post(auth.CODE_VALIDATE_EP, data=json.dumps(data), verify=False) - response = r.json() + response = self._post_login(auth.CODE_VALIDATE_EP, data) if not response['data']['validated']: raise ValidationFailed @@ -86,8 +97,7 @@ def _get_refresh_token(self, otp_code: str) -> str: def _get_api_token(self) -> str: data = {'refresh_token': self._refresh_token} - r = self._session.post(auth.TOKEN_EP, data=json.dumps(data), verify=False) - response = r.json() + response = self._post_login(auth.TOKEN_EP, data) return response['data']['api_token'] diff --git a/test.py b/test.py index 857a28a..2ee29c6 100644 --- a/test.py +++ b/test.py @@ -7,7 +7,9 @@ user.login() user.like_all() + """ # v2 FB authentication user = FBUSer('fb email', 'fb password') user.login() - user.like_all() \ No newline at end of file + user.like_all() + """ \ No newline at end of file From 14f6c1b81470b756697d92dbd0b9b59493511170 Mon Sep 17 00:00:00 2001 From: "maxime.peim" Date: Wed, 13 Oct 2021 16:49:35 +0200 Subject: [PATCH 13/23] Restore test --- .gitignore | 1 + test.py | 4 +--- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/.gitignore b/.gitignore index 211e386..0d6c1d6 100644 --- a/.gitignore +++ b/.gitignore @@ -7,6 +7,7 @@ find.py *.log *.egg-info env/ +maxime.py .idea/ .vscode/ diff --git a/test.py b/test.py index 2ee29c6..857a28a 100644 --- a/test.py +++ b/test.py @@ -7,9 +7,7 @@ user.login() user.like_all() - """ # v2 FB authentication user = FBUSer('fb email', 'fb password') user.login() - user.like_all() - """ \ No newline at end of file + user.like_all() \ No newline at end of file From a3ffd4f54936b172f84f1aefa7e367a775094b65 Mon Sep 17 00:00:00 2001 From: "maxime.peim" Date: Thu, 14 Oct 2021 11:34:12 +0200 Subject: [PATCH 14/23] Fixed error in like function --- src/tinder/user.py | 17 ++++++----------- test.py | 4 +--- 2 files changed, 7 insertions(+), 14 deletions(-) diff --git a/src/tinder/user.py b/src/tinder/user.py index fc9f054..7371513 100644 --- a/src/tinder/user.py +++ b/src/tinder/user.py @@ -35,17 +35,12 @@ def recs(self) -> dict: return recs @need_logged - def like(self, user_rec) -> dict: - r = self._session.get(tinder.LIKE_EP / self.id) - return r.json() - - @need_logged - def like_all(self) -> None: - for rec in self.recs: - if rec.rec_type == 'user': - print(rec.name) - print(self.like(rec)) - print() + def like(self, user_rec) -> tuple[bool, int]: + r = self._session.get(tinder.LIKE_EP / user_rec.id) + response = r.json() + match = response['match'] + like_remaining = response['likes_remaining'] + return match, like_remaining def login(self) -> None: raise NotImplementedError \ No newline at end of file diff --git a/test.py b/test.py index 857a28a..ff57f92 100644 --- a/test.py +++ b/test.py @@ -5,9 +5,7 @@ # v3 SMS authentication user = SMSUser('phone', email='email') user.login() - user.like_all() # v2 FB authentication user = FBUSer('fb email', 'fb password') - user.login() - user.like_all() \ No newline at end of file + user.login() \ No newline at end of file From c1aca71013489806eea54bf4e7b201614fc2b4dc Mon Sep 17 00:00:00 2001 From: "maxime.peim" Date: Thu, 14 Oct 2021 13:21:15 +0200 Subject: [PATCH 15/23] - Added option to let the user refresh his auth token. - make_request decorator for user's requests once logged. --- README.md | 5 ++++- src/tinder/user.py | 26 +++++++++++++++++++------ src/tinder/v3/auth/sms.py | 40 +++++++++++++++++++++++++++------------ test.py | 2 +- 4 files changed, 53 insertions(+), 20 deletions(-) diff --git a/README.md b/README.md index 84b96d8..24b49e1 100644 --- a/README.md +++ b/README.md @@ -30,7 +30,7 @@ First off, I want to give a shoutout to + @@ -508,3 +508,6 @@ The following is a sample result for friends_pingtimes(): } } ``` +### TODO + - Write a better updated README.md + - Continue adding features to User class \ No newline at end of file diff --git a/src/tinder/user.py b/src/tinder/user.py index 7371513..97c013b 100644 --- a/src/tinder/user.py +++ b/src/tinder/user.py @@ -1,3 +1,6 @@ +from functools import reduce, wraps +from typing import Any + import requests import tinder @@ -13,21 +16,33 @@ def __init__(self) -> None: self._session = requests.Session() def need_logged(func): + @wraps(func) def wrapper(self, *args, **kwargs): if not self._logged: raise UserNotLoggedException(f'The user need to be logged to call the function {func}') return func(self, *args, **kwargs) return wrapper + def make_request(url): + def inner_deco(func): + @wraps(func) + def wrapper(self, *params, **kwargs): + complete_url = reduce(lambda a, b: a / b, [url, *params]) + r = self._session.get(complete_url) + response = r.json() + return func(self, response, **kwargs) + return wrapper + return inner_deco + @property def logged(self) -> bool: return self._logged @property @need_logged - def recs(self) -> dict: - r = self._session.get(tinder.RECS_EP) - result = r.json()['results'] + @make_request(tinder.RECS_EP) + def recs(self, response: dict[str, Any]) -> list[Rec]: + result = response['results'] recs = [ Rec.create(infos) for infos in result @@ -35,9 +50,8 @@ def recs(self) -> dict: return recs @need_logged - def like(self, user_rec) -> tuple[bool, int]: - r = self._session.get(tinder.LIKE_EP / user_rec.id) - response = r.json() + @make_request(tinder.LIKE_EP) + def like(self, response: dict[str, Any]) -> tuple[bool, int]: match = response['match'] like_remaining = response['likes_remaining'] return match, like_remaining diff --git a/src/tinder/v3/auth/sms.py b/src/tinder/v3/auth/sms.py index 8927a1d..b03c4ce 100644 --- a/src/tinder/v3/auth/sms.py +++ b/src/tinder/v3/auth/sms.py @@ -19,9 +19,12 @@ class SMSAuthException(auth.AuthException): class SMSNotSent(SMSAuthException): pass +class MissingToken(SMSAuthException): + pass + class SMSUser(User): - def __init__(self, phone_number: str, email: str = None, token_fn: str = None) -> None: + def __init__(self, phone_number: str, email: str = None, token_fn: str = None, need_refresh: bool = False) -> None: super().__init__() self._install_id = ''.join(random.choices(string.ascii_uppercase + string.ascii_lowercase + string.digits, k=11)) @@ -31,6 +34,7 @@ def __init__(self, phone_number: str, email: str = None, token_fn: str = None) - self._device_id = secrets.token_hex(8) self._phone_number = phone_number self._email = email + self._need_refresh = need_refresh self._auth_token: str = None self._refresh_token: str = None @@ -45,17 +49,19 @@ def load_token(self, token_fn: str) -> None: token_file = Path(token_fn) if token_file.exists(): - print(f'[+] `{token_fn}` found.\n[+] If you wish to auth again from scratch, delete it.') + print(f'[+] `{token_fn}` found.') + print('[+] If you wish to auth again from scratch, delete it.') with token_file.open() as fh: tokens = fh.read() auth_token, refresh_token = tokens.split(',') self._auth_token = auth_token self._refresh_token = refresh_token + else: + self._need_refresh = False def save_token(self, token_fn: str = None) -> None: if self._auth_token is None or self._refresh_token is None: - print('[!] Missing tokens to save.') - return + raise MissingToken token_fn = token_fn or self._phone_number + '_token.txt' token_file = Path(token_fn) @@ -137,14 +143,6 @@ def login(self) -> None: 'user_interests_available'] } self._session.post(v2.BUCKET_EP, json=payload) - - if self._refresh_token is not None: - print('[+] Attempting to refresh auth token with saved refresh token.') - initial_state = agw.GetInitialState(refresh_token=self._refresh_token) - message_out = agw.AuthGatewayRequest(get_initial_state=initial_state) - else: - phone = agw.Phone(phone=self._phone_number) - message_out = agw.AuthGatewayRequest(phone=phone) seconds = random.uniform(100, 250) headers = { @@ -166,6 +164,24 @@ def login(self) -> None: 'accept-language': 'en-US', 'content-type': 'application/x-protobuf' } + + if self._need_refresh: + print('[+] Attempting to refresh auth token with saved refresh token.') + initial_state = agw.GetInitialState(refresh_token=self._refresh_token) + message_out = agw.AuthGatewayRequest(get_initial_state=initial_state) + + elif self._auth_token is not None: + print('[+] Attempting to use saved auth token, might failed if expired.') + self._session.headers.update(headers) + self._session.headers.update({'X-Auth-Token': self._auth_token}) + self._logged = True + return + + else: + print('[+] Attempting SMS auth.') + phone = agw.Phone(phone=self._phone_number) + message_out = agw.AuthGatewayRequest(phone=phone) + response = self._login_wrapper(message_out, seconds, headers) self._refresh_token = response['loginResult']['refreshToken'] diff --git a/test.py b/test.py index ff57f92..03f6c80 100644 --- a/test.py +++ b/test.py @@ -6,6 +6,6 @@ user = SMSUser('phone', email='email') user.login() - # v2 FB authentication + # v2 FB authentication, not tested user = FBUSer('fb email', 'fb password') user.login() \ No newline at end of file From d7cf4612e885c7312cf5230a04b55b2261a9b97d Mon Sep 17 00:00:00 2001 From: "maxime.peim" Date: Thu, 14 Oct 2021 14:08:03 +0200 Subject: [PATCH 16/23] Updated README.md with installation steps. --- README.md | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/README.md b/README.md index 24b49e1..e4bc0fe 100644 --- a/README.md +++ b/README.md @@ -4,6 +4,18 @@ First off, I want to give a shoutout to From 6e6685a22e06a1574bdd04a9e0cfe75d8a4107e3 Mon Sep 17 00:00:00 2001 From: "maxime.peim" Date: Thu, 14 Oct 2021 15:52:27 +0200 Subject: [PATCH 17/23] Detect when there is no more recs. --- src/tinder/user.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/tinder/user.py b/src/tinder/user.py index 97c013b..1deeaf5 100644 --- a/src/tinder/user.py +++ b/src/tinder/user.py @@ -9,6 +9,9 @@ class UserNotLoggedException(tinder.APIException): pass +class NoMoreRecs(tinder.APIException): + pass + class User: def __init__(self) -> None: @@ -42,6 +45,9 @@ def logged(self) -> bool: @need_logged @make_request(tinder.RECS_EP) def recs(self, response: dict[str, Any]) -> list[Rec]: + if 'message' in response and response['message'] == 'recs timeout': + raise NoMoreRecs + result = response['results'] recs = [ Rec.create(infos) From f2d184bfeb8df8b6dcf891b8ecf72ac518f3aec9 Mon Sep 17 00:00:00 2001 From: "maxime.peim" Date: Thu, 14 Oct 2021 22:09:09 +0200 Subject: [PATCH 18/23] Updated error management on recs --- src/tinder/user.py | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/src/tinder/user.py b/src/tinder/user.py index 1deeaf5..a18627e 100644 --- a/src/tinder/user.py +++ b/src/tinder/user.py @@ -12,6 +12,13 @@ class UserNotLoggedException(tinder.APIException): class NoMoreRecs(tinder.APIException): pass +class UnknownError(tinder.APIException): + + def __init__(self, message: str = ''): + self.message = f'An unknow error as occured.\n{str(message)}' + super().__init__(self.message) + + class User: def __init__(self) -> None: @@ -47,6 +54,9 @@ def logged(self) -> bool: def recs(self, response: dict[str, Any]) -> list[Rec]: if 'message' in response and response['message'] == 'recs timeout': raise NoMoreRecs + + if 'results' not in response: + raise UnknownError(response) result = response['results'] recs = [ From 706d5194f3d9e853dbf8571355fde44712503d32 Mon Sep 17 00:00:00 2001 From: "maxime.peim" Date: Fri, 22 Oct 2021 05:20:00 +0200 Subject: [PATCH 19/23] Added retry exception --- src/tinder/recs.py | 11 +++++++++++ src/tinder/user.py | 13 +++++++------ 2 files changed, 18 insertions(+), 6 deletions(-) diff --git a/src/tinder/recs.py b/src/tinder/recs.py index ea6e40a..950bf64 100644 --- a/src/tinder/recs.py +++ b/src/tinder/recs.py @@ -2,6 +2,17 @@ import tinder +class TimeOutException(tinder.APIException): + + def __init__(self): + super().__init__('Time out while trying to get recs. Could be because there is no more.') + + +class RetryException(tinder.APIException): + + def __init__(self): + super().__init__('Failed to retrieve recs. Retry needed.') + class Rec: _subclasses = {} diff --git a/src/tinder/user.py b/src/tinder/user.py index a18627e..7b140b5 100644 --- a/src/tinder/user.py +++ b/src/tinder/user.py @@ -4,14 +4,11 @@ import requests import tinder -from tinder.recs import Rec +from tinder.recs import Rec, TimeOutException, RetryException class UserNotLoggedException(tinder.APIException): pass -class NoMoreRecs(tinder.APIException): - pass - class UnknownError(tinder.APIException): def __init__(self, message: str = ''): @@ -52,8 +49,12 @@ def logged(self) -> bool: @need_logged @make_request(tinder.RECS_EP) def recs(self, response: dict[str, Any]) -> list[Rec]: - if 'message' in response and response['message'] == 'recs timeout': - raise NoMoreRecs + if 'message' in response: + message = response['message'] + if message == 'recs timeout': + raise TimeOutException + elif message == 'retry required': + raise RetryException if 'results' not in response: raise UnknownError(response) From ff086bd9241f0242c79402a26e1e79762a966af4 Mon Sep 17 00:00:00 2001 From: "maxime.peim" Date: Tue, 2 Nov 2021 15:44:36 +0100 Subject: [PATCH 20/23] Added feature to retrieve matches in v3 --- src/tinder/__init__.py | 2 +- src/tinder/v2/__init__.py | 3 ++- src/tinder/v2/auth/facebook.py | 4 ++-- src/tinder/v2/auth/sms.py | 4 ++-- src/tinder/v2/user.py | 4 ++++ src/tinder/v3/auth/sms.py | 4 ++-- src/tinder/v3/user.py | 32 ++++++++++++++++++++++++++++++++ 7 files changed, 45 insertions(+), 8 deletions(-) create mode 100644 src/tinder/v2/user.py create mode 100644 src/tinder/v3/user.py diff --git a/src/tinder/__init__.py b/src/tinder/__init__.py index e474921..0659c77 100644 --- a/src/tinder/__init__.py +++ b/src/tinder/__init__.py @@ -16,4 +16,4 @@ def __truediv__(self, other_part: str = '') -> Url: URL = Url('https://api.gotinder.com') RECS_EP = URL / 'user' / 'recs' -LIKE_EP = URL / 'like' \ No newline at end of file +LIKE_EP = URL / 'like' diff --git a/src/tinder/v2/__init__.py b/src/tinder/v2/__init__.py index def5696..df343e3 100644 --- a/src/tinder/v2/__init__.py +++ b/src/tinder/v2/__init__.py @@ -5,4 +5,5 @@ class V2Exception(tinder.APIException): URL = tinder.URL / 'v2' BUCKET_EP = URL / 'buckets' -RECS_EP = URL / 'user' / 'recs' \ No newline at end of file +RECS_EP = URL / 'user' / 'recs' +MATCHES = URL / 'matches' \ No newline at end of file diff --git a/src/tinder/v2/auth/facebook.py b/src/tinder/v2/auth/facebook.py index 59bb27b..12d6f3e 100644 --- a/src/tinder/v2/auth/facebook.py +++ b/src/tinder/v2/auth/facebook.py @@ -12,7 +12,7 @@ import robobrowser import tinder.v2.auth as auth -from tinder.user import User +from tinder.v2.user import V2User class FBAuthException(auth.AuthException): @@ -25,7 +25,7 @@ class FBIdException(auth.AuthException): pass -class FBUSer(User): +class FBUSer(V2User): def __init__(self, email: str, password: str) -> None: super().__init__() diff --git a/src/tinder/v2/auth/sms.py b/src/tinder/v2/auth/sms.py index 9d67c95..369e90c 100644 --- a/src/tinder/v2/auth/sms.py +++ b/src/tinder/v2/auth/sms.py @@ -9,7 +9,7 @@ import requests import tinder.v2.auth as auth -from tinder.user import User +from tinder.v2.user import V2User from tinder import Url class SMSAuthException(auth.AuthException): @@ -21,7 +21,7 @@ class SMSNotSent(SMSAuthException): class ValidationFailed(SMSAuthException): pass -class SMSUser(User): +class SMSUser(V2User): def __init__(self, phone_number: str, email: str = None, token_fn: str = None) -> None: super().__init__() diff --git a/src/tinder/v2/user.py b/src/tinder/v2/user.py new file mode 100644 index 0000000..d825d48 --- /dev/null +++ b/src/tinder/v2/user.py @@ -0,0 +1,4 @@ +from tinder.user import User + +class V2User(User): + pass \ No newline at end of file diff --git a/src/tinder/v3/auth/sms.py b/src/tinder/v3/auth/sms.py index b03c4ce..0d82231 100644 --- a/src/tinder/v3/auth/sms.py +++ b/src/tinder/v3/auth/sms.py @@ -11,7 +11,7 @@ import tinder.v2 as v2 import tinder.v3.auth as auth import tinder.v3.auth.authgateway as agw -from tinder.user import User +from tinder.v3.user import V3User class SMSAuthException(auth.AuthException): pass @@ -22,7 +22,7 @@ class SMSNotSent(SMSAuthException): class MissingToken(SMSAuthException): pass -class SMSUser(User): +class SMSUser(V3User): def __init__(self, phone_number: str, email: str = None, token_fn: str = None, need_refresh: bool = False) -> None: super().__init__() diff --git a/src/tinder/v3/user.py b/src/tinder/v3/user.py new file mode 100644 index 0000000..07a298b --- /dev/null +++ b/src/tinder/v3/user.py @@ -0,0 +1,32 @@ +from typing import Any + +import tinder.v2 as v2 +from tinder.user import User + +class V3User(User): + + @User.need_logged + def matches(self, page_token: str = None) -> list: + url = v2.MATCHES + '?count=60' + (f'&page_token={page_token}' if page_token else '') + r = self._session.get(url) + response = r.json() + + if 'data' not in response or \ + 'matches' not in response['data']: + raise Exception + + matches = response['data']['matches'] + next_page_token = response['data'].get('next_page_token', None) + return matches, next_page_token + + @property + @User.need_logged + def all_matches(self) -> list: + matches = [] + next_page_token = '' + + while next_page_token is not None: + next_matches, next_page_token = self.matches(next_page_token) + matches += next_matches + + return matches \ No newline at end of file From ff544af1321dec4214bdb0d6375a791680c99862 Mon Sep 17 00:00:00 2001 From: "maxime.peim" Date: Tue, 2 Nov 2021 15:45:01 +0100 Subject: [PATCH 21/23] Added feature to retrieve matches in v2 --- src/tinder/v2/user.py | 27 ++++++++++++++++++++++++++- 1 file changed, 26 insertions(+), 1 deletion(-) diff --git a/src/tinder/v2/user.py b/src/tinder/v2/user.py index d825d48..19a9dfe 100644 --- a/src/tinder/v2/user.py +++ b/src/tinder/v2/user.py @@ -1,4 +1,29 @@ from tinder.user import User class V2User(User): - pass \ No newline at end of file + + @User.need_logged + def matches(self, page_token: str = None) -> list: + url = v2.MATCHES + '?count=60' + (f'&page_token={page_token}' if page_token else '') + r = self._session.get(url) + response = r.json() + + if 'data' not in response or \ + 'matches' not in response['data']: + raise Exception + + matches = response['data']['matches'] + next_page_token = response['data'].get('next_page_token', None) + return matches, next_page_token + + @property + @User.need_logged + def all_matches(self) -> list: + matches = [] + next_page_token = '' + + while next_page_token is not None: + next_matches, next_page_token = self.matches(next_page_token) + matches += next_matches + + return matches \ No newline at end of file From 06aab24484780cd35fd984c610c15b57dab395dd Mon Sep 17 00:00:00 2001 From: "maxime.peim" Date: Tue, 2 Nov 2021 15:46:54 +0100 Subject: [PATCH 22/23] Updated test.py --- test.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/test.py b/test.py index 03f6c80..d9552a4 100644 --- a/test.py +++ b/test.py @@ -6,6 +6,10 @@ user = SMSUser('phone', email='email') user.login() + matches = user.all_matches + # v2 FB authentication, not tested user = FBUSer('fb email', 'fb password') - user.login() \ No newline at end of file + user.login() + + matches = user.all_matches \ No newline at end of file From 82333eb11fc6e5c2bb61ce51b11e78910ef1dd37 Mon Sep 17 00:00:00 2001 From: "maxime.peim" Date: Tue, 2 Nov 2021 15:54:09 +0100 Subject: [PATCH 23/23] Updated matches functions --- src/tinder/v2/user.py | 9 ++++----- src/tinder/v3/user.py | 11 ++++++----- test.py | 4 ++-- 3 files changed, 12 insertions(+), 12 deletions(-) diff --git a/src/tinder/v2/user.py b/src/tinder/v2/user.py index 19a9dfe..a9dd8ef 100644 --- a/src/tinder/v2/user.py +++ b/src/tinder/v2/user.py @@ -3,8 +3,8 @@ class V2User(User): @User.need_logged - def matches(self, page_token: str = None) -> list: - url = v2.MATCHES + '?count=60' + (f'&page_token={page_token}' if page_token else '') + def matches(self, count: int = 60, page_token: str = None) -> list: + url = v2.MATCHES + f'?count={count}' + (f'&page_token={page_token}' if page_token else '') r = self._session.get(url) response = r.json() @@ -16,14 +16,13 @@ def matches(self, page_token: str = None) -> list: next_page_token = response['data'].get('next_page_token', None) return matches, next_page_token - @property @User.need_logged - def all_matches(self) -> list: + def all_matches(self, count: int = 60) -> list: matches = [] next_page_token = '' while next_page_token is not None: - next_matches, next_page_token = self.matches(next_page_token) + next_matches, next_page_token = self.matches(count, next_page_token) matches += next_matches return matches \ No newline at end of file diff --git a/src/tinder/v3/user.py b/src/tinder/v3/user.py index 07a298b..34a8d34 100644 --- a/src/tinder/v3/user.py +++ b/src/tinder/v3/user.py @@ -5,9 +5,11 @@ class V3User(User): + # Some functions are duplicated from v2 + # because they might change in the v3 @User.need_logged - def matches(self, page_token: str = None) -> list: - url = v2.MATCHES + '?count=60' + (f'&page_token={page_token}' if page_token else '') + def matches(self, count: int = 60, page_token: str = None) -> list: + url = v2.MATCHES + f'?count={count}' + (f'&page_token={page_token}' if page_token else '') r = self._session.get(url) response = r.json() @@ -19,14 +21,13 @@ def matches(self, page_token: str = None) -> list: next_page_token = response['data'].get('next_page_token', None) return matches, next_page_token - @property @User.need_logged - def all_matches(self) -> list: + def all_matches(self, count: int = 60) -> list: matches = [] next_page_token = '' while next_page_token is not None: - next_matches, next_page_token = self.matches(next_page_token) + next_matches, next_page_token = self.matches(count, next_page_token) matches += next_matches return matches \ No newline at end of file diff --git a/test.py b/test.py index d9552a4..a15d53a 100644 --- a/test.py +++ b/test.py @@ -6,10 +6,10 @@ user = SMSUser('phone', email='email') user.login() - matches = user.all_matches + matches = user.all_matches() # v2 FB authentication, not tested user = FBUSer('fb email', 'fb password') user.login() - matches = user.all_matches \ No newline at end of file + matches = user.all_matches() \ No newline at end of file