closed-linkedin-api 2.3.2__py3-none-any.whl

open_linkedin_api/cookie_auth.py

@@ -0,0 +1,233 @@
+"""
+Cookie-based authentication for LinkedIn API.
+
+This module provides utilities to authenticate with LinkedIn using
+browser cookies instead of username/password credentials.
+"""
+
+from typing import Dict, Optional, Union
+from requests.cookies import RequestsCookieJar
+from http.cookiejar import Cookie
+import time
+
+
+class CookieAuthenticationError(Exception):
+    """Raised when cookie-based authentication fails."""
+    pass
+
+
+class CookieAuthenticator:
+    """
+    Helper class to create and validate LinkedIn session cookies.
+    
+    LinkedIn authentication requires at minimum two cookies:
+    - li_at: The main authentication token
+    - JSESSIONID: Session ID (used to derive csrf-token header)
+    
+    Example usage:
+        # From a dict
+        cookies = CookieAuthenticator.from_dict({
+            'li_at': 'your_li_at_value',
+            'JSESSIONID': '"ajax:1234567890"'
+        })
+        
+        # From separate values
+        cookies = CookieAuthenticator.from_li_at_and_jsessionid(
+            li_at='your_li_at_value',
+            jsessionid='"ajax:1234567890"'
+        )
+    """
+    
+    REQUIRED_COOKIES = ['li_at', 'JSESSIONID']
+    OPTIONAL_COOKIES = ['li_rm', 'bcookie', 'bscookie', 'lidc', 'li_gc', 'liap']
+    LINKEDIN_DOMAIN = '.linkedin.com'
+    
+    @staticmethod
+    def _create_cookie(
+        name: str,
+        value: str,
+        domain: str = '.linkedin.com',
+        path: str = '/',
+        expires: Optional[int] = None,
+        secure: bool = True,
+    ) -> Cookie:
+        """
+        Create a Cookie object with the given parameters.
+        
+        :param name: Cookie name
+        :param value: Cookie value
+        :param domain: Cookie domain (default: .linkedin.com)
+        :param path: Cookie path (default: /)
+        :param expires: Expiration timestamp (default: None = session cookie)
+        :param secure: Whether cookie is secure (default: True)
+        :return: Cookie object
+        """
+        # Default expiry to 1 year from now if not specified
+        if expires is None:
+            expires = int(time.time()) + (365 * 24 * 60 * 60)
+        
+        return Cookie(
+            version=0,
+            name=name,
+            value=value,
+            port=None,
+            port_specified=False,
+            domain=domain,
+            domain_specified=True,
+            domain_initial_dot=domain.startswith('.'),
+            path=path,
+            path_specified=True,
+            secure=secure,
+            expires=expires,
+            discard=False,
+            comment=None,
+            comment_url=None,
+            rest={'HttpOnly': ''},
+            rfc2109=False,
+        )
+    
+    @classmethod
+    def from_dict(cls, cookies: Dict[str, str]) -> RequestsCookieJar:
+        """
+        Convert a dict of cookie name->value pairs to a RequestsCookieJar.
+        
+        :param cookies: Dictionary with cookie names as keys and values as values.
+                       Must contain at least 'li_at' and 'JSESSIONID'.
+        :return: RequestsCookieJar configured for LinkedIn
+        :raises CookieAuthenticationError: If required cookies are missing
+        """
+        # Validate required cookies
+        missing = [c for c in cls.REQUIRED_COOKIES if c not in cookies or not cookies[c]]
+        if missing:
+            raise CookieAuthenticationError(
+                f"Missing required cookies: {', '.join(missing)}. "
+                f"Required cookies are: {', '.join(cls.REQUIRED_COOKIES)}"
+            )
+        
+        jar = RequestsCookieJar()
+        
+        for name, value in cookies.items():
+            # Clean up JSESSIONID if it has extra quotes
+            if name == 'JSESSIONID':
+                value = value.strip()
+                # Ensure JSESSIONID has surrounding quotes if not present
+                if not (value.startswith('"') and value.endswith('"')):
+                    if not value.startswith('"'):
+                        value = f'"{value}'
+                    if not value.endswith('"'):
+                        value = f'{value}"'
+            
+            cookie = cls._create_cookie(
+                name=name,
+                value=value,
+                domain=cls.LINKEDIN_DOMAIN,
+            )
+            jar.set_cookie(cookie)
+        
+        return jar
+    
+    @classmethod
+    def from_li_at_and_jsessionid(
+        cls,
+        li_at: str,
+        jsessionid: str,
+        additional_cookies: Optional[Dict[str, str]] = None,
+    ) -> RequestsCookieJar:
+        """
+        Create a RequestsCookieJar from the two required cookie values.
+        
+        :param li_at: The li_at authentication token value
+        :param jsessionid: The JSESSIONID value (with or without surrounding quotes)
+        :param additional_cookies: Optional dict of additional cookies to include
+        :return: RequestsCookieJar configured for LinkedIn
+        :raises CookieAuthenticationError: If li_at or jsessionid is empty
+        """
+        if not li_at:
+            raise CookieAuthenticationError("li_at cookie value cannot be empty")
+        if not jsessionid:
+            raise CookieAuthenticationError("JSESSIONID cookie value cannot be empty")
+        
+        cookies = {
+            'li_at': li_at,
+            'JSESSIONID': jsessionid,
+        }
+        
+        if additional_cookies:
+            cookies.update(additional_cookies)
+        
+        return cls.from_dict(cookies)
+    
+    @classmethod
+    def validate_cookies(cls, cookies: Union[Dict[str, str], RequestsCookieJar]) -> bool:
+        """
+        Check if the provided cookies contain all required values.
+        
+        :param cookies: Either a dict or RequestsCookieJar to validate
+        :return: True if all required cookies are present with non-empty values
+        """
+        if isinstance(cookies, RequestsCookieJar):
+            cookie_dict = {c.name: c.value for c in cookies}
+        else:
+            cookie_dict = cookies
+        
+        for required in cls.REQUIRED_COOKIES:
+            if required not in cookie_dict or not cookie_dict[required]:
+                return False
+        
+        return True
+    
+    @classmethod
+    def get_csrf_token(cls, cookies: Union[Dict[str, str], RequestsCookieJar]) -> str:
+        """
+        Extract the CSRF token from cookies.
+        
+        LinkedIn uses the JSESSIONID value (with quotes stripped) as the csrf-token.
+        
+        :param cookies: Either a dict or RequestsCookieJar containing JSESSIONID
+        :return: The csrf-token value
+        :raises CookieAuthenticationError: If JSESSIONID is not found
+        """
+        if isinstance(cookies, RequestsCookieJar):
+            jsessionid = None
+            for c in cookies:
+                if c.name == 'JSESSIONID':
+                    jsessionid = c.value
+                    break
+        else:
+            jsessionid = cookies.get('JSESSIONID')
+        
+        if not jsessionid:
+            raise CookieAuthenticationError("JSESSIONID cookie not found")
+        
+        # Strip surrounding quotes
+        return jsessionid.strip('"')
+    
+    @classmethod
+    def is_cookie_expired(
+        cls,
+        cookies: Union[Dict[str, str], RequestsCookieJar],
+        cookie_name: str = 'li_at',
+    ) -> bool:
+        """
+        Check if a specific cookie has expired.
+        
+        Note: This only works for RequestsCookieJar objects that contain
+        expiration information. Dict-based cookies are assumed to be valid.
+        
+        :param cookies: Cookies to check
+        :param cookie_name: Name of cookie to check (default: li_at)
+        :return: True if the cookie is expired, False otherwise
+        """
+        if isinstance(cookies, dict):
+            # Can't determine expiration from a plain dict
+            return False
+        
+        now = time.time()
+        for cookie in cookies:
+            if cookie.name == cookie_name:
+                if cookie.expires and cookie.expires < now:
+                    return True
+                return False
+        
+        # Cookie not found
+        return True

