Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2026-03-27 02:38
📄 __about__.py # This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. from __future__ import annotations __all__ = [ "__version__", "__author__", "__copyright__", ] __version__ = "41.0.2" __author__ = "The Python Cryptographic Authority and individual contributors" __copyright__ = f"Copyright 2013-2023 {__author__}"	445 B	2026-01-20 12:58
📄 __init__.py # This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. from __future__ import annotations from cryptography.__about__ import __author__, __copyright__, __version__ __all__ = [ "__version__", "__author__", "__copyright__", ]	364 B	2026-01-20 12:58
📁 __pycache__	-	2026-03-21 15:45
📄 exceptions.py # This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. from __future__ import annotations import typing from cryptography.hazmat.bindings._rust import exceptions as rust_exceptions if typing.TYPE_CHECKING: from cryptography.hazmat.bindings._rust import openssl as rust_openssl _Reasons = rust_exceptions._Reasons class UnsupportedAlgorithm(Exception): def __init__( self, message: str, reason: typing.Optional[_Reasons] = None ) -> None: super().__init__(message) self._reason = reason class AlreadyFinalized(Exception): pass class AlreadyUpdated(Exception): pass class NotYetFinalized(Exception): pass class InvalidTag(Exception): pass class InvalidSignature(Exception): pass class InternalError(Exception): def __init__( self, msg: str, err_code: typing.List[rust_openssl.OpenSSLError] ) -> None: super().__init__(msg) self.err_code = err_code class InvalidKey(Exception): pass	1.09 KB	2026-01-20 12:58
📄 fernet.py # This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. from __future__ import annotations import base64 import binascii import os import time import typing from cryptography import utils from cryptography.exceptions import InvalidSignature from cryptography.hazmat.primitives import hashes, padding from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes from cryptography.hazmat.primitives.hmac import HMAC class InvalidToken(Exception): pass _MAX_CLOCK_SKEW = 60 class Fernet: def __init__( self, key: typing.Union[bytes, str], backend: typing.Any = None, ) -> None: try: key = base64.urlsafe_b64decode(key) except binascii.Error as exc: raise ValueError( "Fernet key must be 32 url-safe base64-encoded bytes." ) from exc if len(key) != 32: raise ValueError( "Fernet key must be 32 url-safe base64-encoded bytes." ) self._signing_key = key[:16] self._encryption_key = key[16:] @classmethod def generate_key(cls) -> bytes: return base64.urlsafe_b64encode(os.urandom(32)) def encrypt(self, data: bytes) -> bytes: return self.encrypt_at_time(data, int(time.time())) def encrypt_at_time(self, data: bytes, current_time: int) -> bytes: iv = os.urandom(16) return self._encrypt_from_parts(data, current_time, iv) def _encrypt_from_parts( self, data: bytes, current_time: int, iv: bytes ) -> bytes: utils._check_bytes("data", data) padder = padding.PKCS7(algorithms.AES.block_size).padder() padded_data = padder.update(data) + padder.finalize() encryptor = Cipher( algorithms.AES(self._encryption_key), modes.CBC(iv), ).encryptor() ciphertext = encryptor.update(padded_data) + encryptor.finalize() basic_parts = ( b"\x80" + current_time.to_bytes(length=8, byteorder="big") + iv + ciphertext ) h = HMAC(self._signing_key, hashes.SHA256()) h.update(basic_parts) hmac = h.finalize() return base64.urlsafe_b64encode(basic_parts + hmac) def decrypt( self, token: typing.Union[bytes, str], ttl: typing.Optional[int] = None ) -> bytes: timestamp, data = Fernet._get_unverified_token_data(token) if ttl is None: time_info = None else: time_info = (ttl, int(time.time())) return self._decrypt_data(data, timestamp, time_info) def decrypt_at_time( self, token: typing.Union[bytes, str], ttl: int, current_time: int ) -> bytes: if ttl is None: raise ValueError( "decrypt_at_time() can only be used with a non-None ttl" ) timestamp, data = Fernet._get_unverified_token_data(token) return self._decrypt_data(data, timestamp, (ttl, current_time)) def extract_timestamp(self, token: typing.Union[bytes, str]) -> int: timestamp, data = Fernet._get_unverified_token_data(token) # Verify the token was not tampered with. self._verify_signature(data) return timestamp @staticmethod def _get_unverified_token_data( token: typing.Union[bytes, str] ) -> typing.Tuple[int, bytes]: if not isinstance(token, (str, bytes)): raise TypeError("token must be bytes or str") try: data = base64.urlsafe_b64decode(token) except (TypeError, binascii.Error): raise InvalidToken if not data or data[0] != 0x80: raise InvalidToken if len(data) < 9: raise InvalidToken timestamp = int.from_bytes(data[1:9], byteorder="big") return timestamp, data def _verify_signature(self, data: bytes) -> None: h = HMAC(self._signing_key, hashes.SHA256()) h.update(data[:-32]) try: h.verify(data[-32:]) except InvalidSignature: raise InvalidToken def _decrypt_data( self, data: bytes, timestamp: int, time_info: typing.Optional[typing.Tuple[int, int]], ) -> bytes: if time_info is not None: ttl, current_time = time_info if timestamp + ttl < current_time: raise InvalidToken if current_time + _MAX_CLOCK_SKEW < timestamp: raise InvalidToken self._verify_signature(data) iv = data[9:25] ciphertext = data[25:-32] decryptor = Cipher( algorithms.AES(self._encryption_key), modes.CBC(iv) ).decryptor() plaintext_padded = decryptor.update(ciphertext) try: plaintext_padded += decryptor.finalize() except ValueError: raise InvalidToken unpadder = padding.PKCS7(algorithms.AES.block_size).unpadder() unpadded = unpadder.update(plaintext_padded) try: unpadded += unpadder.finalize() except ValueError: raise InvalidToken return unpadded class MultiFernet: def __init__(self, fernets: typing.Iterable[Fernet]): fernets = list(fernets) if not fernets: raise ValueError( "MultiFernet requires at least one Fernet instance" ) self._fernets = fernets def encrypt(self, msg: bytes) -> bytes: return self.encrypt_at_time(msg, int(time.time())) def encrypt_at_time(self, msg: bytes, current_time: int) -> bytes: return self._fernets[0].encrypt_at_time(msg, current_time) def rotate(self, msg: typing.Union[bytes, str]) -> bytes: timestamp, data = Fernet._get_unverified_token_data(msg) for f in self._fernets: try: p = f._decrypt_data(data, timestamp, None) break except InvalidToken: pass else: raise InvalidToken iv = os.urandom(16) return self._fernets[0]._encrypt_from_parts(p, timestamp, iv) def decrypt( self, msg: typing.Union[bytes, str], ttl: typing.Optional[int] = None ) -> bytes: for f in self._fernets: try: return f.decrypt(msg, ttl) except InvalidToken: pass raise InvalidToken def decrypt_at_time( self, msg: typing.Union[bytes, str], ttl: int, current_time: int ) -> bytes: for f in self._fernets: try: return f.decrypt_at_time(msg, ttl, current_time) except InvalidToken: pass raise InvalidToken	6.72 KB	2026-01-20 12:58
📁 hazmat	-	2026-03-21 15:45
📄 py.typed	0 B	2026-01-20 12:58
📄 utils.py # This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. from __future__ import annotations import enum import sys import types import typing import warnings # We use a UserWarning subclass, instead of DeprecationWarning, because CPython # decided deprecation warnings should be invisble by default. class CryptographyDeprecationWarning(UserWarning): pass # Several APIs were deprecated with no specific end-of-life date because of the # ubiquity of their use. They should not be removed until we agree on when that # cycle ends. DeprecatedIn36 = CryptographyDeprecationWarning DeprecatedIn37 = CryptographyDeprecationWarning DeprecatedIn40 = CryptographyDeprecationWarning DeprecatedIn41 = CryptographyDeprecationWarning def _check_bytes(name: str, value: bytes) -> None: if not isinstance(value, bytes): raise TypeError(f"{name} must be bytes") def _check_byteslike(name: str, value: bytes) -> None: try: memoryview(value) except TypeError: raise TypeError(f"{name} must be bytes-like") def int_to_bytes(integer: int, length: typing.Optional[int] = None) -> bytes: return integer.to_bytes( length or (integer.bit_length() + 7) // 8 or 1, "big" ) def _extract_buffer_length(obj: typing.Any) -> typing.Tuple[typing.Any, int]: from cryptography.hazmat.bindings._rust import _openssl buf = _openssl.ffi.from_buffer(obj) return buf, int(_openssl.ffi.cast("uintptr_t", buf)) class InterfaceNotImplemented(Exception): pass class _DeprecatedValue: def __init__(self, value: object, message: str, warning_class): self.value = value self.message = message self.warning_class = warning_class class _ModuleWithDeprecations(types.ModuleType): def __init__(self, module: types.ModuleType): super().__init__(module.__name__) self.__dict__["_module"] = module def __getattr__(self, attr: str) -> object: obj = getattr(self._module, attr) if isinstance(obj, _DeprecatedValue): warnings.warn(obj.message, obj.warning_class, stacklevel=2) obj = obj.value return obj def __setattr__(self, attr: str, value: object) -> None: setattr(self._module, attr, value) def __delattr__(self, attr: str) -> None: obj = getattr(self._module, attr) if isinstance(obj, _DeprecatedValue): warnings.warn(obj.message, obj.warning_class, stacklevel=2) delattr(self._module, attr) def __dir__(self) -> typing.Sequence[str]: return ["_module"] + dir(self._module) def deprecated( value: object, module_name: str, message: str, warning_class: typing.Type[Warning], name: typing.Optional[str] = None, ) -> _DeprecatedValue: module = sys.modules[module_name] if not isinstance(module, _ModuleWithDeprecations): sys.modules[module_name] = module = _ModuleWithDeprecations(module) dv = _DeprecatedValue(value, message, warning_class) # Maintain backwards compatibility with `name is None` for pyOpenSSL. if name is not None: setattr(module, name, dv) return dv def cached_property(func: typing.Callable) -> property: cached_name = f"_cached_{func}" sentinel = object() def inner(instance: object): cache = getattr(instance, cached_name, sentinel) if cache is not sentinel: return cache result = func(instance) setattr(instance, cached_name, result) return result return property(inner) # Python 3.10 changed representation of enums. We use well-defined object # representation and string representation from Python 3.9. class Enum(enum.Enum): def __repr__(self) -> str: return f"<{self.__class__.__name__}.{self._name_}: {self._value_!r}>" def __str__(self) -> str: return f"{self.__class__.__name__}.{self._name_}"	3.92 KB	2026-01-20 12:58
📁 x509	-	2026-03-21 15:45

Terminal