Ensta 5.2.11__py3-none-any.whl

ensta/Authentication.py

@@ -0,0 +1,252 @@
+import json
+import random
+import string
+import requests
+import pyotp
+import ntplib
+from requests import Session
+from requests import Response
+from json import JSONDecodeError
+from .PasswordEncryption import PasswordEncryption
+from .lib.Exceptions import (AuthenticationError, NetworkError)
+from .WebSession import WebSession
+
+
+def new_session_id(
+    user_identifier: str,  # Username or Email
+    password: str,
+    proxy: dict[str, str],
+    totp_token: str = None
+) -> str:
+    
+    request_session: Session = requests.Session()
+    request_session.headers["user-agent"] = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 " \
+                                            "(KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36"
+
+    if proxy is not None: request_session.proxies.update(proxy)
+
+    encryption = PasswordEncryption(request_session)
+    encrypted_password = encryption.encrypt(password)
+
+    data: dict = {
+        "enc_password": encrypted_password,
+        "optIntoOneTap": False,
+        "queryParams": "{}",
+        "trustedDeviceRecords": "{}",
+        "username": user_identifier  # Accepts email as well
+    }
+
+    csrf_token: str = "".join(random.choices(string.ascii_letters + string.digits, k=32))
+
+    headers: dict = {
+        "accept": "*/*",
+        "accept-language": "en-US,en;q=0.9",
+        "content-type": "application/x-www-form-urlencoded",
+        "dpr": "1.30208",
+        "sec-ch-prefers-color-scheme": "dark",
+        "sec-ch-ua": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) "
+                     "Chrome/119.0.0.0 Safari/537.36",
+        "sec-ch-ua-full-version-list": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
+                                       "(KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36",
+        "sec-ch-ua-mobile": "?0",
+        "sec-ch-ua-model": "\"\"",
+        "sec-ch-ua-platform": "\"Windows\"",
+        "sec-ch-ua-platform-version": "\"15.0.0\"",
+        "sec-fetch-dest": "empty",
+        "sec-fetch-mode": "cors",
+        "sec-fetch-site": "same-origin",
+        "viewport-width": "1475",
+        "x-asbd-id": "129477",
+        "x-csrftoken": csrf_token,
+        "x-ig-app-id": "936619743392459",
+        "x-ig-www-claim": "0",
+        "x-instagram-ajax": "1009977574",
+        "x-requested-with": "XMLHttpRequest",
+        "x-web-device-id": "25532C62-8BBC-4927-B6C5-02631D6E05BF",
+        "cookie": f"dpr=1.3020833730697632; csrftoken={csrf_token}",
+        "Referer": "https://www.instagram.com/",
+        "Referrer-Policy": "strict-origin-when-cross-origin"
+    }
+
+    http_response: Response = request_session.post(
+        url="https://www.instagram.com/api/v1/web/accounts/login/ajax/",
+        data=data,
+        headers=headers
+    )
+
+    try:
+        response_json: dict = http_response.json()
+
+        if response_json.get("status", "") != "ok":
+
+            verification_code: int | None = None
+
+            if response_json.get("two_factor_required", False) is True:
+            
+                if response_json.get("two_factor_info", {}).get("totp_two_factor_on", False) is False:
+
+                    if response_json.get("two_factor_info", {}).get("sms_two_factor_on", False) is False:
+
+                        raise AuthenticationError(
+                            "Some other 2FA method is enabled. Only TOTP-based"
+                            " (Authenticator App) and SMS-based two factor is supported."
+                        )
+
+                    verification_code: int = int(input("SMS 2FA enabled. Enter OTP: "))
+    
+                if totp_token is None and verification_code is None:
+                    raise AuthenticationError("Two-factor is enabled. Please provide the totp_token while logging in.")
+
+                else:
+                    tf_data: dict = {
+                        "queryParams": '{"next":"/"}',
+                        "trust_signal": True,
+                        "identifier": response_json.get("two_factor_info", {}).get("two_factor_identifier"),
+                        "verification_method": "1",
+                        "username": user_identifier,
+                        "verificationCode": verification_code if verification_code is not None else
+
+                        pyotp.TOTP(totp_token).at(
+                            int(
+                                ntplib.NTPClient().request(
+                                    "time.google.com",
+                                    version=3
+                                ).tx_time
+                            )
+                        )
+                    }
+
+                    tf_response: Response = request_session.post(
+                        url="https://www.instagram.com/api/v1/web/accounts/login/ajax/two_factor/",
+                        data=tf_data,
+                        headers={
+                            "sec-ch-prefers-color-scheme": "dark",
+                            "sec-ch-ua": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+                                         "AppleWebKit/537.36 (KHTML, like Gecko) "
+                                         "Chrome/119.0.0.0 Safari/537.36",
+                            "sec-ch-ua-full-version-list": "Mozilla/5.0 (Windows NT 10.0; Win64;"
+                                                           " x64) AppleWebKit/537.36 "
+                                                           "(KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36",
+                            "sec-ch-ua-mobile": "?0",
+                            "sec-ch-ua-model": "\"\"",
+                            "sec-ch-ua-platform": "\"Windows\"",
+                            "sec-ch-ua-platform-version": "\"15.0.0\"",
+                            "sec-fetch-dest": "empty",
+                            "sec-fetch-mode": "cors",
+                            "sec-fetch-site": "same-origin",
+                            'Accept': '*/*',
+                            'Accept-Language': 'en-US,en;q=0.5',
+                            'X-Mid': response_json.get("two_factor_info", {}).get("device_id"),
+                            'X-CSRFToken': csrf_token,
+                            "x-instagram-ajax": "1009977574",
+                            "x-ig-app-id": "936619743392459",
+                            'X-ASBD-ID': '129477',
+                            'X-IG-WWW-Claim': '0',
+                            "x-web-device-id": "25532C62-8BBC-4927-B6C5-02631D6E05BF",
+                            'Content-Type': 'application/x-www-form-urlencoded',
+                            'X-Requested-With': 'XMLHttpRequest',
+                            'Origin': 'https://www.instagram.com',
+                            'DNT': '1',
+                            'Sec-GPC': '1',
+                            'Connection': 'keep-alive',
+                            'Referer': 'https://www.instagram.com/accounts/login/two_factor?next=%2F',
+                            'Sec-Fetch-Dest': 'empty',
+                            'Sec-Fetch-Mode': 'cors',
+                            'Sec-Fetch-Site': 'same-origin',
+                        },
+                        cookies={
+                            "ig_did": response_json.get("ig_did", ""),
+                            "mid": response_json.get("two_factor_info", {}).get("device_id"),
+                            "csrftoken": csrf_token
+                        }
+                    )
+                     
+                    if "Oops, an error occurred." in tf_response.text:
+
+                        raise AuthenticationError(
+                            "IP temporarily banned most probably due to too many login requests."
+                            " Please try again later or use proxies."
+                        )
+                    
+                    try:
+                        tf_response_json: dict = tf_response.json()
+                    
+                        if tf_response_json.get("status", "") != "ok" \
+                                or tf_response_json.get("authenticated", False) is False:
+
+                            raise AuthenticationError(
+                                "Couldn't log in through 2FA. Most probably your totp_token is incorrect."
+                            )
+                        
+                        session_id: str = tf_response.cookies.get("sessionid", "")
+                        rur: str = tf_response.cookies.get("rur", "")
+                        mid: str = response_json.get("two_factor_info", {}).get("device_id")
+                        user_id: str = tf_response_json.get("userId", "")
+                        ig_did: str = tf_response.cookies.get("ig_did", "")
+    
+                        if session_id == "" or user_id == "":
+
+                            raise AuthenticationError(
+                                "2FA authentication response didn't return a valid session_id or user_id."
+                            )
+
+                        return json.dumps({
+                            "session_id": session_id,
+                            "rur": rur,
+                            "mid": mid,
+                            "user_id": user_id,
+                            "ig_did": ig_did,
+                            "identifier": user_identifier,
+                            "username": WebSession(
+                                json.dumps({
+                                    "session_id": session_id,
+                                    "rur": rur,
+                                    "mid": mid,
+                                    "user_id": user_id,
+                                    "ig_did": ig_did,
+                                })
+                            ).private_info().username
+                        })
+
+                    except JSONDecodeError:
+                        raise NetworkError(
+                            "Response got while logging in was not a valid "
+                            "json. Are you able to visit Instagram on the web?"
+                        )
+            
+            raise AuthenticationError(
+                "Either user doesn't exist or your password is too weak (change it to a stronger one)."
+            )
+
+        if response_json.get("user", False) is False or response_json.get("authenticated", False) is False:
+            raise AuthenticationError("Invalid password.")
+
+        session_id: str = http_response.cookies.get("sessionid", "")
+        rur: str = http_response.cookies.get("rur", "")
+        mid: str = http_response.cookies.get("mid", "")
+        user_id: str = response_json.get("userId", "")
+        ig_did: str = response_json.get("ig_did", "")
+
+        if session_id == "" or user_id == "": raise AuthenticationError("Unable to login.")
+
+        return json.dumps({
+            "session_id": session_id,
+            "rur": rur,
+            "mid": mid,
+            "user_id": user_id,
+            "ig_did": ig_did,
+            "identifier": user_identifier,
+            "username": WebSession(
+                json.dumps({
+                    "session_id": session_id,
+                    "rur": rur,
+                    "mid": mid,
+                    "user_id": user_id,
+                    "ig_did": ig_did,
+                })
+            ).private_info().username
+        })
+
+    except JSONDecodeError:
+        raise NetworkError("Response got while logging in was not a valid "
+                           "json. Are you able to visit Instagram on the web?")

