SkullCyberArmy Bypass Shell

Uname : Linux server1.cgrithy.com 3.10.0-1160.95.1.el7.x86_64 #1 SMP Mon Jul 24 13:59:37 UTC 2023 x86_64
Soft : Apache
Ip : 203.161.60.200
Port : 443

cookiejar.py

import asyncio
import contextlib
import datetime
import os  # noqa
import pathlib
import pickle
import re
from collections import defaultdict
from http.cookies import BaseCookie, Morsel, SimpleCookie
from typing import (  # noqa
    DefaultDict,
    Dict,
    Iterable,
    Iterator,
    List,
    Mapping,
    Optional,
    Set,
    Tuple,
    Union,
    cast,
)

from yarl import URL

from .abc import AbstractCookieJar, ClearCookiePredicate
from .helpers import is_ip_address, next_whole_second
from .typedefs import LooseCookies, PathLike, StrOrURL

__all__ = ("CookieJar", "DummyCookieJar")

CookieItem = Union[str, "Morsel[str]"]

class CookieJar(AbstractCookieJar):
    """Implements cookie storage adhering to RFC 6265."""

DATE_TOKENS_RE = re.compile(
        r"[\x09\x20-\x2F\x3B-\x40\x5B-\x60\x7B-\x7E]*"
        r"(?P<token>[\x00-\x08\x0A-\x1F\d:a-zA-Z\x7F-\xFF]+)"
    )

DATE_HMS_TIME_RE = re.compile(r"(\d{1,2}):(\d{1,2}):(\d{1,2})")

DATE_DAY_OF_MONTH_RE = re.compile(r"(\d{1,2})")

DATE_MONTH_RE = re.compile(
        "(jan)|(feb)|(mar)|(apr)|(may)|(jun)|(jul)|" "(aug)|(sep)|(oct)|(nov)|(dec)",
        re.I,
    )

DATE_YEAR_RE = re.compile(r"(\d{2,4})")

MAX_TIME = datetime.datetime.max.replace(tzinfo=datetime.timezone.utc)

MAX_32BIT_TIME = datetime.datetime.utcfromtimestamp(2**31 - 1)

def __init__(
        self,
        *,
        unsafe: bool = False,
        quote_cookie: bool = True,
        treat_as_secure_origin: Union[StrOrURL, List[StrOrURL], None] = None,
        loop: Optional[asyncio.AbstractEventLoop] = None,
    ) -> None:
        super().__init__(loop=loop)
        self._cookies: DefaultDict[Tuple[str, str], SimpleCookie[str]] = defaultdict(
            SimpleCookie
        )
        self._host_only_cookies: Set[Tuple[str, str]] = set()
        self._unsafe = unsafe
        self._quote_cookie = quote_cookie
        if treat_as_secure_origin is None:
            treat_as_secure_origin = []
        elif isinstance(treat_as_secure_origin, URL):
            treat_as_secure_origin = [treat_as_secure_origin.origin()]
        elif isinstance(treat_as_secure_origin, str):
            treat_as_secure_origin = [URL(treat_as_secure_origin).origin()]
        else:
            treat_as_secure_origin = [
                URL(url).origin() if isinstance(url, str) else url.origin()
                for url in treat_as_secure_origin
            ]
        self._treat_as_secure_origin = treat_as_secure_origin
        self._next_expiration = next_whole_second()
        self._expirations: Dict[Tuple[str, str, str], datetime.datetime] = {}
        # #4515: datetime.max may not be representable on 32-bit platforms
        self._max_time = self.MAX_TIME
        try:
            self._max_time.timestamp()
        except OverflowError:
            self._max_time = self.MAX_32BIT_TIME

def save(self, file_path: PathLike) -> None:
        file_path = pathlib.Path(file_path)
        with file_path.open(mode="wb") as f:
            pickle.dump(self._cookies, f, pickle.HIGHEST_PROTOCOL)

def load(self, file_path: PathLike) -> None:
        file_path = pathlib.Path(file_path)
        with file_path.open(mode="rb") as f:
            self._cookies = pickle.load(f)

def clear(self, predicate: Optional[ClearCookiePredicate] = None) -> None:
        if predicate is None:
            self._next_expiration = next_whole_second()
            self._cookies.clear()
            self._host_only_cookies.clear()
            self._expirations.clear()
            return

to_del = []
        now = datetime.datetime.now(datetime.timezone.utc)
        for (domain, path), cookie in self._cookies.items():
            for name, morsel in cookie.items():
                key = (domain, path, name)
                if (
                    key in self._expirations and self._expirations[key] <= now
                ) or predicate(morsel):
                    to_del.append(key)

