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**

CVE-2022-38887: d8s-python

The d8s-json 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-json==0.1.0

Suggestion: remove version 0.1.0 of this project in PyPI

CVE-2022-38882: code execution backdoor · Issue #9 · democritus-project/d8s-json

The d8s-xml 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-xml==0.1.0

Suggestion: remove version 0.1.0 of this project in PyPI

CVE-2022-38886: code execution backdoor · Issue #10 · democritus-project/d8s-xml

The d8s-domains 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 to interact with Hypothesis.

*   Project description
*   Project details
*   Release history
*   Download files

**Project description**

    

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

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

**Usage**

Coming soon...

**Credits**

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

**Project details**  

**Download files**

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

**Source Distribution**

Close

**Hashes for democritus\_hypothesis-2021.1.2101.tar.gz**

Hashes for democritus\_hypothesis-2021.1.2101.tar.gz

Algorithm

Hash digest

SHA256

aaa683f5ebb4a282c1aad77f13359203bb2a3c71d09e282488dfa41df8bae818

MD5

d6621f711f0df829375fcab223aa0e7d

BLAKE2-256

39107eb111d7d7afb3d04c69aa3e5b431def25cc2660a84af1627aa5d9ec4d92

CVE-2022-40807: democritus-hypothesis

The d8s-domains 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

Democritus functions for working with network requests.

*   Project description
*   Project details
*   Release history
*   Download files

**Project description**

  

Democritus functions\[1\] for working with network requests.

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

**Usage**

Coming soon...

**Credits**

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

**Project details**  

**Download files**

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

**Source Distribution**

Close

**Hashes for democritus\_networking-2021.1.2101.tar.gz**

Hashes for democritus\_networking-2021.1.2101.tar.gz

Algorithm

Hash digest

SHA256

a139aafc83f392abc719a84a1733189899f3b8587bc84c5ac2d8835821343048

MD5

bf27bedf981bd377a7686a9ec91e6219

BLAKE2-256

7544ef1be47a0dc02723fda67e5fa4d685677a9deea42cce294be4b5a8c41185

CVE-2022-40427: democritus-networking

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

**Project description**

**Democritus File System (Files and Directories)**

  

Democritus functions\[1\] for working with files and directories.

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

**Usage**

Coming soon...

**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**

Tag

#backdoor