ensta/Credentials.py

@@ -0,0 +1,251 @@
+import json
+from json import JSONDecodeError
+from requests import Session, Response
+from uuid import uuid4
+from .PasswordEncryption import PasswordEncryption
+from .lib.Exceptions import AuthenticationError
+from requests.models import CaseInsensitiveDict
+from .SessionManager import SessionManager
+import pyotp
+import ntplib
+
+
+class Credentials:
+    """
+    Takes identifier-password and returns Credentials.
+
+    - Should be called with identifier and password.
+    - If stored session exists, validates it (not authenticates), and returns Credentials.
+    - Otherwise logs in using given identifier and password, stores it in file, and returns Credentials.
+    - Raises appropriate exceptions where needed.
+    """
+
+    session: Session
+    user_agent: str
+    totp_token: str
+
+    bearer: str
+    user_id: str
+    username: str
+    phone_id: str
+    stored_identifier: str
+
+    device_id: str = "android-d105ec84a512642c"
+
+    def __init__(
+        self,
+        identifier: str,
+        password: str,
+        user_agent: str,
+        session: Session,
+        save_folder: str,
+        totp_token: str,
+        session_data: str,
+        logging: bool = False
+    ) -> None:
+
+        self.session = session
+        self.user_agent = user_agent
+        self.totp_token = totp_token
+
+        # Existing Stored Credentials?
+        if session_data is not None: stored_dict: dict = json.loads(session_data)
+        else: stored_dict: dict = SessionManager.load_from_file(identifier, password, save_folder)
+
+        stored_dict_valid: bool = True
+
+        # Validate StoredDict
+        for key in ("bearer", "user_id", "username", "phone_id", "identifier", "device_id"):
+            if key not in stored_dict.keys(): stored_dict_valid: bool = False
+
+        # Load From StoredDict
+        if stored_dict_valid and stored_dict.get("identifier") == identifier:
+            if logging: print("Loading from stored file...")
+            self.bearer = stored_dict.get("bearer")
+            self.user_id = stored_dict.get("user_id")
+            self.username= stored_dict.get("username")
+            self.phone_id = stored_dict.get("phone_id")
+            self.stored_identifier = stored_dict.get("identifier")
+
+        # Create New Session
+        else:
+            if logging: print("Creating new session...")
+            self.login(identifier, password, save_folder)
+
+
+    def login(self, identifier: str, password: str, save_folder: str) -> None:
+        """
+        Takes identifier and password, authenticates, stores new session in file, and returns a bunch of session data.
+        :param identifier: Username or Email
+        :param password: Password
+        :param save_folder: Folder path to store new session in. Empty to skip storing session.
+        :return: Tuple of session data
+        """
+
+        phone_id: str = str(uuid4())
+        guid: str = str(uuid4())
+        encrypted_password = PasswordEncryption(self.session).encrypt(password)
+
+        response: Response = self.session.post(
+            url="https://i.instagram.com/api/v1/accounts/login/",
+            headers={
+                "content-type": "application/x-www-form-urlencoded; charset=UTF-8",
+                "user-agent": self.user_agent,
+                "host": "i.instagram.com",
+            },
+            data={
+                "jazoest": "22506",
+                "country_codes": "[{\"country_code\":\"1\",\"source\":[\"default\"]}]",
+                "phone_id": phone_id,
+                "enc_password": encrypted_password,
+                "username": identifier,
+                "adid": "00000000-0000-0000-0000-000000000000",
+                "guid": guid,
+                "device_id": self.device_id,
+                "google_tokens": "[]",
+                "login_attempt_count": "0"
+            }
+        )
+
+        try:
+            user_info: dict | None = None
+            response_headers: CaseInsensitiveDict[str] | None = None
+
+            # Parse Response Body Into A JSON
+            response_dict: dict = response.json()
+
+            # Request Failed
+            if response_dict.get("status", "fail") != "ok":
+
+                # Other Than 2FA?
+                if response_dict.get("error_type", "") != "two_factor_required":
+                    raise AuthenticationError(
+                        f"Login failed with given credentials.\n"
+                        f"Response: {response_dict}"
+                    )
+
+                # 2FA Required
+                user_info, response_headers = self.handle_2fa(
+                    information=response_dict.get("two_factor_info", {}),
+                    phone_id=phone_id,
+                    guid=guid
+                )
+
+            # Request Succeeded: Collect Data
+            if user_info is None: user_info: dict = response_dict.get("logged_in_user", dict())
+
+            if response_headers is None: self.bearer: str = response.headers.get("ig-set-authorization")
+            else: self.bearer: str = response_headers.get("ig-set-authorization")
+
+            self.user_id: str = str(user_info.get("pk"))
+            self.phone_id = phone_id
+            self.username: str = user_info.get("username")
+            self.stored_identifier = identifier
+
+            # Save Session in File
+            if save_folder != "":
+                SessionManager.save_to_file(
+                    folder_name=save_folder,
+                    identifier=identifier,
+                    password=password,
+                    phone_id=phone_id,
+                    instance=self
+                )
+
+        # Response Body Not A Valid JSON
+        except JSONDecodeError:
+            raise AuthenticationError(
+                "Response I got didn't parse into a JSON. Maybe you're being rate "
+                "limited. Change WiFi or use reputed proxies."
+            )
+
+    def handle_2fa(
+        self,
+        information: dict,
+        phone_id: str,
+        guid: str
+    ) -> tuple[dict, CaseInsensitiveDict[str]]:
+
+        # Only TOTP Supported: No SMS, No WhatsApp
+        if information.get("totp_two_factor_on", False) is False:
+            raise AuthenticationError(
+                "Only TOTP-based 2FA is supported till now."
+            )
+
+        # TODO: Remove when implemented
+        raise NotImplementedError("TOTP 2FA not implemented yet!")
+
+        # TOTP Token Supplied? Take Input | Use That
+        if self.totp_token is None: code: str = input("Enter TOTP Code: ")
+        else: code: str = self.new_totp_code(self.totp_token)
+
+        while True:
+            user_info, response_headers = self.bypass_totp(
+                code=code,
+                two_factor_identifier=information.get("two_factor_identifier"),
+                phone_id=phone_id,
+                guid=guid
+            )
+
+            if user_info is not None and response_headers is not None: break
+
+            if self.totp_token is None:
+                code: str = input(
+                    "Unable to verify code.\n\n"
+                    "Enter TOTP Code: "
+                )
+
+            else:
+                raise AuthenticationError(
+                    "Unable to verify TOTP 2FA Code. Is the totp_token correct?"
+                )
+
+        return user_info, response_headers
+
+    @staticmethod
+    def new_totp_code(token: str) -> str:
+        """
+        Generates a new TOTP Code for the current time using secret token.
+
+        :param token: TOTP Token generated by Instagram stored secretly in the Authenticator App.
+        :return: Generated Code
+        """
+
+        current_time: int = int(ntplib.NTPClient().request("time.google.com", version=3).tx_time)
+
+        return str(
+            pyotp.TOTP(token).at(current_time)
+        )
+
+    def bypass_totp(self, code: str, two_factor_identifier: str, phone_id: str, guid: str) -> tuple[dict, CaseInsensitiveDict[str]]:
+
+        response: Response = self.session.post(
+            url="https://i.instagram.com/api/v1/accounts/two_factor_login/",
+            headers={
+                "content-type": "application/x-www-form-urlencoded; charset=UTF-8",
+                "accept-encoding": "gzip",
+                "connection": "Keep-Alive"
+            },
+            data={
+                "signed_body": "SIGNATURE." + json.dumps(
+                    {
+                        "verification_code": code,
+                        "phone_id": phone_id,
+                        "two_factor_identifier": two_factor_identifier,
+                        "trust_this_device": "1",
+                        "guid": guid,
+                        "device_id": self.device_id,
+                        "waterfall_id": str(uuid4()),
+                        "verification_method": "3"  # '3' For TOTP-Based 2FA
+                    }
+                )
+            }
+        )
+
+        # TODO
+        """
+        Return logged_in_user_info and response headers.
+        Error: CSRF Token missing or incorrect.
+        """
+
+        raise Exception(response.json())