for domain, path, name in to_del:
            self._host_only_cookies.discard((domain, name))
            key = (domain, path, name)
            if key in self._expirations:
                del self._expirations[(domain, path, name)]
            self._cookies[(domain, path)].pop(name, None)

next_expiration = min(self._expirations.values(), default=self._max_time)
        try:
            self._next_expiration = next_expiration.replace(
                microsecond=0
            ) + datetime.timedelta(seconds=1)
        except OverflowError:
            self._next_expiration = self._max_time

def clear_domain(self, domain: str) -> None:
        self.clear(lambda x: self._is_domain_match(domain, x["domain"]))

def __iter__(self) -> "Iterator[Morsel[str]]":
        self._do_expiration()
        for val in self._cookies.values():
            yield from val.values()

def __len__(self) -> int:
        return sum(1 for i in self)

def _do_expiration(self) -> None:
        self.clear(lambda x: False)

def _expire_cookie(
        self, when: datetime.datetime, domain: str, path: str, name: str
    ) -> None:
        self._next_expiration = min(self._next_expiration, when)
        self._expirations[(domain, path, name)] = when

def update_cookies(self, cookies: LooseCookies, response_url: URL = URL()) -> None:
        """Update cookies."""
        hostname = response_url.raw_host

if not self._unsafe and is_ip_address(hostname):
            # Don't accept cookies from IPs
            return

if isinstance(cookies, Mapping):
            cookies = cookies.items()

for name, cookie in cookies:
            if not isinstance(cookie, Morsel):
                tmp: SimpleCookie[str] = SimpleCookie()
                tmp[name] = cookie  # type: ignore[assignment]
                cookie = tmp[name]

domain = cookie["domain"]

# ignore domains with trailing dots
            if domain.endswith("."):
                domain = ""
                del cookie["domain"]

if not domain and hostname is not None:
                # Set the cookie's domain to the response hostname
                # and set its host-only-flag
                self._host_only_cookies.add((hostname, name))
                domain = cookie["domain"] = hostname

if domain.startswith("."):
                # Remove leading dot
                domain = domain[1:]
                cookie["domain"] = domain

if hostname and not self._is_domain_match(domain, hostname):
                # Setting cookies for different domains is not allowed
                continue

path = cookie["path"]
            if not path or not path.startswith("/"):
                # Set the cookie's path to the response path
                path = response_url.path
                if not path.startswith("/"):
                    path = "/"
                else:
                    # Cut everything from the last slash to the end
                    path = "/" + path[1 : path.rfind("/")]
                cookie["path"] = path

max_age = cookie["max-age"]
            if max_age:
                try:
                    delta_seconds = int(max_age)
                    try:
                        max_age_expiration = datetime.datetime.now(
                            datetime.timezone.utc
                        ) + datetime.timedelta(seconds=delta_seconds)
                    except OverflowError:
                        max_age_expiration = self._max_time
                    self._expire_cookie(max_age_expiration, domain, path, name)
                except ValueError:
                    cookie["max-age"] = ""

else:
                expires = cookie["expires"]
                if expires:
                    expire_time = self._parse_date(expires)
                    if expire_time:
                        self._expire_cookie(expire_time, domain, path, name)
                    else:
                        cookie["expires"] = ""

self._cookies[(domain, path)][name] = cookie

self._do_expiration()

def filter_cookies(
        self, request_url: URL = URL()
    ) -> Union["BaseCookie[str]", "SimpleCookie[str]"]:
        """Returns this jar's cookies filtered by their attributes."""
        self._do_expiration()
        request_url = URL(request_url)
        filtered: Union["SimpleCookie[str]", "BaseCookie[str]"] = (
            SimpleCookie() if self._quote_cookie else BaseCookie()
        )
        hostname = request_url.raw_host or ""
        request_origin = URL()
        with contextlib.suppress(ValueError):
            request_origin = request_url.origin()

is_not_secure = (
            request_url.scheme not in ("https", "wss")
            and request_origin not in self._treat_as_secure_origin
        )

for cookie in self:
            name = cookie.key
            domain = cookie["domain"]

# Send shared cookies
            if not domain:
                filtered[name] = cookie.value
                continue

if not self._unsafe and is_ip_address(hostname):
                continue

if (domain, name) in self._host_only_cookies:
                if domain != hostname:
                    continue
            elif not self._is_domain_match(domain, hostname):
                continue

if not self._is_path_match(request_url.path, cookie["path"]):
                continue

if is_not_secure and cookie["secure"]:
                continue