open_linkedin_api/cookie_repository.py

@@ -0,0 +1,70 @@
+import os
+import pickle
+import time
+import open_linkedin_api.settings as settings
+from requests.cookies import RequestsCookieJar
+from typing import Optional
+
+
+class Error(Exception):
+    """Base class for other exceptions"""
+
+    pass
+
+
+class LinkedinSessionExpired(Error):
+    pass
+
+
+class CookieRepository(object):
+    """
+    Class to act as a repository for the cookies.
+
+    TODO: refactor to use http.cookiejar.FileCookieJar
+    """
+
+    def __init__(self, cookies_dir=settings.COOKIE_PATH):
+        self.cookies_dir = cookies_dir or settings.COOKIE_PATH
+
+    def save(self, cookies, username):
+        self._ensure_cookies_dir()
+        cookiejar_filepath = self._get_cookies_filepath(username)
+        with open(cookiejar_filepath, "wb") as f:
+            pickle.dump(cookies, f)
+
+    def get(self, username: str) -> Optional[RequestsCookieJar]:
+        cookies = self._load_cookies_from_cache(username)
+        if cookies and not CookieRepository._is_token_still_valid(cookies):
+            raise LinkedinSessionExpired
+
+        return cookies
+
+    def _ensure_cookies_dir(self):
+        if not os.path.exists(self.cookies_dir):
+            os.makedirs(self.cookies_dir)
+
+    def _get_cookies_filepath(self, username) -> str:
+        """
+        Return the absolute path of the cookiejar for a given username
+        """
+        return "{}{}.jr".format(self.cookies_dir, username)
+
+    def _load_cookies_from_cache(self, username: str) -> Optional[RequestsCookieJar]:
+        cookiejar_filepath = self._get_cookies_filepath(username)
+        try:
+            with open(cookiejar_filepath, "rb") as f:
+                cookies = pickle.load(f)
+                return cookies
+        except FileNotFoundError:
+            return None
+
+    @staticmethod
+    def _is_token_still_valid(cookiejar: RequestsCookieJar):
+        _now = time.time()
+        for cookie in cookiejar:
+            if cookie.name == "JSESSIONID" and cookie.value:
+                if cookie.expires and cookie.expires > _now:
+                    return True
+                break
+
+        return False