ensta/Direct.py

@@ -0,0 +1,145 @@
+from requests import Session, Response
+from .containers.Inbox import Inbox
+from uuid import uuid4
+import string
+import random
+from .lib.Exceptions import FileTypeError, NetworkError
+from json import JSONDecodeError
+from pathlib import Path
+from ensta.Utils import fb_uploader
+
+
+class Direct:
+
+    session: Session
+    device_id: str
+
+    def __init__(self, session: Session, device_id: str) -> None:
+        self.session = session
+        self.device_id = device_id
+
+    def inbox(self) -> Inbox:
+        """
+        Fetches all the chats from inbox.
+        :return: Inbox object with chat items and some other data
+        """
+
+        raise NotImplementedError()
+
+    def send_text(self, text: str, thread_id: int, silently: bool = False) -> bool:
+        """
+        Sends a text message in a chat
+        :param text: Text message
+        :param thread_id: Thread ID of chat to send message to
+        :param silently: Whether to send message without any notification
+        :return: Boolean (Message sent or not)
+        """
+
+        mutation_token: str = str().join(random.choices(string.digits, k=19))
+
+        response: Response = self.session.post(
+            url="https://i.instagram.com/api/v1/direct_v2/threads/broadcast/text/",
+            data={
+                "action": "send_item",
+                "is_x_transport_forward": False,
+                "is_shh_mode": 0,
+                "send_silently": silently,
+                "thread_ids": f"[{thread_id}]",
+                "send_attribution": "inbox",
+                "client_context": mutation_token,
+                "text": text,
+                "device_id": self.device_id,
+                "mutation_token": mutation_token,
+                "_uuid": str(uuid4()),
+                "btt_dual_send": False,
+                "is_ae_dual_send": False,
+                "offline_threading_id": mutation_token
+            }
+        )
+
+        try:
+            return response.json().get("status", "") == "ok"
+
+        except JSONDecodeError:
+            return False
+
+    def fb_upload_image(self, media_path: str) -> int:
+        """
+        Uploads given image to Instagram and returns MediaID.
+        :param media_path: Local path of image
+        :return: MediaID (Integer)
+        """
+
+        media_path: Path = Path(media_path)
+
+        if media_path.suffix not in (".jpg", ".jpeg"):
+            raise FileTypeError(
+                "Only jpg and jpeg image types can be uploaded."
+            )
+
+        with open(media_path, "rb") as file:
+            media_data: bytes = file.read()
+
+        upload_name: str = fb_uploader()
+        media_length: str = str(len(media_data))
+
+        response: Response = self.session.post(
+            url=f"https://rupload.facebook.com/messenger_image/{upload_name}",
+            headers={
+                "content-length": media_length,
+                "content-type": "application/octet-stream",
+                "host": "rupload.facebook.com",
+                "x-entity-name": upload_name,
+                "x-entity-type": "image/jpeg",
+                "x-entity-length": media_length,
+                "offset": "0",
+                "image_type": "FILE_ATTACHMENT"
+            },
+            data=media_data
+        )
+
+        try:
+            return response.json().get("media_id")
+
+        except JSONDecodeError:
+            raise NetworkError(
+                "Unable to upload image. Make sure there's nothing wrong with the image. "
+                "If this problem persists, try using a different account, switch to a different "
+                "network, or use reputed proxies."
+            )
+
+    def send_photo(self, media_id: int, thread_id: int) -> bool:
+        """
+        Sends a photo in a chat
+        :param media_id: Media ID of photo received by uploading it to 'FB Uploader'
+        :param thread_id: Thread ID of chat to send photo to
+        :return: Boolean (Photo sent or not)
+        """
+
+        mutation_token: str = str().join(random.choices(string.digits, k=19))
+
+        response: Response = self.session.post(
+            url="https://i.instagram.com/api/v1/direct_v2/threads/broadcast/photo_attachment/",
+            data={
+                "action": "send_item",
+                "is_x_transport_forward": False,
+                "is_shh_mode": 0,
+                "thread_ids": f"[{thread_id}]",
+                "send_attribution": "inbox",
+                "client_context": mutation_token,
+                "attachment_fbid": media_id,
+                "device_id": self.device_id,
+                "mutation_token": mutation_token,
+                "_uuid": str(uuid4()),
+                "allow_full_aspect_ratio": True,
+                "btt_dual_send": False,
+                "is_ae_dual_send": False,
+                "offline_threading_id": mutation_token
+            }
+        )
+
+        try:
+            return response.json().get("status", "") == "ok"
+
+        except JSONDecodeError:
+            return False