# It's critical we use the Morsel so the coded_value
            # (based on cookie version) is preserved
            mrsl_val = cast("Morsel[str]", cookie.get(cookie.key, Morsel()))
            mrsl_val.set(cookie.key, cookie.value, cookie.coded_value)
            filtered[name] = mrsl_val

return filtered

@staticmethod
    def _is_domain_match(domain: str, hostname: str) -> bool:
        """Implements domain matching adhering to RFC 6265."""
        if hostname == domain:
            return True

if not hostname.endswith(domain):
            return False

non_matching = hostname[: -len(domain)]

if not non_matching.endswith("."):
            return False

return not is_ip_address(hostname)

@staticmethod
    def _is_path_match(req_path: str, cookie_path: str) -> bool:
        """Implements path matching adhering to RFC 6265."""
        if not req_path.startswith("/"):
            req_path = "/"

if req_path == cookie_path:
            return True

if not req_path.startswith(cookie_path):
            return False

if cookie_path.endswith("/"):
            return True

non_matching = req_path[len(cookie_path) :]

return non_matching.startswith("/")

@classmethod
    def _parse_date(cls, date_str: str) -> Optional[datetime.datetime]:
        """Implements date string parsing adhering to RFC 6265."""
        if not date_str:
            return None

found_time = False
        found_day = False
        found_month = False
        found_year = False

hour = minute = second = 0
        day = 0
        month = 0
        year = 0

for token_match in cls.DATE_TOKENS_RE.finditer(date_str):

token = token_match.group("token")

if not found_time:
                time_match = cls.DATE_HMS_TIME_RE.match(token)
                if time_match:
                    found_time = True
                    hour, minute, second = (int(s) for s in time_match.groups())
                    continue

if not found_day:
                day_match = cls.DATE_DAY_OF_MONTH_RE.match(token)
                if day_match:
                    found_day = True
                    day = int(day_match.group())
                    continue

if not found_month:
                month_match = cls.DATE_MONTH_RE.match(token)
                if month_match:
                    found_month = True
                    assert month_match.lastindex is not None
                    month = month_match.lastindex
                    continue

if not found_year:
                year_match = cls.DATE_YEAR_RE.match(token)
                if year_match:
                    found_year = True
                    year = int(year_match.group())

if 70 <= year <= 99:
            year += 1900
        elif 0 <= year <= 69:
            year += 2000

if False in (found_day, found_month, found_year, found_time):
            return None

if not 1 <= day <= 31:
            return None

if year < 1601 or hour > 23 or minute > 59 or second > 59:
            return None

return datetime.datetime(
            year, month, day, hour, minute, second, tzinfo=datetime.timezone.utc
        )

class DummyCookieJar(AbstractCookieJar):
    """Implements a dummy cookie storage.

It can be used with the ClientSession when no cookie processing is needed.

"""

def __init__(self, *, loop: Optional[asyncio.AbstractEventLoop] = None) -> None:
        super().__init__(loop=loop)

def __iter__(self) -> "Iterator[Morsel[str]]":
        while False:
            yield None

def __len__(self) -> int:
        return 0

def clear(self, predicate: Optional[ClearCookiePredicate] = None) -> None:
        pass

def clear_domain(self, domain: str) -> None:
        pass

def update_cookies(self, cookies: LooseCookies, response_url: URL = URL()) -> None:
        pass

def filter_cookies(self, request_url: URL) -> "BaseCookie[str]":
        return SimpleCookie()

