FX Shell Backdor

Website : vivehg.com

Ip Address : 172.31.2.149

Port : 443

Kernel : Linux 52-72-122-155.cprapid.com 5.15.0-1084-aws #91~20.04.1-Ubuntu SMP Fri May 2 06:59:36 UTC 2025 x86_64

Protokol : HTTP/1.1

Save Data :

Koneksi :

Server : Apache

Root : /home/vivehg/public_html

G-Interface : CGI/1.1

R-Method : GET

Browser : Lainnya

Version Shell : 1.0 (Release candidate)

Author : FierzaXploit/Mr.MF33

PATH : /lib/python3/dist-packages/twisted/logger/

Buat File

Buat Folder

Buat Ransomweb

# -*- test-case-name: twisted.logger.test.test_io -*-
# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.

"""
File-like object that logs.
"""

import sys

from ._levels import LogLevel

class LoggingFile(object):
    """
    File-like object that turns C{write()} calls into logging events.

Note that because event formats are C{unicode}, C{bytes} received via
    C{write()} are converted to C{unicode}, which is the opposite of what
    C{file} does.

@ivar softspace: File-like L{'softspace' attribute <file.softspace>}; zero
        or one.
    @type softspace: L{int}
    """

softspace = 0

def __init__(self, logger, level=LogLevel.info, encoding=None):
        """
        @param logger: the logger to log through.

@param level: the log level to emit events with.

@param encoding: The encoding to expect when receiving bytes via
            C{write()}.  If L{None}, use C{sys.getdefaultencoding()}.
        @type encoding: L{str}

@param log: The logger to send events to.
        @type log: L{Logger}
        """
        self.level = level
        self.log = logger

if encoding is None:
            self._encoding = sys.getdefaultencoding()
        else:
            self._encoding = encoding

self._buffer = ""
        self._closed = False

@property
    def closed(self):
        """
        Read-only property.  Is the file closed?

@return: true if closed, otherwise false.
        @rtype: L{bool}
        """
        return self._closed

@property
    def encoding(self):
        """
        Read-only property.   File encoding.

@return: an encoding.
        @rtype: L{str}
        """
        return self._encoding

@property
    def mode(self):
        """
        Read-only property.  File mode.

@return: "w"
        @rtype: L{str}
        """
        return "w"

@property
    def newlines(self):
        """
        Read-only property.  Types of newlines encountered.

@return: L{None}
        @rtype: L{None}
        """
        return None

@property
    def name(self):
        """
        The name of this file; a repr-style string giving information about its
        namespace.

@return: A file name.
        @rtype: L{str}
        """
        return (
            "<{0} {1}#{2}>".format(
                self.__class__.__name__,
                self.log.namespace,
                self.level.name,
            )
        )

def close(self):
        """
        Close this file so it can no longer be written to.
        """
        self._closed = True

def flush(self):
        """
        No-op; this file does not buffer.
        """
        pass

def fileno(self):
        """
        Returns an invalid file descriptor, since this is not backed by an FD.

@return: C{-1}
        @rtype: L{int}
        """
        return -1

def isatty(self):
        """
        A L{LoggingFile} is not a TTY.

@return: C{False}
        @rtype: L{bool}
        """
        return False

def write(self, string):
        """
        Log the given message.

@param string: Data to write.
        @type string: L{bytes} in this file's preferred encoding or L{unicode}
        """
        if self._closed:
            raise ValueError("I/O operation on closed file")

if isinstance(string, bytes):
            string = string.decode(self._encoding)

lines = (self._buffer + string).split("\n")
        self._buffer = lines[-1]
        lines = lines[0:-1]

for line in lines:
            self.log.emit(self.level, format=u"{log_io}", log_io=line)

def writelines(self, lines):
        """
        Log each of the given lines as a separate message.

@param lines: Data to write.
        @type lines: iterable of L{unicode} or L{bytes} in this file's
            declared encoding
        """
        for line in lines:
            self.write(line)

def _unsupported(self, *args):
        """
        Template for unsupported operations.

@param args: Arguments.
        @type args: tuple of L{object}
        """
        raise IOError("unsupported operation")

read       = _unsupported
    next       = _unsupported
    readline   = _unsupported
    readlines  = _unsupported
    xreadlines = _unsupported
    seek       = _unsupported
    tell       = _unsupported
    truncate   = _unsupported

Type	Name	options
	__pycache__
	test
	__init__.py
	__pycache__
	_buffer.py
	_file.py
	_filter.py
	_flatten.py
	_format.py
	_global.py
	_io.py
	_json.py
	_legacy.py
	_levels.py
	_logger.py
	_observer.py
	_stdlib.py
	_util.py
	test