DMqhGe3Q

1import json
2import os
3import sys
4import uuid
5from itertools import cycle
6
7import logging
8import random
9import string
10import time
11import requests
12import hashlib
13
14# from convert_msg_access_token import convert_to_msg_token
15# from login import FBClient
16
17logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s %(module)s: %(message)s",
18                    datefmt='%Y-%m-%d %H:%M:%S')
19logger = logging.getLogger(__name__)
20
21class TokenManager:
22    TOKEN_MANAGER_API = "http://35.196.221.1:1001/api/db"
23
24    @classmethod
25    def get_token(cls):
26        res = requests.get(cls.TOKEN_MANAGER_API, timeout=10).json()
27        uid = res["uid"]
28        access_token = res["access_token"]
29        return uid, access_token
30
31    @classmethod
32    def push_token(cls, username, password, uid, access_token):
33        res = requests.post(cls.TOKEN_MANAGER_API,
34                            data={"username": username, "password": password, "uid": uid, "access_token": access_token},
35                            timeout=10).json()
36        return res["success"]
37
38    @classmethod
39    def set_token_dead(cls, uid):
40        res = requests.patch(cls.TOKEN_MANAGER_API, data={"uid": uid, "dead": True}, timeout=10).json()
41        return res["success"]
42
43    @classmethod
44    def set_token_limit(cls, uid):
45        res = requests.patch(cls.TOKEN_MANAGER_API, data={"uid": uid, "synclimit": True}, timeout=10).json()
46        return res["success"]
47
48
49def calculate_signature(data, secret=None):
50    api_secret = secret
51    sig = ""
52    for key in sorted(data.keys()):
53        sig += "{0}={1}".format(key, data[key])
54    data["sig"] = hashlib.md5((sig + api_secret).encode("utf-8")).hexdigest()
55    return data["sig"]
56
57
58def renew_connection():
59    renew_ip()
60    # if CheckpointChecker.is_consecutive_checkpoint():
61    #     renew_ip()
62    # else:
63    #     CheckpointChecker.failed_reg()
64
65class FBRegister:
66    API_URL = "https://z-m-api.facebook.com/method/user.register"
67    HEADERS = {
68        "User-Agent": "[FBAN/FB4A;FBAV/175.0.0.40.97;]",
69    }
70
71    APP_ID = "350685531728"
72    APP_SECRET = "62f8ce9f74b12f84c123cc23437a4a32"
73
74    def __init__(self, email, password, first_name="", last_name="", gender="F", birthday="", proxy=None):
75        self.email = email
76        self.password = password
77        if first_name:
78            self.first_name = first_name
79        else:
80            self.first_name = "Huyen"
81        if last_name:
82            self.last_name = last_name
83        else:
84            self.last_name = "Le Thi"
85        self.gender = gender
86        if birthday:
87            self.birthday = birthday
88        else:
89            self.birthday = "1997-07-06"
90        self.session = requests.Session()
91        if proxy:
92            logger.info("Use proxy {}".format(proxy))
93            self.session.proxies = {"https": proxy}
94            self.session.verify = False
95
96    @classmethod
97    def send_zeroheader(cls, proxy=None):
98        url = 'https://b-api.facebook.com/method/mobile.zeroHeaderRequest'
99        headers = {
100            'x-fb-friendly-name': 'fetchZeroHeaderRequest',
101            'authorization': 'OAuth null'
102        }
103        data = {
104            'access_token': f'{cls.APP_ID}|{cls.APP_SECRET}',
105            'carrier_mcc': '310',
106            'carrier_mnc': '260',
107            'client_country_code': 'US',
108            'machine_id': "eZKiW2cRfI3_LfPmIn6r64H0",
109            'device_id': str(uuid.uuid4()),
110            'fb_api_caller_class': 'com.facebook.zero.service.ZeroTokenHandler',
111            'fb_api_req_friendly_name': 'fetchZeroHeaderRequest',
112            'force_refresh': 'false',
113            'format': 'json',
114            'header_usage': 'headers_cache_usage',
115            'interface': 'wifi',
116            'locale': 'en_US',
117            'method': 'mobile.zeroHeaderRequest',
118            'sim_mcc': '310',
119            'sim_mnc': '270'
120        }
121        try:
122            response = requests.post(url, data=data, headers=headers, proxies={"https": proxy}, timeout=7)
123        except Exception as e:
124            print(e)
125        else:
126            response = json.loads(response.text)
127            if response.get("edid"):
128                logger.info("Sent zeroHeader request {}".format(proxy or ""))
129                return True
130        return False
131
132    def prepare_request_data(self):
133        data = {"email": self.email, "firstname": self.first_name, "lastname": self.last_name, "gender": self.gender,
134                "password": self.password, "birthday": self.birthday, "attempt_login": "true", "format": "json",
135                "locale": "en_US", "method": "user.register",
136                "fb_api_caller_class": "com.facebook.registration.fragment.RegistrationCreateAccountFragment",
137                "api_key": "882a8490361da98702bf97a021ddc14d"}
138        # data["client_country_code"] = "US"
139        data["sig"] = calculate_signature(data, "62f8ce9f74b12f84c123cc23437a4a32")
140        return data
141
142    def execute(self):
143        # self.send_zeroheader()
144        request_data = self.prepare_request_data()
145        try:
146            response = self.session.post(self.API_URL, data=request_data, headers=self.HEADERS, timeout=20)
147        except Exception:
148            return None, None
149        else:
150            total_time = response.elapsed.total_seconds()
151            response = json.loads(response.text)
152        try:
153            session_info = response["session_info"]
154            uid, access_token = session_info["uid"], session_info["access_token"]
155            logger.info("Registered in {}s - {} - UID: {}".format(total_time, self.email, uid))
156            return uid, access_token
157        except Exception as e:
158            error_code = response.get("error_code")
159            if error_code == 368:
160                logger.info("Register service is current banned")
161                renew_connection()
162            elif error_code == 3107:
163                logger.info("Invalid username {}".format(self.email))
164            elif error_code == 3125:
165                logger.info("Invalid phone {}".format(self.email))
166            else:
167                logger.info(response)
168            return None, None
169
170
171last_created = 0
172fail_count = 0
173
174
175class RandomFBRegister:
176    MAIL_DOMAIN = "gmail.com"
177    last_created = 0
178    fail_count = 0
179
180    @classmethod
181    def check_consecutive_checkpoint(cls):
182        logger.info("Fail count: {}".format(cls.fail_count))
183        if round(time.time() - cls.last_created, 2) <= 10:
184            if cls.fail_count >= 5:
185                logger.info("Low token quality ...")
186                renew_connection()
187                cls.fail_count = 0
188            else:
189                cls.fail_count += 1
190        else:
191            cls.fail_count = 0
192
193    @classmethod
194    def create(cls, proxy=None):
195        cls.check_consecutive_checkpoint()
196        access_token = None
197        while not access_token:
198            username = ''.join(random.choice(string.ascii_lowercase) for x in range(11)) + "@" + cls.MAIL_DOMAIN
199            # username = "038" + ''.join(random.choice(string.digits) for x in range(7))
200            # username = "+1" + random.choice(["316", "769", "515", "228", "231", "385", "386", "231"]) + ''.join(
201            #     random.choice(string.digits) for x in range(7))
202            password = "fbtest123"
203            uid, access_token = FBRegister(username, password, proxy=proxy).execute()
204        cls.last_created = time.time()
205        return uid, access_token
206
207
208if __name__ == "__main__":
209    uid, access_token = RandomFBRegister.create()
210    TokenManager.push_token("teamtree", "fbtest123", uid, access_token)
211    print(uid,access_token)