Name	Type	Size	Permission	Last Modified	Actions
.	dir	-	0755	2023-09-12 12:51:40
..	dir	-	0755	2023-09-13 09:03:03
.hash	dir	-	0755	2023-09-12 12:51:40
__pycache__	dir	-	0755	2023-09-12 12:51:47
__init__.py	text/x-script.python	6.71 KB	0644	2023-06-23 12:19:28
_cparser.pxd	text/plain	4.88 KB	0644	2023-06-23 12:19:28
_find_header.pxd	text/plain	68 B	0644	2023-06-23 12:19:28
_headers.pxi	text/x-script.python	1.96 KB	0644	2023-06-23 12:19:28
_helpers.cpython-311-x86_64-linux-gnu.so	application/x-pie-executable	293.69 KB	0755	2023-06-23 12:19:28
_helpers.pyi	text/x-script.python	202 B	0644	2023-06-23 12:19:28
_helpers.pyx	text/x-script.python	1.02 KB	0644	2023-06-23 12:19:28
_http_parser.cpython-311-x86_64-linux-gnu.so	application/x-pie-executable	2.32 MB	0755	2023-06-23 12:19:28
_http_parser.pyx	text/x-script.python	26.7 KB	0644	2023-06-23 12:19:28
_http_writer.cpython-311-x86_64-linux-gnu.so	application/x-pie-executable	289.3 KB	0755	2023-06-23 12:19:28
_http_writer.pyx	text/x-script.python	4.47 KB	0644	2023-06-23 12:19:28
_websocket.cpython-311-x86_64-linux-gnu.so	application/x-pie-executable	117.55 KB	0755	2023-06-23 12:19:28
_websocket.pyx	text/x-script.python	1.52 KB	0644	2023-06-23 12:19:28
abc.py	text/x-script.python	5.38 KB	0644	2023-06-23 12:19:28
base_protocol.py	text/x-script.python	2.68 KB	0644	2023-06-23 12:19:28
client.py	text/plain	43.98 KB	0644	2023-06-23 12:19:28
client_exceptions.py	text/plain	9.05 KB	0644	2023-06-23 12:19:28
client_proto.py	text/x-script.python	7.98 KB	0644	2023-06-23 12:19:28
client_reqrep.py	text/x-script.python	36.11 KB	0644	2023-06-23 12:19:28
client_ws.py	text/plain	10.27 KB	0644	2023-06-23 12:19:28
connector.py	text/x-script.python	49.98 KB	0644	2023-06-23 12:19:28
cookiejar.py	text/x-script.python	13.33 KB	0644	2023-06-23 12:19:28
formdata.py	text/x-script.python	5.96 KB	0644	2023-06-23 12:19:28
hdrs.py	text/plain	4.61 KB	0644	2023-06-23 12:19:28
helpers.py	text/plain	25.78 KB	0644	2023-06-23 12:19:28
http.py	text/x-script.python	1.76 KB	0644	2023-06-23 12:19:28
http_exceptions.py	text/plain	2.53 KB	0644	2023-06-23 12:19:28
http_parser.py	text/x-script.python	32.32 KB	0644	2023-06-23 12:19:28
http_websocket.py	text/plain	24.71 KB	0644	2023-06-23 12:19:28
http_writer.py	text/plain	5.79 KB	0644	2023-06-23 12:19:28
locks.py	text/x-script.python	1.11 KB	0644	2023-06-23 12:19:28
log.py	text/plain	325 B	0644	2023-06-23 12:19:28
multipart.py	text/x-script.python	31.56 KB	0644	2023-06-23 12:19:28
payload.py	text/x-script.python	13.31 KB	0644	2023-06-23 12:19:28
payload_streamer.py	text/plain	2.06 KB	0644	2023-06-23 12:19:28
py.typed	text/plain	7 B	0644	2023-06-23 12:19:28
pytest_plugin.py	text/x-script.python	11.5 KB	0644	2023-06-23 12:19:28
resolver.py	text/x-script.python	4.97 KB	0644	2023-06-23 12:19:28
streams.py	text/x-script.python	20.27 KB	0644	2023-06-23 12:19:28
tcp_helpers.py	text/plain	961 B	0644	2023-06-23 12:19:28
test_utils.py	text/plain	20.93 KB	0644	2023-06-23 12:19:28
tracing.py	text/x-script.python	14.82 KB	0644	2023-06-23 12:19:28
typedefs.py	text/x-script.python	1.72 KB	0644	2023-06-23 12:19:28
web.py	text/x-script.python	17.66 KB	0644	2023-06-23 12:19:28
web_app.py	text/x-script.python	16.77 KB	0644	2023-06-23 12:19:28
web_exceptions.py	text/x-script.python	9.86 KB	0644	2023-06-23 12:19:28
web_fileresponse.py	text/x-script.python	10.53 KB	0644	2023-06-23 12:19:28
web_log.py	text/x-script.python	7.38 KB	0644	2023-06-23 12:19:28
web_middlewares.py	text/x-script.python	4.04 KB	0644	2023-06-23 12:19:28
web_protocol.py	text/x-script.python	21.87 KB	0644	2023-06-23 12:19:28
web_request.py	text/x-script.python	27.53 KB	0644	2023-06-23 12:19:28
web_response.py	text/x-script.python	26.83 KB	0644	2023-06-23 12:19:28
web_routedef.py	text/x-script.python	6.01 KB	0644	2023-06-23 12:19:28
web_runner.py	text/x-script.python	10.9 KB	0644	2023-06-23 12:19:28
web_server.py	text/plain	2 KB	0644	2023-06-23 12:19:28
web_urldispatcher.py	text/x-script.python	38.56 KB	0644	2023-06-23 12:19:28
web_ws.py	text/x-script.python	16.74 KB	0644	2023-06-23 12:19:28
worker.py	text/plain	8.56 KB	0644	2023-06-23 12:19:28