open_linkedin_api/graphql.py

@@ -0,0 +1,237 @@
+"""
+GraphQL abstraction layer for LinkedIn Voyager API.
+
+This module provides a registry of known GraphQL query IDs and a client
+for executing GraphQL requests against LinkedIn's Voyager API.
+"""
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, Dict, Optional
+from urllib.parse import quote
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class QueryType(Enum):
+    """Types of GraphQL endpoints available."""
+    VOYAGER = "voyager"  # /voyager/api/graphql
+    MESSAGING = "messaging"  # /voyager/api/voyagerMessagingGraphQL/graphql
+
+
+@dataclass(frozen=True)
+class GraphQLQuery:
+    """Represents a LinkedIn GraphQL query with its metadata."""
+    query_id: str
+    query_type: QueryType
+    description: str
+
+
+class QueryRegistry:
+    """
+    Registry of known LinkedIn GraphQL query IDs.
+    
+    These query IDs were discovered through network traffic analysis.
+    LinkedIn uses fixed query IDs that map to specific GraphQL operations.
+    """
+    
+    # Profile queries (Voyager GraphQL)
+    PROFILE = GraphQLQuery(
+        query_id="voyagerIdentityDashProfiles.2ca312bdbe80fac72fd663a3e06a83e7",
+        query_type=QueryType.VOYAGER,
+        description="Fetch full profile data by vanity name"
+    )
+    
+    PROFILE_CARDS = GraphQLQuery(
+        query_id="voyagerIdentityDashProfileCards.55af784c21dc8640b500ab5b45937064",
+        query_type=QueryType.VOYAGER,
+        description="Fetch profile cards/sections"
+    )
+    
+    PROFILE_COMPONENTS = GraphQLQuery(
+        query_id="voyagerIdentityDashProfileComponents.7af5d6f176f11583b382e37e5639e69e",
+        query_type=QueryType.VOYAGER,
+        description="Fetch profile components (experience, education, etc.)"
+    )
+    
+    # Feed queries (Voyager GraphQL)
+    MAIN_FEED = GraphQLQuery(
+        query_id="voyagerFeedDashMainFeed.923020905727c01516495a0ac90bb475",
+        query_type=QueryType.VOYAGER,
+        description="Fetch main feed posts"
+    )
+    
+    # Settings queries (Voyager GraphQL)
+    MY_SETTINGS = GraphQLQuery(
+        query_id="voyagerDashMySettings.7ea6de345b41dfb57b660a9a4bebe1b8",
+        query_type=QueryType.VOYAGER,
+        description="Fetch user settings"
+    )
+    
+    # Messaging queries (Messaging GraphQL)
+    CONVERSATIONS = GraphQLQuery(
+        query_id="messengerConversations.0d5e6781bbee71c3e51c8843c6519f48",
+        query_type=QueryType.MESSAGING,
+        description="Fetch list of conversations"
+    )
+    
+    MESSAGES = GraphQLQuery(
+        query_id="messengerMessages.5846eeb71c981f11e0134cb6626cc314",
+        query_type=QueryType.MESSAGING,
+        description="Fetch messages in a conversation"
+    )
+    
+    MAILBOX_COUNTS = GraphQLQuery(
+        query_id="messengerMailboxCounts.fc528a5a81a76dff212a4a3d2d48e84b",
+        query_type=QueryType.MESSAGING,
+        description="Fetch unread message counts"
+    )
+    
+    # Organization/Company queries (Voyager GraphQL)
+    ORGANIZATION_COMPANIES = GraphQLQuery(
+        query_id="voyagerOrganizationDashCompanies.148b1aebfadd0a455f32806df656c3c1",
+        query_type=QueryType.VOYAGER,
+        description="Fetch company data by universal name"
+    )
+    
+    ORGANIZATION_PAGE_UPDATES = GraphQLQuery(
+        query_id="voyagerFeedDashOrganizationalPageUpdates.827e11d165078dd7a5afaf1cba734121",
+        query_type=QueryType.VOYAGER,
+        description="Fetch company/organization page posts"
+    )
+    
+    # Social/Reactions queries (Voyager GraphQL)
+    REACTIONS = GraphQLQuery(
+        query_id="voyagerSocialDashReactions.41ebf31a9f4c4a84e35a49d5abc9010b",
+        query_type=QueryType.VOYAGER,
+        description="Fetch post reactions with reactor profile data"
+    )
+
+
+class GraphQLClient:
+    """
+    Client for executing LinkedIn GraphQL requests.
+    
+    This class handles the construction of GraphQL URLs and provides
+    a clean interface for making GraphQL requests.
+    """
+    
+    # Base URLs for different GraphQL endpoints (relative to API_BASE_URL which is /voyager/api)
+    VOYAGER_GRAPHQL_URL = "/graphql"
+    MESSAGING_GRAPHQL_URL = "/voyagerMessagingGraphQL/graphql"
+    
+    def __init__(self, session, api_base_url: str):
+        """
+        Initialize the GraphQL client.
+        
+        :param session: requests.Session object with authentication cookies
+        :param api_base_url: Base URL for the LinkedIn API
+        """
+        self.session = session
+        self.api_base_url = api_base_url
+    
+    def _get_endpoint(self, query_type: QueryType) -> str:
+        """Get the appropriate endpoint URL for a query type."""
+        if query_type == QueryType.VOYAGER:
+            return self.VOYAGER_GRAPHQL_URL
+        elif query_type == QueryType.MESSAGING:
+            return self.MESSAGING_GRAPHQL_URL
+        else:
+            raise ValueError(f"Unknown query type: {query_type}")
+    
+    def _build_variables_string(self, variables: Dict[str, Any]) -> str:
+        """
+        Build a LinkedIn-style variables string from a dictionary.
+        
+        LinkedIn uses a custom format for GraphQL variables that looks like:
+        (key1:value1,key2:value2,key3:(nestedKey:nestedValue))
+        
+        :param variables: Dictionary of variables
+        :return: Formatted variables string
+        """
+        def format_value(value: Any) -> str:
+            if isinstance(value, bool):
+                return "true" if value else "false"
+            elif isinstance(value, str):
+                return value
+            elif isinstance(value, (int, float)):
+                return str(value)
+            elif isinstance(value, dict):
+                inner = ",".join(f"{k}:{format_value(v)}" for k, v in value.items())
+                return f"({inner})"
+            elif isinstance(value, list):
+                items = ",".join(format_value(v) for v in value)
+                return f"List({items})"
+            else:
+                return str(value)
+        
+        parts = []
+        for key, value in variables.items():
+            parts.append(f"{key}:{format_value(value)}")
+        
+        return f"({','.join(parts)})"
+    
+    def build_url(
+        self,
+        query: GraphQLQuery,
+        variables: Optional[Dict[str, Any]] = None,
+        include_web_metadata: bool = False
+    ) -> str:
+        """
+        Build a complete GraphQL URL for a query.
+        
+        :param query: The GraphQL query to execute
+        :param variables: Variables to pass to the query
+        :param include_web_metadata: Whether to include web metadata in response
+        :return: Complete URL for the GraphQL request
+        """
+        endpoint = self._get_endpoint(query.query_type)
+        
+        url_parts = [endpoint, "?"]
+        
+        if variables:
+            variables_str = self._build_variables_string(variables)
+            url_parts.append(f"variables={quote(variables_str, safe='(),:-')}")
+            url_parts.append("&")
+        
+        url_parts.append(f"queryId={query.query_id}")
+        
+        if include_web_metadata:
+            url_parts.append("&includeWebMetadata=true")
+        
+        return "".join(url_parts)
+    
+    def execute(
+        self,
+        query: GraphQLQuery,
+        variables: Optional[Dict[str, Any]] = None,
+        include_web_metadata: bool = False,
+        headers: Optional[Dict[str, str]] = None
+    ) -> Dict[str, Any]:
+        """
+        Execute a GraphQL query and return the response.
+        
+        :param query: The GraphQL query to execute
+        :param variables: Variables to pass to the query
+        :param include_web_metadata: Whether to include web metadata
+        :param headers: Additional headers to include in the request
+        :return: JSON response from the API
+        :raises: requests.HTTPError on request failure
+        """
+        url = self.build_url(query, variables, include_web_metadata)
+        full_url = f"{self.api_base_url}{url}"
+        
+        request_headers = {
+            "accept": "application/vnd.linkedin.normalized+json+2.1"
+        }
+        if headers:
+            request_headers.update(headers)
+        
+        logger.debug(f"Executing GraphQL query: {query.query_id}")
+        logger.debug(f"URL: {full_url}")
+        
+        response = self.session.get(full_url, headers=request_headers)
+        response.raise_for_status()
+        
+        return response.json()