Delete multilingual_toxic_files

multilingual_toxic_comment_files/.gitattributes

@@ -1 +0,0 @@
-Multilingual_toxic_comment_classifier/ filter=lfs diff=lfs merge=lfs -text

multilingual_toxic_comment_files/Multilingual_toxic_comment_classifier/fingerprint.pb

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:9a9d19f63b7b7b7dcfa8f357dd1fd99fa99f3a5ff34a7570f182d8a3aa20823c
-size 56

multilingual_toxic_comment_files/Multilingual_toxic_comment_classifier/keras_metadata.pb

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:82f64bf076deed233b6fc5b1571df01a1962cec9329ab1e666b1a40e342f7077
-size 335379

multilingual_toxic_comment_files/Multilingual_toxic_comment_classifier/saved_model.pb

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:e6d665d394967b71ef01e9726c26bacef102200d68d760a5ed5178356f788157
-size 14061456

multilingual_toxic_comment_files/Multilingual_toxic_comment_classifier/variables/variables.data-00000-of-00001

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:c62edbd59c81c2c336b4fe4dae3f4e4d34b410ebe038c32904a538c91eb4636d
-size 6731757780

multilingual_toxic_comment_files/app.py

@@ -1,55 +0,0 @@
-import tensorflow as tf
-import gradio as gr
-import pandas as pd
-from transformers import AutoTokenizer
-
-model_save_path = "Multilingual_toxic_comment_classifier/"
-### Loading the fine-tuned model ###
-loaded_model = tf.keras.models.load_model(model_save_path)
-### Initializing the tokenizer ###
-tokenizer_ = AutoTokenizer.from_pretrained("xlm-roberta-large")
-
-examples_list = [
-    [example]
-    for example in pd.read_csv("examples/sample_comments.csv")["comment_text"].tolist()
-]
-
-
-def prep_data(text, tokenizer, max_len=192):
-    tokens = tokenizer(
-        text,
-        max_length=max_len,
-        truncation=True,
-        padding="max_length",
-        add_special_tokens=True,
-        return_tensors="tf",
-    )
-
-    return {
-        "input_ids": tokens["input_ids"],
-        "attention_mask": tokens["attention_mask"],
-    }
-
-
-def predict(text):
-    prob_of_toxic_comment = loaded_model.predict(
-        prep_data(text=text, tokenizer=tokenizer_, max_len=192)
-    )[0][0]
-    prob_of_non_toxic_comment = 1 - prob_of_toxic_comment
-    prob_of_toxic_comment, prob_of_non_toxic_comment
-    probs = {
-        "prob_of_toxic_comment": float(prob_of_toxic_comment),
-        "prob_of_non_toxic_comment": float(prob_of_non_toxic_comment),
-    }
-    return probs
-
-
-interface = gr.Interface(
-    fn=predict,
-    inputs=gr.components.Textbox(lines=4, label="Comment"),
-    outputs=[gr.Label(label="Probabilities")],
-    examples=examples_list,
-    title="Multi-Lingual Toxic Comment Classification.",
-    description="XLM-Roberta Large model",
-)
-interface.launch(debug=False, share=True)

multilingual_toxic_comment_files/env/Lib/site-packages/Crypto/Cipher/AES.py

@@ -1,234 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-#  Cipher/AES.py : AES
-#
-# ===================================================================
-# The contents of this file are dedicated to the public domain.  To
-# the extent that dedication to the public domain is not available,
-# everyone is granted a worldwide, perpetual, royalty-free,
-# non-exclusive license to exercise all rights associated with the
-# contents of this file for any purpose whatsoever.
-# No rights are reserved.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
-# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-# ===================================================================
-
-import sys
-
-from Crypto.Cipher import _create_cipher
-from Crypto.Util._raw_api import (load_pycryptodome_raw_lib,
-                                  VoidPointer, SmartPointer,
-                                  c_size_t, c_uint8_ptr)
-
-from Crypto.Util import _cpu_features
-from Crypto.Random import get_random_bytes
-
-MODE_ECB = 1        #: Electronic Code Book (:ref:`ecb_mode`)
-MODE_CBC = 2        #: Cipher-Block Chaining (:ref:`cbc_mode`)
-MODE_CFB = 3        #: Cipher Feedback (:ref:`cfb_mode`)
-MODE_OFB = 5        #: Output Feedback (:ref:`ofb_mode`)
-MODE_CTR = 6        #: Counter mode (:ref:`ctr_mode`)
-MODE_OPENPGP = 7    #: OpenPGP mode (:ref:`openpgp_mode`)
-MODE_CCM = 8        #: Counter with CBC-MAC (:ref:`ccm_mode`)
-MODE_EAX = 9        #: :ref:`eax_mode`
-MODE_SIV = 10       #: Galois Counter Mode (:ref:`gcm_mode`)
-MODE_GCM = 11       #: Synthetic Initialization Vector (:ref:`siv_mode`)
-MODE_OCB = 12       #: Offset Code Book (:ref:`ocb_mode`)
-
-
-_cproto = """
-        int AES_start_operation(const uint8_t key[],
-                                size_t key_len,
-                                void **pResult);
-        int AES_encrypt(const void *state,
-                        const uint8_t *in,
-                        uint8_t *out,
-                        size_t data_len);
-        int AES_decrypt(const void *state,
-                        const uint8_t *in,
-                        uint8_t *out,
-                        size_t data_len);
-        int AES_stop_operation(void *state);
-        """
-
-
-# Load portable AES
-_raw_aes_lib = load_pycryptodome_raw_lib("Crypto.Cipher._raw_aes",
-                                         _cproto)
-
-# Try to load AES with AES NI instructions
-try:
-    _raw_aesni_lib = None
-    if _cpu_features.have_aes_ni():
-        _raw_aesni_lib = load_pycryptodome_raw_lib("Crypto.Cipher._raw_aesni",
-                                                   _cproto.replace("AES",
-                                                                   "AESNI"))
-# _raw_aesni may not have been compiled in
-except OSError:
-    pass
-
-
-def _create_base_cipher(dict_parameters):
-    """This method instantiates and returns a handle to a low-level
-    base cipher. It will absorb named parameters in the process."""
-
-    use_aesni = dict_parameters.pop("use_aesni", True)
-
-    try:
-        key = dict_parameters.pop("key")
-    except KeyError:
-        raise TypeError("Missing 'key' parameter")
-
-    if len(key) not in key_size:
-        raise ValueError("Incorrect AES key length (%d bytes)" % len(key))
-
-    if use_aesni and _raw_aesni_lib:
-        start_operation = _raw_aesni_lib.AESNI_start_operation
-        stop_operation = _raw_aesni_lib.AESNI_stop_operation
-    else:
-        start_operation = _raw_aes_lib.AES_start_operation
-        stop_operation = _raw_aes_lib.AES_stop_operation
-
-    cipher = VoidPointer()
-    result = start_operation(c_uint8_ptr(key),
-                             c_size_t(len(key)),
-                             cipher.address_of())
-    if result:
-        raise ValueError("Error %X while instantiating the AES cipher"
-                         % result)
-    return SmartPointer(cipher.get(), stop_operation)
-
-
-def _derive_Poly1305_key_pair(key, nonce):
-    """Derive a tuple (r, s, nonce) for a Poly1305 MAC.
-
-    If nonce is ``None``, a new 16-byte nonce is generated.
-    """
-
-    if len(key) != 32:
-        raise ValueError("Poly1305 with AES requires a 32-byte key")
-
-    if nonce is None:
-        nonce = get_random_bytes(16)
-    elif len(nonce) != 16:
-        raise ValueError("Poly1305 with AES requires a 16-byte nonce")
-
-    s = new(key[:16], MODE_ECB).encrypt(nonce)
-    return key[16:], s, nonce
-
-
-def new(key, mode, *args, **kwargs):
-    """Create a new AES cipher.
-
-    Args:
-      key(bytes/bytearray/memoryview):
-        The secret key to use in the symmetric cipher.
-
-        It must be 16 (*AES-128)*, 24 (*AES-192*) or 32 (*AES-256*) bytes long.
-
-        For ``MODE_SIV`` only, it doubles to 32, 48, or 64 bytes.
-      mode (a ``MODE_*`` constant):
-        The chaining mode to use for encryption or decryption.
-        If in doubt, use ``MODE_EAX``.
-
-    Keyword Args:
-      iv (bytes/bytearray/memoryview):
-        (Only applicable for ``MODE_CBC``, ``MODE_CFB``, ``MODE_OFB``,
-        and ``MODE_OPENPGP`` modes).
-
-        The initialization vector to use for encryption or decryption.
-
-        For ``MODE_CBC``, ``MODE_CFB``, and ``MODE_OFB`` it must be 16 bytes long.
-
-        For ``MODE_OPENPGP`` mode only,
-        it must be 16 bytes long for encryption
-        and 18 bytes for decryption (in the latter case, it is
-        actually the *encrypted* IV which was prefixed to the ciphertext).
-
-        If not provided, a random byte string is generated (you must then
-        read its value with the :attr:`iv` attribute).
-
-      nonce (bytes/bytearray/memoryview):
-        (Only applicable for ``MODE_CCM``, ``MODE_EAX``, ``MODE_GCM``,
-        ``MODE_SIV``, ``MODE_OCB``, and ``MODE_CTR``).
-
-        A value that must never be reused for any other encryption done
-        with this key (except possibly for ``MODE_SIV``, see below).
-
-        For ``MODE_EAX``, ``MODE_GCM`` and ``MODE_SIV`` there are no
-        restrictions on its length (recommended: **16** bytes).
-
-        For ``MODE_CCM``, its length must be in the range **[7..13]**.
-        Bear in mind that with CCM there is a trade-off between nonce
-        length and maximum message size. Recommendation: **11** bytes.
-
-        For ``MODE_OCB``, its length must be in the range **[1..15]**
-        (recommended: **15**).
-
-        For ``MODE_CTR``, its length must be in the range **[0..15]**
-        (recommended: **8**).
-
-        For ``MODE_SIV``, the nonce is optional, if it is not specified,
-        then no nonce is being used, which renders the encryption
-        deterministic.
-
-        If not provided, for modes other than ``MODE_SIV``, a random
-        byte string of the recommended length is used (you must then
-        read its value with the :attr:`nonce` attribute).
-
-      segment_size (integer):
-        (Only ``MODE_CFB``).The number of **bits** the plaintext and ciphertext
-        are segmented in. It must be a multiple of 8.
-        If not specified, it will be assumed to be 8.
-
-      mac_len (integer):
-        (Only ``MODE_EAX``, ``MODE_GCM``, ``MODE_OCB``, ``MODE_CCM``)
-        Length of the authentication tag, in bytes.
-
-        It must be even and in the range **[4..16]**.
-        The recommended value (and the default, if not specified) is **16**.
-
-      msg_len (integer):
-        (Only ``MODE_CCM``). Length of the message to (de)cipher.
-        If not specified, ``encrypt`` must be called with the entire message.
-        Similarly, ``decrypt`` can only be called once.
-
-      assoc_len (integer):
-        (Only ``MODE_CCM``). Length of the associated data.
-        If not specified, all associated data is buffered internally,
-        which may represent a problem for very large messages.
-
-      initial_value (integer or bytes/bytearray/memoryview):
-        (Only ``MODE_CTR``).
-        The initial value for the counter. If not present, the cipher will
-        start counting from 0. The value is incremented by one for each block.
-        The counter number is encoded in big endian mode.
-
-      counter (object):
-        (Only ``MODE_CTR``).
-        Instance of ``Crypto.Util.Counter``, which allows full customization
-        of the counter block. This parameter is incompatible to both ``nonce``
-        and ``initial_value``.
-
-      use_aesni: (boolean):
-        Use Intel AES-NI hardware extensions (default: use if available).
-
-    Returns:
-        an AES object, of the applicable mode.
-    """
-
-    kwargs["add_aes_modes"] = True
-    return _create_cipher(sys.modules[__name__], key, mode, *args, **kwargs)
-
-
-# Size of a data block (in bytes)
-block_size = 16
-# Size of a key (in bytes)
-key_size = (16, 24, 32)

multilingual_toxic_comment_files/env/Lib/site-packages/Crypto/Cipher/AES.pyi

@@ -1,154 +0,0 @@
-from typing import ByteString, Dict, Optional, Tuple, Union, overload
-from typing_extensions import Literal
-
-from Crypto.Cipher._mode_ecb import EcbMode
-from Crypto.Cipher._mode_cbc import CbcMode
-from Crypto.Cipher._mode_cfb import CfbMode
-from Crypto.Cipher._mode_ofb import OfbMode
-from Crypto.Cipher._mode_ctr import CtrMode
-from Crypto.Cipher._mode_openpgp import OpenPgpMode
-from Crypto.Cipher._mode_ccm import CcmMode
-from Crypto.Cipher._mode_eax import EaxMode
-from Crypto.Cipher._mode_gcm import GcmMode
-from Crypto.Cipher._mode_siv import SivMode
-from Crypto.Cipher._mode_ocb import OcbMode
-
-MODE_ECB: Literal[1]
-MODE_CBC: Literal[2]
-MODE_CFB: Literal[3]
-MODE_OFB: Literal[5]
-MODE_CTR: Literal[6]
-MODE_OPENPGP: Literal[7]
-MODE_CCM: Literal[8]
-MODE_EAX: Literal[9]
-MODE_SIV: Literal[10]
-MODE_GCM: Literal[11]
-MODE_OCB: Literal[12]
-
-# MODE_ECB
-@overload
-def new(key: ByteString,
-        mode: Literal[1],
-        use_aesni : bool = ...) -> \
-        EcbMode: ...
-
-# MODE_CBC
-@overload
-def new(key: ByteString,
-        mode: Literal[2],
-        iv : Optional[ByteString] = ...,
-        use_aesni : bool = ...) -> \
-        CbcMode: ...
-
-@overload
-def new(key: ByteString,
-        mode: Literal[2],
-        IV : Optional[ByteString] = ...,
-        use_aesni : bool = ...) -> \
-        CbcMode: ...
-
-# MODE_CFB
-@overload
-def new(key: ByteString,
-        mode: Literal[3],
-        iv : Optional[ByteString] = ...,
-        segment_size : int = ...,
-        use_aesni : bool = ...) -> \
-        CfbMode: ...
-
-@overload
-def new(key: ByteString,
-        mode: Literal[3],
-        IV : Optional[ByteString] = ...,
-        segment_size : int = ...,
-        use_aesni : bool = ...) -> \
-        CfbMode: ...
-
-# MODE_OFB
-@overload
-def new(key: ByteString,
-        mode: Literal[5],
-        iv : Optional[ByteString] = ...,
-        use_aesni : bool = ...) -> \
-        OfbMode: ...
-
-@overload
-def new(key: ByteString,
-        mode: Literal[5],
-        IV : Optional[ByteString] = ...,
-        use_aesni : bool = ...) -> \
-        OfbMode: ...
-
-# MODE_CTR
-@overload
-def new(key: ByteString,
-        mode: Literal[6],
-        nonce : Optional[ByteString] = ...,
-        initial_value : Union[int, ByteString] = ...,
-        counter : Dict = ...,
-        use_aesni : bool = ...) -> \
-        CtrMode: ...
-
-# MODE_OPENPGP
-@overload
-def new(key: ByteString,
-        mode: Literal[7],
-        iv : Optional[ByteString] = ...,
-        use_aesni : bool = ...) -> \
-        OpenPgpMode: ...
-
-@overload
-def new(key: ByteString,
-        mode: Literal[7],
-        IV : Optional[ByteString] = ...,
-        use_aesni : bool = ...) -> \
-        OpenPgpMode: ...
-
-# MODE_CCM
-@overload
-def new(key: ByteString,
-        mode: Literal[8],
-        nonce : Optional[ByteString] = ...,
-        mac_len : int = ...,
-        assoc_len : int = ...,
-        use_aesni : bool = ...) -> \
-        CcmMode: ...
-
-# MODE_EAX
-@overload
-def new(key: ByteString,
-        mode: Literal[9],
-        nonce : Optional[ByteString] = ...,
-        mac_len : int = ...,
-        use_aesni : bool = ...) -> \
-        EaxMode: ...
-
-# MODE_GCM
-@overload
-def new(key: ByteString,
-        mode: Literal[10],
-        nonce : Optional[ByteString] = ...,
-        use_aesni : bool = ...) -> \
-        SivMode: ...
-
-# MODE_SIV
-@overload
-def new(key: ByteString,
-        mode: Literal[11],
-        nonce : Optional[ByteString] = ...,
-        mac_len : int = ...,
-        use_aesni : bool = ...) -> \
-        GcmMode: ...
-
-# MODE_OCB
-@overload
-def new(key: ByteString,
-        mode: Literal[12],
-        nonce : Optional[ByteString] = ...,
-        mac_len : int = ...,
-        use_aesni : bool = ...) -> \
-        OcbMode: ...
-
-
-block_size: int
-key_size: Tuple[int, int, int]

multilingual_toxic_comment_files/env/Lib/site-packages/Crypto/Cipher/ARC2.py

@@ -1,175 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-#  Cipher/ARC2.py : ARC2.py
-#
-# ===================================================================
-# The contents of this file are dedicated to the public domain.  To
-# the extent that dedication to the public domain is not available,
-# everyone is granted a worldwide, perpetual, royalty-free,
-# non-exclusive license to exercise all rights associated with the
-# contents of this file for any purpose whatsoever.
-# No rights are reserved.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
-# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-# ===================================================================
-"""
-Module's constants for the modes of operation supported with ARC2:
-
-:var MODE_ECB: :ref:`Electronic Code Book (ECB) <ecb_mode>`
-:var MODE_CBC: :ref:`Cipher-Block Chaining (CBC) <cbc_mode>`
-:var MODE_CFB: :ref:`Cipher FeedBack (CFB) <cfb_mode>`
-:var MODE_OFB: :ref:`Output FeedBack (OFB) <ofb_mode>`
-:var MODE_CTR: :ref:`CounTer Mode (CTR) <ctr_mode>`
-:var MODE_OPENPGP:  :ref:`OpenPGP Mode <openpgp_mode>`
-:var MODE_EAX: :ref:`EAX Mode <eax_mode>`
-"""
-
-import sys
-
-from Crypto.Cipher import _create_cipher
-from Crypto.Util.py3compat import byte_string
-from Crypto.Util._raw_api import (load_pycryptodome_raw_lib,
-                                  VoidPointer, SmartPointer,
-                                  c_size_t, c_uint8_ptr)
-
-_raw_arc2_lib = load_pycryptodome_raw_lib(
-                        "Crypto.Cipher._raw_arc2",
-                        """
-                        int ARC2_start_operation(const uint8_t key[],
-                                                 size_t key_len,
-                                                 size_t effective_key_len,
-                                                 void **pResult);
-                        int ARC2_encrypt(const void *state,
-                                         const uint8_t *in,
-                                         uint8_t *out,
-                                         size_t data_len);
-                        int ARC2_decrypt(const void *state,
-                                         const uint8_t *in,
-                                         uint8_t *out,
-                                         size_t data_len);
-                        int ARC2_stop_operation(void *state);
-                        """
-                        )
-
-
-def _create_base_cipher(dict_parameters):
-    """This method instantiates and returns a handle to a low-level
-    base cipher. It will absorb named parameters in the process."""
-
-    try:
-        key = dict_parameters.pop("key")
-    except KeyError:
-        raise TypeError("Missing 'key' parameter")
-
-    effective_keylen = dict_parameters.pop("effective_keylen", 1024)
-
-    if len(key) not in key_size:
-        raise ValueError("Incorrect ARC2 key length (%d bytes)" % len(key))
-
-    if not (40 <= effective_keylen <= 1024):
-        raise ValueError("'effective_key_len' must be at least 40 and no larger than 1024 "
-                         "(not %d)" % effective_keylen)
-
-    start_operation = _raw_arc2_lib.ARC2_start_operation
-    stop_operation = _raw_arc2_lib.ARC2_stop_operation
-
-    cipher = VoidPointer()
-    result = start_operation(c_uint8_ptr(key),
-                             c_size_t(len(key)),
-                             c_size_t(effective_keylen),
-                             cipher.address_of())
-    if result:
-        raise ValueError("Error %X while instantiating the ARC2 cipher"
-                         % result)
-
-    return SmartPointer(cipher.get(), stop_operation)
-
-
-def new(key, mode, *args, **kwargs):
-    """Create a new RC2 cipher.
-
-    :param key:
-        The secret key to use in the symmetric cipher.
-        Its length can vary from 5 to 128 bytes; the actual search space
-        (and the cipher strength) can be reduced with the ``effective_keylen`` parameter.
-    :type key: bytes, bytearray, memoryview
-
-    :param mode:
-        The chaining mode to use for encryption or decryption.
-    :type mode: One of the supported ``MODE_*`` constants
-
-    :Keyword Arguments:
-        *   **iv** (*bytes*, *bytearray*, *memoryview*) --
-            (Only applicable for ``MODE_CBC``, ``MODE_CFB``, ``MODE_OFB``,
-            and ``MODE_OPENPGP`` modes).
-
-            The initialization vector to use for encryption or decryption.
-
-            For ``MODE_CBC``, ``MODE_CFB``, and ``MODE_OFB`` it must be 8 bytes long.
-
-            For ``MODE_OPENPGP`` mode only,
-            it must be 8 bytes long for encryption
-            and 10 bytes for decryption (in the latter case, it is
-            actually the *encrypted* IV which was prefixed to the ciphertext).
-
-            If not provided, a random byte string is generated (you must then
-            read its value with the :attr:`iv` attribute).
-
-        *   **nonce** (*bytes*, *bytearray*, *memoryview*) --
-            (Only applicable for ``MODE_EAX`` and ``MODE_CTR``).
-
-            A value that must never be reused for any other encryption done
-            with this key.
-
-            For ``MODE_EAX`` there are no
-            restrictions on its length (recommended: **16** bytes).
-
-            For ``MODE_CTR``, its length must be in the range **[0..7]**.
-
-            If not provided for ``MODE_EAX``, a random byte string is generated (you
-            can read it back via the ``nonce`` attribute).
-
-        *   **effective_keylen** (*integer*) --
-            Optional. Maximum strength in bits of the actual key used by the ARC2 algorithm.
-            If the supplied ``key`` parameter is longer (in bits) of the value specified
-            here, it will be weakened to match it.
-            If not specified, no limitation is applied.
-
-        *   **segment_size** (*integer*) --
-            (Only ``MODE_CFB``).The number of **bits** the plaintext and ciphertext
-            are segmented in. It must be a multiple of 8.
-            If not specified, it will be assumed to be 8.
-
-        *   **mac_len** : (*integer*) --
-            (Only ``MODE_EAX``)
-            Length of the authentication tag, in bytes.
-            It must be no longer than 8 (default).
-
-        *   **initial_value** : (*integer*) --
-            (Only ``MODE_CTR``). The initial value for the counter within
-            the counter block. By default it is **0**.
-
-    :Return: an ARC2 object, of the applicable mode.
-    """
-
-    return _create_cipher(sys.modules[__name__], key, mode, *args, **kwargs)
-
-MODE_ECB = 1
-MODE_CBC = 2
-MODE_CFB = 3
-MODE_OFB = 5
-MODE_CTR = 6
-MODE_OPENPGP = 7
-MODE_EAX = 9
-
-# Size of a data block (in bytes)
-block_size = 8
-# Size of a key (in bytes)
-key_size = range(5, 128 + 1)

multilingual_toxic_comment_files/env/Lib/site-packages/Crypto/Cipher/ARC2.pyi

@@ -1,33 +0,0 @@
-from typing import Union, Dict, Iterable, Optional, ByteString
-
-from Crypto.Cipher._mode_ecb import EcbMode
-from Crypto.Cipher._mode_cbc import CbcMode
-from Crypto.Cipher._mode_cfb import CfbMode
-from Crypto.Cipher._mode_ofb import OfbMode
-from Crypto.Cipher._mode_ctr import CtrMode
-from Crypto.Cipher._mode_openpgp import OpenPgpMode
-from Crypto.Cipher._mode_eax import EaxMode
-
-ARC2Mode = int
-
-MODE_ECB: ARC2Mode
-MODE_CBC: ARC2Mode
-MODE_CFB: ARC2Mode
-MODE_OFB: ARC2Mode
-MODE_CTR: ARC2Mode
-MODE_OPENPGP: ARC2Mode
-MODE_EAX: ARC2Mode
-
-def new(key: ByteString,
-        mode: ARC2Mode,
-        iv : Optional[ByteString] = ...,
-        IV : Optional[ByteString] = ...,
-        nonce : Optional[ByteString] = ...,
-        segment_size : int = ...,
-        mac_len : int = ...,
-        initial_value : Union[int, ByteString] = ...,
-        counter : Dict = ...) -> \
-        Union[EcbMode, CbcMode, CfbMode, OfbMode, CtrMode, OpenPgpMode]: ...
-
-block_size: int
-key_size: Iterable[int]

multilingual_toxic_comment_files/env/Lib/site-packages/Crypto/Cipher/ARC4.py

@@ -1,136 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-#  Cipher/ARC4.py : ARC4
-#
-# ===================================================================
-# The contents of this file are dedicated to the public domain.  To
-# the extent that dedication to the public domain is not available,
-# everyone is granted a worldwide, perpetual, royalty-free,
-# non-exclusive license to exercise all rights associated with the
-# contents of this file for any purpose whatsoever.
-# No rights are reserved.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
-# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-# ===================================================================
-
-from Crypto.Util._raw_api import (load_pycryptodome_raw_lib, VoidPointer,
-                                  create_string_buffer, get_raw_buffer,
-                                  SmartPointer, c_size_t, c_uint8_ptr)
-
-
-_raw_arc4_lib = load_pycryptodome_raw_lib("Crypto.Cipher._ARC4", """
-                    int ARC4_stream_encrypt(void *rc4State, const uint8_t in[],
-                                            uint8_t out[], size_t len);
-                    int ARC4_stream_init(uint8_t *key, size_t keylen,
-                                         void **pRc4State);
-                    int ARC4_stream_destroy(void *rc4State);
-                    """)
-
-
-class ARC4Cipher:
-    """ARC4 cipher object. Do not create it directly. Use
-    :func:`Crypto.Cipher.ARC4.new` instead.
-    """
-
-    def __init__(self, key, *args, **kwargs):
-        """Initialize an ARC4 cipher object
-
-        See also `new()` at the module level."""
-
-        if len(args) > 0:
-            ndrop = args[0]
-            args = args[1:]
-        else:
-            ndrop = kwargs.pop('drop', 0)
-
-        if len(key) not in key_size:
-            raise ValueError("Incorrect ARC4 key length (%d bytes)" %
-                             len(key))
-
-        self._state = VoidPointer()
-        result = _raw_arc4_lib.ARC4_stream_init(c_uint8_ptr(key),
-                                                c_size_t(len(key)),
-                                                self._state.address_of())
-        if result != 0:
-            raise ValueError("Error %d while creating the ARC4 cipher"
-                             % result)
-        self._state = SmartPointer(self._state.get(),
-                                   _raw_arc4_lib.ARC4_stream_destroy)
-
-        if ndrop > 0:
-            # This is OK even if the cipher is used for decryption,
-            # since encrypt and decrypt are actually the same thing
-            # with ARC4.
-            self.encrypt(b'\x00' * ndrop)
-
-        self.block_size = 1
-        self.key_size = len(key)
-
-    def encrypt(self, plaintext):
-        """Encrypt a piece of data.
-
-        :param plaintext: The data to encrypt, of any size.
-        :type plaintext: bytes, bytearray, memoryview
-        :returns: the encrypted byte string, of equal length as the
-          plaintext.
-        """
-
-        ciphertext = create_string_buffer(len(plaintext))
-        result = _raw_arc4_lib.ARC4_stream_encrypt(self._state.get(),
-                                                   c_uint8_ptr(plaintext),
-                                                   ciphertext,
-                                                   c_size_t(len(plaintext)))
-        if result:
-            raise ValueError("Error %d while encrypting with RC4" % result)
-        return get_raw_buffer(ciphertext)
-
-    def decrypt(self, ciphertext):
-        """Decrypt a piece of data.
-
-        :param ciphertext: The data to decrypt, of any size.
-        :type ciphertext: bytes, bytearray, memoryview
-        :returns: the decrypted byte string, of equal length as the
-          ciphertext.
-        """
-
-        try:
-            return self.encrypt(ciphertext)
-        except ValueError as e:
-            raise ValueError(str(e).replace("enc", "dec"))
-
-
-def new(key, *args, **kwargs):
-    """Create a new ARC4 cipher.
-
-    :param key:
-        The secret key to use in the symmetric cipher.
-        Its length must be in the range ``[1..256]``.
-        The recommended length is 16 bytes.
-    :type key: bytes, bytearray, memoryview
-
-    :Keyword Arguments:
-        *   *drop* (``integer``) --
-            The amount of bytes to discard from the initial part of the keystream.
-            In fact, such part has been found to be distinguishable from random
-            data (while it shouldn't) and also correlated to key.
-
-            The recommended value is 3072_ bytes. The default value is 0.
-
-    :Return: an `ARC4Cipher` object
-
-    .. _3072: http://eprint.iacr.org/2002/067.pdf
-    """
-    return ARC4Cipher(key, *args, **kwargs)
-
-
-# Size of a data block (in bytes)
-block_size = 1
-# Size of a key (in bytes)
-key_size = range(1, 256+1)

multilingual_toxic_comment_files/env/Lib/site-packages/Crypto/Cipher/ARC4.pyi

@@ -1,14 +0,0 @@
-from typing import Any, Union, Iterable, ByteString
-
-class ARC4Cipher:
-    block_size: int
-    key_size: int
-
-    def __init__(self, key: ByteString, *args: Any, **kwargs: Any) -> None: ...
-    def encrypt(self, plaintext: ByteString) -> bytes: ...
-    def decrypt(self, ciphertext: ByteString) -> bytes: ...
-
-def new(key: ByteString, drop : int = ...) -> ARC4Cipher: ...
-
-block_size: int
-key_size: Iterable[int]

multilingual_toxic_comment_files/env/Lib/site-packages/Crypto/Cipher/Blowfish.py

@@ -1,159 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-#  Cipher/Blowfish.py : Blowfish
-#
-# ===================================================================
-# The contents of this file are dedicated to the public domain.  To
-# the extent that dedication to the public domain is not available,
-# everyone is granted a worldwide, perpetual, royalty-free,
-# non-exclusive license to exercise all rights associated with the
-# contents of this file for any purpose whatsoever.
-# No rights are reserved.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
-# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-# ===================================================================
-"""
-Module's constants for the modes of operation supported with Blowfish:
-
-:var MODE_ECB: :ref:`Electronic Code Book (ECB) <ecb_mode>`
-:var MODE_CBC: :ref:`Cipher-Block Chaining (CBC) <cbc_mode>`
-:var MODE_CFB: :ref:`Cipher FeedBack (CFB) <cfb_mode>`
-:var MODE_OFB: :ref:`Output FeedBack (OFB) <ofb_mode>`
-:var MODE_CTR: :ref:`CounTer Mode (CTR) <ctr_mode>`
-:var MODE_OPENPGP:  :ref:`OpenPGP Mode <openpgp_mode>`
-:var MODE_EAX: :ref:`EAX Mode <eax_mode>`
-"""
-
-import sys
-
-from Crypto.Cipher import _create_cipher
-from Crypto.Util._raw_api import (load_pycryptodome_raw_lib,
-                                  VoidPointer, SmartPointer, c_size_t,
-                                  c_uint8_ptr)
-
-_raw_blowfish_lib = load_pycryptodome_raw_lib(
-        "Crypto.Cipher._raw_blowfish",
-        """
-        int Blowfish_start_operation(const uint8_t key[],
-                                     size_t key_len,
-                                     void **pResult);
-        int Blowfish_encrypt(const void *state,
-                             const uint8_t *in,
-                             uint8_t *out,
-                             size_t data_len);
-        int Blowfish_decrypt(const void *state,
-                             const uint8_t *in,
-                             uint8_t *out,
-                             size_t data_len);
-        int Blowfish_stop_operation(void *state);
-        """
-        )
-
-
-def _create_base_cipher(dict_parameters):
-    """This method instantiates and returns a smart pointer to
-    a low-level base cipher. It will absorb named parameters in
-    the process."""
-
-    try:
-        key = dict_parameters.pop("key")
-    except KeyError:
-        raise TypeError("Missing 'key' parameter")
-
-    if len(key) not in key_size:
-        raise ValueError("Incorrect Blowfish key length (%d bytes)" % len(key))
-
-    start_operation = _raw_blowfish_lib.Blowfish_start_operation
-    stop_operation = _raw_blowfish_lib.Blowfish_stop_operation
-
-    void_p = VoidPointer()
-    result = start_operation(c_uint8_ptr(key),
-                             c_size_t(len(key)),
-                             void_p.address_of())
-    if result:
-        raise ValueError("Error %X while instantiating the Blowfish cipher"
-                         % result)
-    return SmartPointer(void_p.get(), stop_operation)
-
-
-def new(key, mode, *args, **kwargs):
-    """Create a new Blowfish cipher
-
-    :param key:
-        The secret key to use in the symmetric cipher.
-        Its length can vary from 5 to 56 bytes.
-    :type key: bytes, bytearray, memoryview
-
-    :param mode:
-        The chaining mode to use for encryption or decryption.
-    :type mode: One of the supported ``MODE_*`` constants
-
-    :Keyword Arguments:
-        *   **iv** (*bytes*, *bytearray*, *memoryview*) --
-            (Only applicable for ``MODE_CBC``, ``MODE_CFB``, ``MODE_OFB``,
-            and ``MODE_OPENPGP`` modes).
-
-            The initialization vector to use for encryption or decryption.
-
-            For ``MODE_CBC``, ``MODE_CFB``, and ``MODE_OFB`` it must be 8 bytes long.
-
-            For ``MODE_OPENPGP`` mode only,
-            it must be 8 bytes long for encryption
-            and 10 bytes for decryption (in the latter case, it is
-            actually the *encrypted* IV which was prefixed to the ciphertext).
-
-            If not provided, a random byte string is generated (you must then
-            read its value with the :attr:`iv` attribute).
-
-        *   **nonce** (*bytes*, *bytearray*, *memoryview*) --
-            (Only applicable for ``MODE_EAX`` and ``MODE_CTR``).
-
-            A value that must never be reused for any other encryption done
-            with this key.
-
-            For ``MODE_EAX`` there are no
-            restrictions on its length (recommended: **16** bytes).
-
-            For ``MODE_CTR``, its length must be in the range **[0..7]**.
-
-            If not provided for ``MODE_EAX``, a random byte string is generated (you
-            can read it back via the ``nonce`` attribute).
-
-        *   **segment_size** (*integer*) --
-            (Only ``MODE_CFB``).The number of **bits** the plaintext and ciphertext
-            are segmented in. It must be a multiple of 8.
-            If not specified, it will be assumed to be 8.
-
-        *   **mac_len** : (*integer*) --
-            (Only ``MODE_EAX``)
-            Length of the authentication tag, in bytes.
-            It must be no longer than 8 (default).
-
-        *   **initial_value** : (*integer*) --
-            (Only ``MODE_CTR``). The initial value for the counter within
-            the counter block. By default it is **0**.
-
-    :Return: a Blowfish object, of the applicable mode.
-    """
-
-    return _create_cipher(sys.modules[__name__], key, mode, *args, **kwargs)
-
-MODE_ECB = 1
-MODE_CBC = 2
-MODE_CFB = 3
-MODE_OFB = 5
-MODE_CTR = 6
-MODE_OPENPGP = 7
-MODE_EAX = 9
-
-# Size of a data block (in bytes)
-block_size = 8
-# Size of a key (in bytes)
-key_size = range(4, 56 + 1)

multilingual_toxic_comment_files/env/Lib/site-packages/Crypto/Cipher/Blowfish.pyi

@@ -1,33 +0,0 @@
-from typing import Union, Dict, Iterable, ByteString, Optional
-
-from Crypto.Cipher._mode_ecb import EcbMode
-from Crypto.Cipher._mode_cbc import CbcMode
-from Crypto.Cipher._mode_cfb import CfbMode
-from Crypto.Cipher._mode_ofb import OfbMode
-from Crypto.Cipher._mode_ctr import CtrMode
-from Crypto.Cipher._mode_openpgp import OpenPgpMode
-from Crypto.Cipher._mode_eax import EaxMode
-
-BlowfishMode = int
-
-MODE_ECB: BlowfishMode
-MODE_CBC: BlowfishMode
-MODE_CFB: BlowfishMode
-MODE_OFB: BlowfishMode
-MODE_CTR: BlowfishMode
-MODE_OPENPGP: BlowfishMode
-MODE_EAX: BlowfishMode
-
-def new(key: ByteString,
-        mode: BlowfishMode,
-        iv : Optional[ByteString] = ...,
-        IV : Optional[ByteString] = ...,
-        nonce : Optional[ByteString] = ...,
-        segment_size : int = ...,
-        mac_len : int = ...,
-        initial_value : Union[int, ByteString] = ...,
-        counter : Dict = ...) -> \
-        Union[EcbMode, CbcMode, CfbMode, OfbMode, CtrMode, OpenPgpMode]: ...
-
-block_size: int
-key_size: Iterable[int]

multilingual_toxic_comment_files/env/Lib/site-packages/Crypto/Cipher/CAST.py

@@ -1,159 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-#  Cipher/CAST.py : CAST
-#
-# ===================================================================
-# The contents of this file are dedicated to the public domain.  To
-# the extent that dedication to the public domain is not available,
-# everyone is granted a worldwide, perpetual, royalty-free,
-# non-exclusive license to exercise all rights associated with the
-# contents of this file for any purpose whatsoever.
-# No rights are reserved.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
-# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-# ===================================================================
-"""
-Module's constants for the modes of operation supported with CAST:
-
-:var MODE_ECB: :ref:`Electronic Code Book (ECB) <ecb_mode>`
-:var MODE_CBC: :ref:`Cipher-Block Chaining (CBC) <cbc_mode>`
-:var MODE_CFB: :ref:`Cipher FeedBack (CFB) <cfb_mode>`
-:var MODE_OFB: :ref:`Output FeedBack (OFB) <ofb_mode>`
-:var MODE_CTR: :ref:`CounTer Mode (CTR) <ctr_mode>`
-:var MODE_OPENPGP:  :ref:`OpenPGP Mode <openpgp_mode>`
-:var MODE_EAX: :ref:`EAX Mode <eax_mode>`
-"""
-
-import sys
-
-from Crypto.Cipher import _create_cipher
-from Crypto.Util.py3compat import byte_string
-from Crypto.Util._raw_api import (load_pycryptodome_raw_lib,
-                                  VoidPointer, SmartPointer,
-                                  c_size_t, c_uint8_ptr)
-
-_raw_cast_lib = load_pycryptodome_raw_lib(
-                    "Crypto.Cipher._raw_cast",
-                    """
-                    int CAST_start_operation(const uint8_t key[],
-                                             size_t key_len,
-                                             void **pResult);
-                    int CAST_encrypt(const void *state,
-                                     const uint8_t *in,
-                                     uint8_t *out,
-                                     size_t data_len);
-                    int CAST_decrypt(const void *state,
-                                     const uint8_t *in,
-                                     uint8_t *out,
-                                     size_t data_len);
-                    int CAST_stop_operation(void *state);
-                    """)
-
-
-def _create_base_cipher(dict_parameters):
-    """This method instantiates and returns a handle to a low-level
-    base cipher. It will absorb named parameters in the process."""
-
-    try:
-        key = dict_parameters.pop("key")
-    except KeyError:
-        raise TypeError("Missing 'key' parameter")
-
-    if len(key) not in key_size:
-        raise ValueError("Incorrect CAST key length (%d bytes)" % len(key))
-
-    start_operation = _raw_cast_lib.CAST_start_operation
-    stop_operation = _raw_cast_lib.CAST_stop_operation
-
-    cipher = VoidPointer()
-    result = start_operation(c_uint8_ptr(key),
-                             c_size_t(len(key)),
-                             cipher.address_of())
-    if result:
-        raise ValueError("Error %X while instantiating the CAST cipher"
-                         % result)
-
-    return SmartPointer(cipher.get(), stop_operation)
-
-
-def new(key, mode, *args, **kwargs):
-    """Create a new CAST cipher
-
-    :param key:
-        The secret key to use in the symmetric cipher.
-        Its length can vary from 5 to 16 bytes.
-    :type key: bytes, bytearray, memoryview
-
-    :param mode:
-        The chaining mode to use for encryption or decryption.
-    :type mode: One of the supported ``MODE_*`` constants
-
-    :Keyword Arguments:
-        *   **iv** (*bytes*, *bytearray*, *memoryview*) --
-            (Only applicable for ``MODE_CBC``, ``MODE_CFB``, ``MODE_OFB``,
-            and ``MODE_OPENPGP`` modes).
-
-            The initialization vector to use for encryption or decryption.
-
-            For ``MODE_CBC``, ``MODE_CFB``, and ``MODE_OFB`` it must be 8 bytes long.
-
-            For ``MODE_OPENPGP`` mode only,
-            it must be 8 bytes long for encryption
-            and 10 bytes for decryption (in the latter case, it is
-            actually the *encrypted* IV which was prefixed to the ciphertext).
-
-            If not provided, a random byte string is generated (you must then
-            read its value with the :attr:`iv` attribute).
-
-        *   **nonce** (*bytes*, *bytearray*, *memoryview*) --
-            (Only applicable for ``MODE_EAX`` and ``MODE_CTR``).
-
-            A value that must never be reused for any other encryption done
-            with this key.
-
-            For ``MODE_EAX`` there are no
-            restrictions on its length (recommended: **16** bytes).
-
-            For ``MODE_CTR``, its length must be in the range **[0..7]**.
-
-            If not provided for ``MODE_EAX``, a random byte string is generated (you
-            can read it back via the ``nonce`` attribute).
-
-        *   **segment_size** (*integer*) --
-            (Only ``MODE_CFB``).The number of **bits** the plaintext and ciphertext
-            are segmented in. It must be a multiple of 8.
-            If not specified, it will be assumed to be 8.
-
-        *   **mac_len** : (*integer*) --
-            (Only ``MODE_EAX``)
-            Length of the authentication tag, in bytes.
-            It must be no longer than 8 (default).
-
-        *   **initial_value** : (*integer*) --
-            (Only ``MODE_CTR``). The initial value for the counter within
-            the counter block. By default it is **0**.
-
-    :Return: a CAST object, of the applicable mode.
-    """
-
-    return _create_cipher(sys.modules[__name__], key, mode, *args, **kwargs)
-
-MODE_ECB = 1
-MODE_CBC = 2
-MODE_CFB = 3
-MODE_OFB = 5
-MODE_CTR = 6
-MODE_OPENPGP = 7
-MODE_EAX = 9
-
-# Size of a data block (in bytes)
-block_size = 8
-# Size of a key (in bytes)
-key_size = range(5, 16 + 1)

multilingual_toxic_comment_files/env/Lib/site-packages/Crypto/Cipher/CAST.pyi

@@ -1,33 +0,0 @@
-from typing import Union, Dict, Iterable, Optional, ByteString
-
-from Crypto.Cipher._mode_ecb import EcbMode
-from Crypto.Cipher._mode_cbc import CbcMode
-from Crypto.Cipher._mode_cfb import CfbMode
-from Crypto.Cipher._mode_ofb import OfbMode
-from Crypto.Cipher._mode_ctr import CtrMode
-from Crypto.Cipher._mode_openpgp import OpenPgpMode
-from Crypto.Cipher._mode_eax import EaxMode
-
-CASTMode = int
-
-MODE_ECB: CASTMode
-MODE_CBC: CASTMode
-MODE_CFB: CASTMode
-MODE_OFB: CASTMode
-MODE_CTR: CASTMode
-MODE_OPENPGP: CASTMode
-MODE_EAX: CASTMode
-
-def new(key: ByteString,
-        mode: CASTMode,
-        iv : Optional[ByteString] = ...,
-        IV : Optional[ByteString] = ...,
-        nonce : Optional[ByteString] = ...,
-        segment_size : int = ...,
-        mac_len : int = ...,
-        initial_value : Union[int, ByteString] = ...,
-        counter : Dict = ...) -> \
-        Union[EcbMode, CbcMode, CfbMode, OfbMode, CtrMode, OpenPgpMode]: ...
-
-block_size: int
-key_size : Iterable[int]

multilingual_toxic_comment_files/env/Lib/site-packages/Crypto/Cipher/ChaCha20.py

@@ -1,287 +0,0 @@
-# ===================================================================
-#
-# Copyright (c) 2014, Legrandin <helderijs@gmail.com>
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions
-# are met:
-#
-# 1. Redistributions of source code must retain the above copyright
-#    notice, this list of conditions and the following disclaimer.
-# 2. Redistributions in binary form must reproduce the above copyright
-#    notice, this list of conditions and the following disclaimer in
-#    the documentation and/or other materials provided with the
-#    distribution.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
-# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-# POSSIBILITY OF SUCH DAMAGE.
-# ===================================================================
-
-from Crypto.Random import get_random_bytes
-
-from Crypto.Util.py3compat import _copy_bytes
-from Crypto.Util._raw_api import (load_pycryptodome_raw_lib,
-                                  create_string_buffer,
-                                  get_raw_buffer, VoidPointer,
-                                  SmartPointer, c_size_t,
-                                  c_uint8_ptr, c_ulong,
-                                  is_writeable_buffer)
-
-_raw_chacha20_lib = load_pycryptodome_raw_lib("Crypto.Cipher._chacha20",
-                    """
-                    int chacha20_init(void **pState,
-                                      const uint8_t *key,
-                                      size_t keySize,
-                                      const uint8_t *nonce,
-                                      size_t nonceSize);
-
-                    int chacha20_destroy(void *state);
-
-                    int chacha20_encrypt(void *state,
-                                         const uint8_t in[],
-                                         uint8_t out[],
-                                         size_t len);
-
-                    int chacha20_seek(void *state,
-                                      unsigned long block_high,
-                                      unsigned long block_low,
-                                      unsigned offset);
-                    int hchacha20(  const uint8_t key[32],
-                                    const uint8_t nonce16[16],
-                                    uint8_t subkey[32]);
-                    """)
-
-
-def _HChaCha20(key, nonce):
-
-    assert(len(key) == 32)
-    assert(len(nonce) == 16)
-
-    subkey = bytearray(32)
-    result = _raw_chacha20_lib.hchacha20(
-                c_uint8_ptr(key),
-                c_uint8_ptr(nonce),
-                c_uint8_ptr(subkey))
-    if result:
-        raise ValueError("Error %d when deriving subkey with HChaCha20" % result)
-
-    return subkey
-
-
-class ChaCha20Cipher(object):
-    """ChaCha20 (or XChaCha20) cipher object.
-    Do not create it directly. Use :py:func:`new` instead.
-
-    :var nonce: The nonce with length 8, 12 or 24 bytes
-    :vartype nonce: bytes
-    """
-
-    block_size = 1
-
-    def __init__(self, key, nonce):
-        """Initialize a ChaCha20/XChaCha20 cipher object
-
-        See also `new()` at the module level."""
-
-        self.nonce = _copy_bytes(None, None, nonce)
-
-        # XChaCha20 requires a key derivation with HChaCha20
-        # See 2.3 in https://tools.ietf.org/html/draft-arciszewski-xchacha-03
-        if len(nonce) == 24:
-            key = _HChaCha20(key, nonce[:16])
-            nonce = b'\x00' * 4 + nonce[16:]
-            self._name = "XChaCha20"
-        else:
-            self._name = "ChaCha20"
-            nonce = self.nonce
-
-        self._next = ("encrypt", "decrypt")
-
-        self._state = VoidPointer()
-        result = _raw_chacha20_lib.chacha20_init(
-                        self._state.address_of(),
-                        c_uint8_ptr(key),
-                        c_size_t(len(key)),
-                        nonce,
-                        c_size_t(len(nonce)))
-        if result:
-            raise ValueError("Error %d instantiating a %s cipher" % (result,
-                                                                     self._name))
-        self._state = SmartPointer(self._state.get(),
-                                   _raw_chacha20_lib.chacha20_destroy)
-
-    def encrypt(self, plaintext, output=None):
-        """Encrypt a piece of data.
-
-        Args:
-          plaintext(bytes/bytearray/memoryview): The data to encrypt, of any size.
-        Keyword Args:
-          output(bytes/bytearray/memoryview): The location where the ciphertext
-            is written to. If ``None``, the ciphertext is returned.
-        Returns:
-          If ``output`` is ``None``, the ciphertext is returned as ``bytes``.
-          Otherwise, ``None``.
-        """
-
-        if "encrypt" not in self._next:
-            raise TypeError("Cipher object can only be used for decryption")
-        self._next = ("encrypt",)
-        return self._encrypt(plaintext, output)
-
-    def _encrypt(self, plaintext, output):
-        """Encrypt without FSM checks"""
-
-        if output is None:
-            ciphertext = create_string_buffer(len(plaintext))
-        else:
-            ciphertext = output
-
-            if not is_writeable_buffer(output):
-                raise TypeError("output must be a bytearray or a writeable memoryview")
-
-            if len(plaintext) != len(output):
-                raise ValueError("output must have the same length as the input"
-                                 "  (%d bytes)" % len(plaintext))
-
-        result = _raw_chacha20_lib.chacha20_encrypt(
-                                         self._state.get(),
-                                         c_uint8_ptr(plaintext),
-                                         c_uint8_ptr(ciphertext),
-                                         c_size_t(len(plaintext)))
-        if result:
-            raise ValueError("Error %d while encrypting with %s" % (result, self._name))
-
-        if output is None:
-            return get_raw_buffer(ciphertext)
-        else:
-            return None
-
-    def decrypt(self, ciphertext, output=None):
-        """Decrypt a piece of data.
-
-        Args:
-          ciphertext(bytes/bytearray/memoryview): The data to decrypt, of any size.
-        Keyword Args:
-          output(bytes/bytearray/memoryview): The location where the plaintext
-            is written to. If ``None``, the plaintext is returned.
-        Returns:
-          If ``output`` is ``None``, the plaintext is returned as ``bytes``.
-          Otherwise, ``None``.
-        """
-
-        if "decrypt" not in self._next:
-            raise TypeError("Cipher object can only be used for encryption")
-        self._next = ("decrypt",)
-
-        try:
-            return self._encrypt(ciphertext, output)
-        except ValueError as e:
-            raise ValueError(str(e).replace("enc", "dec"))
-
-    def seek(self, position):
-        """Seek to a certain position in the key stream.
-
-        Args:
-          position (integer):
-            The absolute position within the key stream, in bytes.
-        """
-
-        position, offset = divmod(position, 64)
-        block_low = position & 0xFFFFFFFF
-        block_high = position >> 32
-
-        result = _raw_chacha20_lib.chacha20_seek(
-                                                 self._state.get(),
-                                                 c_ulong(block_high),
-                                                 c_ulong(block_low),
-                                                 offset
-                                                 )
-        if result:
-            raise ValueError("Error %d while seeking with %s" % (result, self._name))
-
-
-def _derive_Poly1305_key_pair(key, nonce):
-    """Derive a tuple (r, s, nonce) for a Poly1305 MAC.
-
-    If nonce is ``None``, a new 12-byte nonce is generated.
-    """
-
-    if len(key) != 32:
-        raise ValueError("Poly1305 with ChaCha20 requires a 32-byte key")
-
-    if nonce is None:
-        padded_nonce = nonce = get_random_bytes(12)
-    elif len(nonce) == 8:
-        # See RFC7538, 2.6: [...] ChaCha20 as specified here requires a 96-bit
-        # nonce.  So if the provided nonce is only 64-bit, then the first 32
-        # bits of the nonce will be set to a constant number.
-        # This will usually be zero, but for protocols with multiple senders it may be
-        # different for each sender, but should be the same for all
-        # invocations of the function with the same key by a particular
-        # sender.
-        padded_nonce = b'\x00\x00\x00\x00' + nonce
-    elif len(nonce) == 12:
-        padded_nonce = nonce
-    else:
-        raise ValueError("Poly1305 with ChaCha20 requires an 8- or 12-byte nonce")
-
-    rs = new(key=key, nonce=padded_nonce).encrypt(b'\x00' * 32)
-    return rs[:16], rs[16:], nonce
-
-
-def new(**kwargs):
-    """Create a new ChaCha20 or XChaCha20 cipher
-
-    Keyword Args:
-        key (bytes/bytearray/memoryview): The secret key to use.
-            It must be 32 bytes long.
-        nonce (bytes/bytearray/memoryview): A mandatory value that
-            must never be reused for any other encryption
-            done with this key.
-
-            For ChaCha20, it must be 8 or 12 bytes long.
-
-            For XChaCha20, it must be 24 bytes long.
-
-            If not provided, 8 bytes will be randomly generated
-            (you can find them back in the ``nonce`` attribute).
-
-    :Return: a :class:`Crypto.Cipher.ChaCha20.ChaCha20Cipher` object
-    """
-
-    try:
-        key = kwargs.pop("key")
-    except KeyError as e:
-        raise TypeError("Missing parameter %s" % e)
-
-    nonce = kwargs.pop("nonce", None)
-    if nonce is None:
-        nonce = get_random_bytes(8)
-
-    if len(key) != 32:
-        raise ValueError("ChaCha20/XChaCha20 key must be 32 bytes long")
-
-    if len(nonce) not in (8, 12, 24):
-        raise ValueError("Nonce must be 8/12 bytes(ChaCha20) or 24 bytes (XChaCha20)")
-
-    if kwargs:
-        raise TypeError("Unknown parameters: " + str(kwargs))
-
-    return ChaCha20Cipher(key, nonce)
-
-# Size of a data block (in bytes)
-block_size = 1
-
-# Size of a key (in bytes)
-key_size = 32

multilingual_toxic_comment_files/env/Lib/site-packages/Crypto/Cipher/ChaCha20.pyi

@@ -1,23 +0,0 @@
-from typing import Union, overload, ByteString, Optional
-
-def _HChaCha20(key: ByteString, nonce: ByteString) -> bytearray: ...
-
-class ChaCha20Cipher:
-    block_size: int
-    nonce: bytes
-
-    def __init__(self, key: ByteString, nonce: ByteString) -> None: ...
-    @overload
-    def encrypt(self, plaintext: ByteString) -> bytes: ...
-    @overload
-    def encrypt(self, plaintext: ByteString, output: Union[bytearray, memoryview]) -> None: ...
-    @overload
-    def decrypt(self, plaintext: ByteString) -> bytes: ...
-    @overload
-    def decrypt(self, plaintext: ByteString, output: Union[bytearray, memoryview]) -> None: ...
-    def seek(self, position: int) -> None: ...
-
-def new(key: ByteString, nonce: Optional[ByteString] = ...) -> ChaCha20Cipher: ...
-
-block_size: int
-key_size: int

multilingual_toxic_comment_files/env/Lib/site-packages/Crypto/Cipher/ChaCha20_Poly1305.py

@@ -1,336 +0,0 @@
-# ===================================================================
-#
-# Copyright (c) 2018, Helder Eijs <helderijs@gmail.com>
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions
-# are met:
-#
-# 1. Redistributions of source code must retain the above copyright
-#    notice, this list of conditions and the following disclaimer.
-# 2. Redistributions in binary form must reproduce the above copyright
-#    notice, this list of conditions and the following disclaimer in
-#    the documentation and/or other materials provided with the
-#    distribution.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
-# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-# POSSIBILITY OF SUCH DAMAGE.
-# ===================================================================
-
-from binascii import unhexlify
-
-from Crypto.Cipher import ChaCha20
-from Crypto.Cipher.ChaCha20 import _HChaCha20
-from Crypto.Hash import Poly1305, BLAKE2s
-
-from Crypto.Random import get_random_bytes
-
-from Crypto.Util.number import long_to_bytes
-from Crypto.Util.py3compat import _copy_bytes, bord
-from Crypto.Util._raw_api import is_buffer
-
-
-def _enum(**enums):
-    return type('Enum', (), enums)
-
-
-_CipherStatus = _enum(PROCESSING_AUTH_DATA=1,
-                      PROCESSING_CIPHERTEXT=2,
-                      PROCESSING_DONE=3)
-
-
-class ChaCha20Poly1305Cipher(object):
-    """ChaCha20-Poly1305 and XChaCha20-Poly1305 cipher object.
-    Do not create it directly. Use :py:func:`new` instead.
-
-    :var nonce: The nonce with length 8, 12 or 24 bytes
-    :vartype nonce: byte string
-    """
-
-    def __init__(self, key, nonce):
-        """Initialize a ChaCha20-Poly1305 AEAD cipher object
-
-        See also `new()` at the module level."""
-
-        self.nonce = _copy_bytes(None, None, nonce)
-
-        self._next = ("update", "encrypt", "decrypt", "digest",
-                      "verify")
-
-        self._authenticator = Poly1305.new(key=key, nonce=nonce, cipher=ChaCha20)
-
-        self._cipher = ChaCha20.new(key=key, nonce=nonce)
-        self._cipher.seek(64)   # Block counter starts at 1
-
-        self._len_aad = 0
-        self._len_ct = 0
-        self._mac_tag = None
-        self._status = _CipherStatus.PROCESSING_AUTH_DATA
-
-    def update(self, data):
-        """Protect the associated data.
-
-        Associated data (also known as *additional authenticated data* - AAD)
-        is the piece of the message that must stay in the clear, while
-        still allowing the receiver to verify its integrity.
-        An example is packet headers.
-
-        The associated data (possibly split into multiple segments) is
-        fed into :meth:`update` before any call to :meth:`decrypt` or :meth:`encrypt`.
-        If there is no associated data, :meth:`update` is not called.
-
-        :param bytes/bytearray/memoryview assoc_data:
-            A piece of associated data. There are no restrictions on its size.
-        """
-
-        if "update" not in self._next:
-            raise TypeError("update() method cannot be called")
-
-        self._len_aad += len(data)
-        self._authenticator.update(data)
-
-    def _pad_aad(self):
-
-        assert(self._status == _CipherStatus.PROCESSING_AUTH_DATA)
-        if self._len_aad & 0x0F:
-            self._authenticator.update(b'\x00' * (16 - (self._len_aad & 0x0F)))
-        self._status = _CipherStatus.PROCESSING_CIPHERTEXT
-
-    def encrypt(self, plaintext, output=None):
-        """Encrypt a piece of data.
-
-        Args:
-          plaintext(bytes/bytearray/memoryview): The data to encrypt, of any size.
-        Keyword Args:
-          output(bytes/bytearray/memoryview): The location where the ciphertext
-            is written to. If ``None``, the ciphertext is returned.
-        Returns:
-          If ``output`` is ``None``, the ciphertext is returned as ``bytes``.
-          Otherwise, ``None``.
-        """
-
-        if "encrypt" not in self._next:
-            raise TypeError("encrypt() method cannot be called")
-
-        if self._status == _CipherStatus.PROCESSING_AUTH_DATA:
-            self._pad_aad()
-
-        self._next = ("encrypt", "digest")
-
-        result = self._cipher.encrypt(plaintext, output=output)
-        self._len_ct += len(plaintext)
-        if output is None:
-            self._authenticator.update(result)
-        else:
-            self._authenticator.update(output)
-        return result
-
-    def decrypt(self, ciphertext, output=None):
-        """Decrypt a piece of data.
-
-        Args:
-          ciphertext(bytes/bytearray/memoryview): The data to decrypt, of any size.
-        Keyword Args:
-          output(bytes/bytearray/memoryview): The location where the plaintext
-            is written to. If ``None``, the plaintext is returned.
-        Returns:
-          If ``output`` is ``None``, the plaintext is returned as ``bytes``.
-          Otherwise, ``None``.
-        """
-
-        if "decrypt" not in self._next:
-            raise TypeError("decrypt() method cannot be called")
-
-        if self._status == _CipherStatus.PROCESSING_AUTH_DATA:
-            self._pad_aad()
-
-        self._next = ("decrypt", "verify")
-
-        self._len_ct += len(ciphertext)
-        self._authenticator.update(ciphertext)
-        return self._cipher.decrypt(ciphertext, output=output)
-
-    def _compute_mac(self):
-        """Finalize the cipher (if not done already) and return the MAC."""
-
-        if self._mac_tag:
-            assert(self._status == _CipherStatus.PROCESSING_DONE)
-            return self._mac_tag
-
-        assert(self._status != _CipherStatus.PROCESSING_DONE)
-
-        if self._status == _CipherStatus.PROCESSING_AUTH_DATA:
-            self._pad_aad()
-
-        if self._len_ct & 0x0F:
-            self._authenticator.update(b'\x00' * (16 - (self._len_ct & 0x0F)))
-
-        self._status = _CipherStatus.PROCESSING_DONE
-
-        self._authenticator.update(long_to_bytes(self._len_aad, 8)[::-1])
-        self._authenticator.update(long_to_bytes(self._len_ct, 8)[::-1])
-        self._mac_tag = self._authenticator.digest()
-        return self._mac_tag
-
-    def digest(self):
-        """Compute the *binary* authentication tag (MAC).
-
-        :Return: the MAC tag, as 16 ``bytes``.
-        """
-
-        if "digest" not in self._next:
-            raise TypeError("digest() method cannot be called")
-        self._next = ("digest",)
-
-        return self._compute_mac()
-
-    def hexdigest(self):
-        """Compute the *printable* authentication tag (MAC).
-
-        This method is like :meth:`digest`.
-
-        :Return: the MAC tag, as a hexadecimal string.
-        """
-        return "".join(["%02x" % bord(x) for x in self.digest()])
-
-    def verify(self, received_mac_tag):
-        """Validate the *binary* authentication tag (MAC).
-
-        The receiver invokes this method at the very end, to
-        check if the associated data (if any) and the decrypted
-        messages are valid.
-
-        :param bytes/bytearray/memoryview received_mac_tag:
-            This is the 16-byte *binary* MAC, as received from the sender.
-        :Raises ValueError:
-            if the MAC does not match. The message has been tampered with
-            or the key is incorrect.
-        """
-
-        if "verify" not in self._next:
-            raise TypeError("verify() cannot be called"
-                            " when encrypting a message")
-        self._next = ("verify",)
-
-        secret = get_random_bytes(16)
-
-        self._compute_mac()
-
-        mac1 = BLAKE2s.new(digest_bits=160, key=secret,
-                           data=self._mac_tag)
-        mac2 = BLAKE2s.new(digest_bits=160, key=secret,
-                           data=received_mac_tag)
-
-        if mac1.digest() != mac2.digest():
-            raise ValueError("MAC check failed")
-
-    def hexverify(self, hex_mac_tag):
-        """Validate the *printable* authentication tag (MAC).
-
-        This method is like :meth:`verify`.
-
-        :param string hex_mac_tag:
-            This is the *printable* MAC.
-        :Raises ValueError:
-            if the MAC does not match. The message has been tampered with
-            or the key is incorrect.
-        """
-
-        self.verify(unhexlify(hex_mac_tag))
-
-    def encrypt_and_digest(self, plaintext):
-        """Perform :meth:`encrypt` and :meth:`digest` in one step.
-
-        :param plaintext: The data to encrypt, of any size.
-        :type plaintext: bytes/bytearray/memoryview
-        :return: a tuple with two ``bytes`` objects:
-
-            - the ciphertext, of equal length as the plaintext
-            - the 16-byte MAC tag
-        """
-
-        return self.encrypt(plaintext), self.digest()
-
-    def decrypt_and_verify(self, ciphertext, received_mac_tag):
-        """Perform :meth:`decrypt` and :meth:`verify` in one step.
-
-        :param ciphertext: The piece of data to decrypt.
-        :type ciphertext: bytes/bytearray/memoryview
-        :param bytes received_mac_tag:
-            This is the 16-byte *binary* MAC, as received from the sender.
-        :return: the decrypted data (as ``bytes``)
-        :raises ValueError:
-            if the MAC does not match. The message has been tampered with
-            or the key is incorrect.
-        """
-
-        plaintext = self.decrypt(ciphertext)
-        self.verify(received_mac_tag)
-        return plaintext
-
-
-def new(**kwargs):
-    """Create a new ChaCha20-Poly1305 or XChaCha20-Poly1305 AEAD cipher.
-
-    :keyword key: The secret key to use. It must be 32 bytes long.
-    :type key: byte string
-
-    :keyword nonce:
-        A value that must never be reused for any other encryption
-        done with this key.
-
-        For ChaCha20-Poly1305, it must be 8 or 12 bytes long.
-
-        For XChaCha20-Poly1305, it must be 24 bytes long.
-
-        If not provided, 12 ``bytes`` will be generated randomly
-        (you can find them back in the ``nonce`` attribute).
-    :type nonce: bytes, bytearray, memoryview
-
-    :Return: a :class:`Crypto.Cipher.ChaCha20.ChaCha20Poly1305Cipher` object
-    """
-
-    try:
-        key = kwargs.pop("key")
-    except KeyError as e:
-        raise TypeError("Missing parameter %s" % e)
-
-        self._len_ct += len(plaintext)
-
-    if len(key) != 32:
-        raise ValueError("Key must be 32 bytes long")
-
-    nonce = kwargs.pop("nonce", None)
-    if nonce is None:
-        nonce = get_random_bytes(12)
-
-    if len(nonce) in (8, 12):
-        pass
-    elif len(nonce) == 24:
-        key = _HChaCha20(key, nonce[:16])
-        nonce = b'\x00\x00\x00\x00' + nonce[16:]
-    else:
-        raise ValueError("Nonce must be 8, 12 or 24 bytes long")
-
-    if not is_buffer(nonce):
-        raise TypeError("nonce must be bytes, bytearray or memoryview")
-
-    if kwargs:
-        raise TypeError("Unknown parameters: " + str(kwargs))
-
-    return ChaCha20Poly1305Cipher(key, nonce)
-
-
-# Size of a key (in bytes)
-key_size = 32

multilingual_toxic_comment_files/env/Lib/site-packages/Crypto/Cipher/ChaCha20_Poly1305.pyi

@@ -1,26 +0,0 @@
-from typing import Union, Tuple, overload, ByteString, Optional
-
-class ChaCha20Poly1305Cipher:
-    nonce: bytes
-
-    def __init__(self, key: ByteString, nonce: ByteString) -> None: ...
-    def update(self, data: ByteString) -> None: ...
-    @overload
-    def encrypt(self, plaintext: ByteString) -> bytes: ...
-    @overload
-    def encrypt(self, plaintext: ByteString, output: Union[bytearray, memoryview]) -> None: ...
-    @overload
-    def decrypt(self, plaintext: ByteString) -> bytes: ...
-    @overload
-    def decrypt(self, plaintext: ByteString, output: Union[bytearray, memoryview]) -> None: ...
-    def digest(self) -> bytes: ...
-    def hexdigest(self) -> str: ...
-    def verify(self, received_mac_tag: ByteString) -> None: ...
-    def hexverify(self, received_mac_tag: str) -> None: ...
-    def encrypt_and_digest(self, plaintext: ByteString) -> Tuple[bytes, bytes]: ...
-    def decrypt_and_verify(self, ciphertext: ByteString, received_mac_tag: ByteString) -> bytes: ...
-
-def new(key: ByteString, nonce: Optional[ByteString] = ...) -> ChaCha20Poly1305Cipher: ...
-
-block_size: int
-key_size: int

multilingual_toxic_comment_files/env/Lib/site-packages/Crypto/Cipher/DES.py

@@ -1,158 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-#  Cipher/DES.py : DES
-#
-# ===================================================================
-# The contents of this file are dedicated to the public domain.  To
-# the extent that dedication to the public domain is not available,
-# everyone is granted a worldwide, perpetual, royalty-free,
-# non-exclusive license to exercise all rights associated with the
-# contents of this file for any purpose whatsoever.
-# No rights are reserved.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
-# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-# ===================================================================
-"""
-Module's constants for the modes of operation supported with Single DES:
-
-:var MODE_ECB: :ref:`Electronic Code Book (ECB) <ecb_mode>`
-:var MODE_CBC: :ref:`Cipher-Block Chaining (CBC) <cbc_mode>`
-:var MODE_CFB: :ref:`Cipher FeedBack (CFB) <cfb_mode>`
-:var MODE_OFB: :ref:`Output FeedBack (OFB) <ofb_mode>`
-:var MODE_CTR: :ref:`CounTer Mode (CTR) <ctr_mode>`
-:var MODE_OPENPGP:  :ref:`OpenPGP Mode <openpgp_mode>`
-:var MODE_EAX: :ref:`EAX Mode <eax_mode>`
-"""
-
-import sys
-
-from Crypto.Cipher import _create_cipher
-from Crypto.Util.py3compat import byte_string
-from Crypto.Util._raw_api import (load_pycryptodome_raw_lib,
-                                  VoidPointer, SmartPointer,
-                                  c_size_t, c_uint8_ptr)
-
-_raw_des_lib = load_pycryptodome_raw_lib(
-                "Crypto.Cipher._raw_des",
-                """
-                int DES_start_operation(const uint8_t key[],
-                                        size_t key_len,
-                                        void **pResult);
-                int DES_encrypt(const void *state,
-                                const uint8_t *in,
-                                uint8_t *out,
-                                size_t data_len);
-                int DES_decrypt(const void *state,
-                                const uint8_t *in,
-                                uint8_t *out,
-                                size_t data_len);
-                int DES_stop_operation(void *state);
-                """)
-
-
-def _create_base_cipher(dict_parameters):
-    """This method instantiates and returns a handle to a low-level
-    base cipher. It will absorb named parameters in the process."""
-
-    try:
-        key = dict_parameters.pop("key")
-    except KeyError:
-        raise TypeError("Missing 'key' parameter")
-
-    if len(key) != key_size:
-        raise ValueError("Incorrect DES key length (%d bytes)" % len(key))
-
-    start_operation = _raw_des_lib.DES_start_operation
-    stop_operation = _raw_des_lib.DES_stop_operation
-
-    cipher = VoidPointer()
-    result = start_operation(c_uint8_ptr(key),
-                             c_size_t(len(key)),
-                             cipher.address_of())
-    if result:
-        raise ValueError("Error %X while instantiating the DES cipher"
-                         % result)
-    return SmartPointer(cipher.get(), stop_operation)
-
-
-def new(key, mode, *args, **kwargs):
-    """Create a new DES cipher.
-
-    :param key:
-        The secret key to use in the symmetric cipher.
-        It must be 8 byte long. The parity bits will be ignored.
-    :type key: bytes/bytearray/memoryview
-
-    :param mode:
-        The chaining mode to use for encryption or decryption.
-    :type mode: One of the supported ``MODE_*`` constants
-
-    :Keyword Arguments:
-        *   **iv** (*byte string*) --
-            (Only applicable for ``MODE_CBC``, ``MODE_CFB``, ``MODE_OFB``,
-            and ``MODE_OPENPGP`` modes).
-
-            The initialization vector to use for encryption or decryption.
-
-            For ``MODE_CBC``, ``MODE_CFB``, and ``MODE_OFB`` it must be 8 bytes long.
-
-            For ``MODE_OPENPGP`` mode only,
-            it must be 8 bytes long for encryption
-            and 10 bytes for decryption (in the latter case, it is
-            actually the *encrypted* IV which was prefixed to the ciphertext).
-
-            If not provided, a random byte string is generated (you must then
-            read its value with the :attr:`iv` attribute).
-
-        *   **nonce** (*byte string*) --
-            (Only applicable for ``MODE_EAX`` and ``MODE_CTR``).
-
-            A value that must never be reused for any other encryption done
-            with this key.
-
-            For ``MODE_EAX`` there are no
-            restrictions on its length (recommended: **16** bytes).
-
-            For ``MODE_CTR``, its length must be in the range **[0..7]**.
-
-            If not provided for ``MODE_EAX``, a random byte string is generated (you
-            can read it back via the ``nonce`` attribute).
-
-        *   **segment_size** (*integer*) --
-            (Only ``MODE_CFB``).The number of **bits** the plaintext and ciphertext
-            are segmented in. It must be a multiple of 8.
-            If not specified, it will be assumed to be 8.
-
-        *   **mac_len** : (*integer*) --
-            (Only ``MODE_EAX``)
-            Length of the authentication tag, in bytes.
-            It must be no longer than 8 (default).
-
-        *   **initial_value** : (*integer*) --
-            (Only ``MODE_CTR``). The initial value for the counter within
-            the counter block. By default it is **0**.
-
-    :Return: a DES object, of the applicable mode.
-    """
-
-    return _create_cipher(sys.modules[__name__], key, mode, *args, **kwargs)
-
-MODE_ECB = 1
-MODE_CBC = 2
-MODE_CFB = 3
-MODE_OFB = 5
-MODE_CTR = 6
-MODE_OPENPGP = 7
-MODE_EAX = 9
-
-# Size of a data block (in bytes)
-block_size = 8
-# Size of a key (in bytes)
-key_size = 8

multilingual_toxic_comment_files/env/Lib/site-packages/Crypto/Cipher/DES.pyi

@@ -1,33 +0,0 @@
-from typing import Union, Dict, Iterable, ByteString, Optional
-
-from Crypto.Cipher._mode_ecb import EcbMode
-from Crypto.Cipher._mode_cbc import CbcMode
-from Crypto.Cipher._mode_cfb import CfbMode
-from Crypto.Cipher._mode_ofb import OfbMode
-from Crypto.Cipher._mode_ctr import CtrMode
-from Crypto.Cipher._mode_openpgp import OpenPgpMode
-from Crypto.Cipher._mode_eax import EaxMode
-
-DESMode = int
-
-MODE_ECB: DESMode
-MODE_CBC: DESMode
-MODE_CFB: DESMode
-MODE_OFB: DESMode
-MODE_CTR: DESMode
-MODE_OPENPGP: DESMode
-MODE_EAX: DESMode
-
-def new(key: ByteString,
-        mode: DESMode,
-        iv : Optional[ByteString] = ...,
-        IV : Optional[ByteString] = ...,
-        nonce : Optional[ByteString] = ...,
-        segment_size : int = ...,
-        mac_len : int = ...,
-        initial_value : Union[int, ByteString] = ...,
-        counter : Dict = ...) -> \
-        Union[EcbMode, CbcMode, CfbMode, OfbMode, CtrMode, OpenPgpMode]: ...
-
-block_size: int
-key_size: int

multilingual_toxic_comment_files/env/Lib/site-packages/Crypto/Cipher/DES3.py

@@ -1,187 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-#  Cipher/DES3.py : DES3
-#
-# ===================================================================
-# The contents of this file are dedicated to the public domain.  To
-# the extent that dedication to the public domain is not available,
-# everyone is granted a worldwide, perpetual, royalty-free,
-# non-exclusive license to exercise all rights associated with the
-# contents of this file for any purpose whatsoever.
-# No rights are reserved.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
-# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-# ===================================================================
-"""
-Module's constants for the modes of operation supported with Triple DES:
-
-:var MODE_ECB: :ref:`Electronic Code Book (ECB) <ecb_mode>`
-:var MODE_CBC: :ref:`Cipher-Block Chaining (CBC) <cbc_mode>`
-:var MODE_CFB: :ref:`Cipher FeedBack (CFB) <cfb_mode>`
-:var MODE_OFB: :ref:`Output FeedBack (OFB) <ofb_mode>`
-:var MODE_CTR: :ref:`CounTer Mode (CTR) <ctr_mode>`
-:var MODE_OPENPGP:  :ref:`OpenPGP Mode <openpgp_mode>`
-:var MODE_EAX: :ref:`EAX Mode <eax_mode>`
-"""
-
-import sys
-
-from Crypto.Cipher import _create_cipher
-from Crypto.Util.py3compat import byte_string, bchr, bord, bstr
-from Crypto.Util._raw_api import (load_pycryptodome_raw_lib,
-                                  VoidPointer, SmartPointer,
-                                  c_size_t)
-
-_raw_des3_lib = load_pycryptodome_raw_lib(
-                    "Crypto.Cipher._raw_des3",
-                    """
-                    int DES3_start_operation(const uint8_t key[],
-                                             size_t key_len,
-                                             void **pResult);
-                    int DES3_encrypt(const void *state,
-                                     const uint8_t *in,
-                                     uint8_t *out,
-                                     size_t data_len);
-                    int DES3_decrypt(const void *state,
-                                     const uint8_t *in,
-                                     uint8_t *out,
-                                     size_t data_len);
-                    int DES3_stop_operation(void *state);
-                    """)
-
-
-def adjust_key_parity(key_in):
-    """Set the parity bits in a TDES key.
-
-    :param key_in: the TDES key whose bits need to be adjusted
-    :type key_in: byte string
-
-    :returns: a copy of ``key_in``, with the parity bits correctly set
-    :rtype: byte string
-
-    :raises ValueError: if the TDES key is not 16 or 24 bytes long
-    :raises ValueError: if the TDES key degenerates into Single DES
-    """
-
-    def parity_byte(key_byte):
-        parity = 1
-        for i in range(1, 8):
-            parity ^= (key_byte >> i) & 1
-        return (key_byte & 0xFE) | parity
-
-    if len(key_in) not in key_size:
-        raise ValueError("Not a valid TDES key")
-
-    key_out = b"".join([ bchr(parity_byte(bord(x))) for x in key_in ])
-
-    if key_out[:8] == key_out[8:16] or key_out[-16:-8] == key_out[-8:]:
-        raise ValueError("Triple DES key degenerates to single DES")
-
-    return key_out
-
-
-def _create_base_cipher(dict_parameters):
-    """This method instantiates and returns a handle to a low-level base cipher.
-    It will absorb named parameters in the process."""
-
-    try:
-        key_in = dict_parameters.pop("key")
-    except KeyError:
-        raise TypeError("Missing 'key' parameter")
-
-    key = adjust_key_parity(bstr(key_in))
-
-    start_operation = _raw_des3_lib.DES3_start_operation
-    stop_operation = _raw_des3_lib.DES3_stop_operation
-
-    cipher = VoidPointer()
-    result = start_operation(key,
-                             c_size_t(len(key)),
-                             cipher.address_of())
-    if result:
-        raise ValueError("Error %X while instantiating the TDES cipher"
-                         % result)
-    return SmartPointer(cipher.get(), stop_operation)
-
-
-def new(key, mode, *args, **kwargs):
-    """Create a new Triple DES cipher.
-
-    :param key:
-        The secret key to use in the symmetric cipher.
-        It must be 16 or 24 byte long. The parity bits will be ignored.
-    :type key: bytes/bytearray/memoryview
-
-    :param mode:
-        The chaining mode to use for encryption or decryption.
-    :type mode: One of the supported ``MODE_*`` constants
-
-    :Keyword Arguments:
-        *   **iv** (*bytes*, *bytearray*, *memoryview*) --
-            (Only applicable for ``MODE_CBC``, ``MODE_CFB``, ``MODE_OFB``,
-            and ``MODE_OPENPGP`` modes).
-
-            The initialization vector to use for encryption or decryption.
-
-            For ``MODE_CBC``, ``MODE_CFB``, and ``MODE_OFB`` it must be 8 bytes long.
-
-            For ``MODE_OPENPGP`` mode only,
-            it must be 8 bytes long for encryption
-            and 10 bytes for decryption (in the latter case, it is
-            actually the *encrypted* IV which was prefixed to the ciphertext).
-
-            If not provided, a random byte string is generated (you must then
-            read its value with the :attr:`iv` attribute).
-
-        *   **nonce** (*bytes*, *bytearray*, *memoryview*) --
-            (Only applicable for ``MODE_EAX`` and ``MODE_CTR``).
-
-            A value that must never be reused for any other encryption done
-            with this key.
-
-            For ``MODE_EAX`` there are no
-            restrictions on its length (recommended: **16** bytes).
-
-            For ``MODE_CTR``, its length must be in the range **[0..7]**.
-
-            If not provided for ``MODE_EAX``, a random byte string is generated (you
-            can read it back via the ``nonce`` attribute).
-
-        *   **segment_size** (*integer*) --
-            (Only ``MODE_CFB``).The number of **bits** the plaintext and ciphertext
-            are segmented in. It must be a multiple of 8.
-            If not specified, it will be assumed to be 8.
-
-        *   **mac_len** : (*integer*) --
-            (Only ``MODE_EAX``)
-            Length of the authentication tag, in bytes.
-            It must be no longer than 8 (default).
-
-        *   **initial_value** : (*integer*) --
-            (Only ``MODE_CTR``). The initial value for the counter within
-            the counter block. By default it is **0**.
-
-    :Return: a Triple DES object, of the applicable mode.
-    """
-
-    return _create_cipher(sys.modules[__name__], key, mode, *args, **kwargs)
-
-MODE_ECB = 1
-MODE_CBC = 2
-MODE_CFB = 3
-MODE_OFB = 5
-MODE_CTR = 6
-MODE_OPENPGP = 7
-MODE_EAX = 9
-
-# Size of a data block (in bytes)
-block_size = 8
-# Size of a key (in bytes)
-key_size = (16, 24)

multilingual_toxic_comment_files/env/Lib/site-packages/Crypto/Cipher/DES3.pyi

@@ -1,35 +0,0 @@
-from typing import Union, Dict, Tuple, ByteString, Optional
-
-from Crypto.Cipher._mode_ecb import EcbMode
-from Crypto.Cipher._mode_cbc import CbcMode
-from Crypto.Cipher._mode_cfb import CfbMode
-from Crypto.Cipher._mode_ofb import OfbMode
-from Crypto.Cipher._mode_ctr import CtrMode
-from Crypto.Cipher._mode_openpgp import OpenPgpMode
-from Crypto.Cipher._mode_eax import EaxMode
-
-def adjust_key_parity(key_in: bytes) -> bytes: ...
-
-DES3Mode = int
-
-MODE_ECB: DES3Mode
-MODE_CBC: DES3Mode
-MODE_CFB: DES3Mode
-MODE_OFB: DES3Mode
-MODE_CTR: DES3Mode
-MODE_OPENPGP: DES3Mode
-MODE_EAX: DES3Mode
-
-def new(key: ByteString,
-        mode: DES3Mode,
-        iv : Optional[ByteString] = ...,
-        IV : Optional[ByteString] = ...,
-        nonce : Optional[ByteString] = ...,
-        segment_size : int = ...,
-        mac_len : int = ...,
-        initial_value : Union[int, ByteString] = ...,
-        counter : Dict = ...) -> \
-        Union[EcbMode, CbcMode, CfbMode, OfbMode, CtrMode, OpenPgpMode]: ...
-
-block_size: int
-key_size: Tuple[int, int]

multilingual_toxic_comment_files/env/Lib/site-packages/Crypto/Cipher/PKCS1_OAEP.py

@@ -1,239 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-#  Cipher/PKCS1_OAEP.py : PKCS#1 OAEP
-#
-# ===================================================================
-# The contents of this file are dedicated to the public domain.  To
-# the extent that dedication to the public domain is not available,
-# everyone is granted a worldwide, perpetual, royalty-free,
-# non-exclusive license to exercise all rights associated with the
-# contents of this file for any purpose whatsoever.
-# No rights are reserved.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
-# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-# ===================================================================
-
-from Crypto.Signature.pss import MGF1
-import Crypto.Hash.SHA1
-
-from Crypto.Util.py3compat import bord, _copy_bytes
-import Crypto.Util.number
-from   Crypto.Util.number import ceil_div, bytes_to_long, long_to_bytes
-from   Crypto.Util.strxor import strxor
-from Crypto import Random
-
-class PKCS1OAEP_Cipher:
-    """Cipher object for PKCS#1 v1.5 OAEP.
-    Do not create directly: use :func:`new` instead."""
-
-    def __init__(self, key, hashAlgo, mgfunc, label, randfunc):
-        """Initialize this PKCS#1 OAEP cipher object.
-
-        :Parameters:
-         key : an RSA key object
-                If a private half is given, both encryption and decryption are possible.
-                If a public half is given, only encryption is possible.
-         hashAlgo : hash object
-                The hash function to use. This can be a module under `Crypto.Hash`
-                or an existing hash object created from any of such modules. If not specified,
-                `Crypto.Hash.SHA1` is used.
-         mgfunc : callable
-                A mask generation function that accepts two parameters: a string to
-                use as seed, and the lenth of the mask to generate, in bytes.
-                If not specified, the standard MGF1 consistent with ``hashAlgo`` is used (a safe choice).
-         label : bytes/bytearray/memoryview
-                A label to apply to this particular encryption. If not specified,
-                an empty string is used. Specifying a label does not improve
-                security.
-         randfunc : callable
-                A function that returns random bytes.
-
-        :attention: Modify the mask generation function only if you know what you are doing.
-                    Sender and receiver must use the same one.
-        """
-        self._key = key
-
-        if hashAlgo:
-            self._hashObj = hashAlgo
-        else:
-            self._hashObj = Crypto.Hash.SHA1
-
-        if mgfunc:
-            self._mgf = mgfunc
-        else:
-            self._mgf = lambda x,y: MGF1(x,y,self._hashObj)
-
-        self._label = _copy_bytes(None, None, label)
-        self._randfunc = randfunc
-
-    def can_encrypt(self):
-        """Legacy function to check if you can call :meth:`encrypt`.
-
-        .. deprecated:: 3.0"""
-        return self._key.can_encrypt()
-
-    def can_decrypt(self):
-        """Legacy function to check if you can call :meth:`decrypt`.
-
-        .. deprecated:: 3.0"""
-        return self._key.can_decrypt()
-
-    def encrypt(self, message):
-        """Encrypt a message with PKCS#1 OAEP.
-
-        :param message:
-            The message to encrypt, also known as plaintext. It can be of
-            variable length, but not longer than the RSA modulus (in bytes)
-            minus 2, minus twice the hash output size.
-            For instance, if you use RSA 2048 and SHA-256, the longest message
-            you can encrypt is 190 byte long.
-        :type message: bytes/bytearray/memoryview
-
-        :returns: The ciphertext, as large as the RSA modulus.
-        :rtype: bytes
-
-        :raises ValueError:
-            if the message is too long.
-        """
-
-        # See 7.1.1 in RFC3447
-        modBits = Crypto.Util.number.size(self._key.n)
-        k = ceil_div(modBits, 8) # Convert from bits to bytes
-        hLen = self._hashObj.digest_size
-        mLen = len(message)
-
-        # Step 1b
-        ps_len = k - mLen - 2 * hLen - 2
-        if ps_len < 0:
-            raise ValueError("Plaintext is too long.")
-        # Step 2a
-        lHash = self._hashObj.new(self._label).digest()
-        # Step 2b
-        ps = b'\x00' * ps_len
-        # Step 2c
-        db = lHash + ps + b'\x01' + _copy_bytes(None, None, message)
-        # Step 2d
-        ros = self._randfunc(hLen)
-        # Step 2e
-        dbMask = self._mgf(ros, k-hLen-1)
-        # Step 2f
-        maskedDB = strxor(db, dbMask)
-        # Step 2g
-        seedMask = self._mgf(maskedDB, hLen)
-        # Step 2h
-        maskedSeed = strxor(ros, seedMask)
-        # Step 2i
-        em = b'\x00' + maskedSeed + maskedDB
-        # Step 3a (OS2IP)
-        em_int = bytes_to_long(em)
-        # Step 3b (RSAEP)
-        m_int = self._key._encrypt(em_int)
-        # Step 3c (I2OSP)
-        c = long_to_bytes(m_int, k)
-        return c
-
-    def decrypt(self, ciphertext):
-        """Decrypt a message with PKCS#1 OAEP.
-
-        :param ciphertext: The encrypted message.
-        :type ciphertext: bytes/bytearray/memoryview
-
-        :returns: The original message (plaintext).
-        :rtype: bytes
-
-        :raises ValueError:
-            if the ciphertext has the wrong length, or if decryption
-            fails the integrity check (in which case, the decryption
-            key is probably wrong).
-        :raises TypeError:
-            if the RSA key has no private half (i.e. you are trying
-            to decrypt using a public key).
-        """
-
-        # See 7.1.2 in RFC3447
-        modBits = Crypto.Util.number.size(self._key.n)
-        k = ceil_div(modBits,8) # Convert from bits to bytes
-        hLen = self._hashObj.digest_size
-
-        # Step 1b and 1c
-        if len(ciphertext) != k or k<hLen+2:
-            raise ValueError("Ciphertext with incorrect length.")
-        # Step 2a (O2SIP)
-        ct_int = bytes_to_long(ciphertext)
-        # Step 2b (RSADP)
-        m_int = self._key._decrypt(ct_int)
-        # Complete step 2c (I2OSP)
-        em = long_to_bytes(m_int, k)
-        # Step 3a
-        lHash = self._hashObj.new(self._label).digest()
-        # Step 3b
-        y = em[0]
-        # y must be 0, but we MUST NOT check it here in order not to
-        # allow attacks like Manger's (http://dl.acm.org/citation.cfm?id=704143)
-        maskedSeed = em[1:hLen+1]
-        maskedDB = em[hLen+1:]
-        # Step 3c
-        seedMask = self._mgf(maskedDB, hLen)
-        # Step 3d
-        seed = strxor(maskedSeed, seedMask)
-        # Step 3e
-        dbMask = self._mgf(seed, k-hLen-1)
-        # Step 3f
-        db = strxor(maskedDB, dbMask)
-        # Step 3g
-        one_pos = hLen + db[hLen:].find(b'\x01')
-        lHash1 = db[:hLen]
-        invalid = bord(y) | int(one_pos < hLen)
-        hash_compare = strxor(lHash1, lHash)
-        for x in hash_compare:
-            invalid |= bord(x)
-        for x in db[hLen:one_pos]:
-            invalid |= bord(x)
-        if invalid != 0:
-            raise ValueError("Incorrect decryption.")
-        # Step 4
-        return db[one_pos + 1:]
-
-def new(key, hashAlgo=None, mgfunc=None, label=b'', randfunc=None):
-    """Return a cipher object :class:`PKCS1OAEP_Cipher` that can be used to perform PKCS#1 OAEP encryption or decryption.
-
-    :param key:
-      The key object to use to encrypt or decrypt the message.
-      Decryption is only possible with a private RSA key.
-    :type key: RSA key object
-
-    :param hashAlgo:
-      The hash function to use. This can be a module under `Crypto.Hash`
-      or an existing hash object created from any of such modules.
-      If not specified, `Crypto.Hash.SHA1` is used.
-    :type hashAlgo: hash object
-
-    :param mgfunc:
-      A mask generation function that accepts two parameters: a string to
-      use as seed, and the lenth of the mask to generate, in bytes.
-      If not specified, the standard MGF1 consistent with ``hashAlgo`` is used (a safe choice).
-    :type mgfunc: callable
-
-    :param label:
-      A label to apply to this particular encryption. If not specified,
-      an empty string is used. Specifying a label does not improve
-      security.
-    :type label: bytes/bytearray/memoryview
-
-    :param randfunc:
-      A function that returns random bytes.
-      The default is `Random.get_random_bytes`.
-    :type randfunc: callable
-    """
-
-    if randfunc is None:
-        randfunc = Random.get_random_bytes
-    return PKCS1OAEP_Cipher(key, hashAlgo, mgfunc, label, randfunc)
-

multilingual_toxic_comment_files/env/Lib/site-packages/Crypto/Cipher/PKCS1_OAEP.pyi

@@ -1,35 +0,0 @@
-from typing import Optional, Union, Callable, Any, overload
-from typing_extensions import Protocol
-
-from Crypto.PublicKey.RSA import RsaKey
-
-class HashLikeClass(Protocol):
-    digest_size : int
-    def new(self, data: Optional[bytes] = ...) -> Any: ...
-
-class HashLikeModule(Protocol):
-    digest_size : int
-    @staticmethod
-    def new(data: Optional[bytes] = ...) -> Any: ...
-
-HashLike = Union[HashLikeClass, HashLikeModule]
-
-Buffer = Union[bytes, bytearray, memoryview]
-
-class PKCS1OAEP_Cipher:
-    def __init__(self,
-                 key: RsaKey,
-                 hashAlgo: HashLike,
-                 mgfunc: Callable[[bytes, int], bytes],
-                 label: Buffer,
-                 randfunc: Callable[[int], bytes]) -> None: ...
-    def can_encrypt(self) -> bool: ...
-    def can_decrypt(self) -> bool: ...
-    def encrypt(self, message: Buffer) -> bytes: ...
-    def decrypt(self, ciphertext: Buffer) -> bytes: ...
-
-def new(key: RsaKey,
-        hashAlgo: Optional[HashLike] = ...,
-        mgfunc: Optional[Callable[[bytes, int], bytes]] = ...,
-        label: Optional[Buffer] = ...,
-        randfunc: Optional[Callable[[int], bytes]] = ...) -> PKCS1OAEP_Cipher: ...

multilingual_toxic_comment_files/env/Lib/site-packages/Crypto/Cipher/PKCS1_v1_5.py

@@ -1,217 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-#  Cipher/PKCS1-v1_5.py : PKCS#1 v1.5
-#
-# ===================================================================
-# The contents of this file are dedicated to the public domain.  To
-# the extent that dedication to the public domain is not available,
-# everyone is granted a worldwide, perpetual, royalty-free,
-# non-exclusive license to exercise all rights associated with the
-# contents of this file for any purpose whatsoever.
-# No rights are reserved.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
-# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-# ===================================================================
-
-__all__ = ['new', 'PKCS115_Cipher']
-
-from Crypto import Random
-from Crypto.Util.number import bytes_to_long, long_to_bytes
-from Crypto.Util.py3compat import bord, is_bytes, _copy_bytes
-
-from Crypto.Util._raw_api import (load_pycryptodome_raw_lib, c_size_t,
-                                  c_uint8_ptr)
-
-
-_raw_pkcs1_decode = load_pycryptodome_raw_lib("Crypto.Cipher._pkcs1_decode",
-                        """
-                        int pkcs1_decode(const uint8_t *em, size_t len_em,
-                                         const uint8_t *sentinel, size_t len_sentinel,
-                                         size_t expected_pt_len,
-                                         uint8_t *output);
-                        """)
-
-
-def _pkcs1_decode(em, sentinel, expected_pt_len, output):
-    if len(em) != len(output):
-        raise ValueError("Incorrect output length")
-
-    ret = _raw_pkcs1_decode.pkcs1_decode(c_uint8_ptr(em),
-                                         c_size_t(len(em)),
-                                         c_uint8_ptr(sentinel),
-                                         c_size_t(len(sentinel)),
-                                         c_size_t(expected_pt_len),
-                                         c_uint8_ptr(output))
-    return ret
-
-
-class PKCS115_Cipher:
-    """This cipher can perform PKCS#1 v1.5 RSA encryption or decryption.
-    Do not instantiate directly. Use :func:`Crypto.Cipher.PKCS1_v1_5.new` instead."""
-
-    def __init__(self, key, randfunc):
-        """Initialize this PKCS#1 v1.5 cipher object.
-
-        :Parameters:
-         key : an RSA key object
-          If a private half is given, both encryption and decryption are possible.
-          If a public half is given, only encryption is possible.
-         randfunc : callable
-          Function that returns random bytes.
-        """
-
-        self._key = key
-        self._randfunc = randfunc
-
-    def can_encrypt(self):
-        """Return True if this cipher object can be used for encryption."""
-        return self._key.can_encrypt()
-
-    def can_decrypt(self):
-        """Return True if this cipher object can be used for decryption."""
-        return self._key.can_decrypt()
-
-    def encrypt(self, message):
-        """Produce the PKCS#1 v1.5 encryption of a message.
-
-        This function is named ``RSAES-PKCS1-V1_5-ENCRYPT``, and it is specified in
-        `section 7.2.1 of RFC8017
-        <https://tools.ietf.org/html/rfc8017#page-28>`_.
-
-        :param message:
-            The message to encrypt, also known as plaintext. It can be of
-            variable length, but not longer than the RSA modulus (in bytes) minus 11.
-        :type message: bytes/bytearray/memoryview
-
-        :Returns: A byte string, the ciphertext in which the message is encrypted.
-            It is as long as the RSA modulus (in bytes).
-
-        :Raises ValueError:
-            If the RSA key length is not sufficiently long to deal with the given
-            message.
-        """
-
-        # See 7.2.1 in RFC8017
-        k = self._key.size_in_bytes()
-        mLen = len(message)
-
-        # Step 1
-        if mLen > k - 11:
-            raise ValueError("Plaintext is too long.")
-        # Step 2a
-        ps = []
-        while len(ps) != k - mLen - 3:
-            new_byte = self._randfunc(1)
-            if bord(new_byte[0]) == 0x00:
-                continue
-            ps.append(new_byte)
-        ps = b"".join(ps)
-        assert(len(ps) == k - mLen - 3)
-        # Step 2b
-        em = b'\x00\x02' + ps + b'\x00' + _copy_bytes(None, None, message)
-        # Step 3a (OS2IP)
-        em_int = bytes_to_long(em)
-        # Step 3b (RSAEP)
-        m_int = self._key._encrypt(em_int)
-        # Step 3c (I2OSP)
-        c = long_to_bytes(m_int, k)
-        return c
-
-    def decrypt(self, ciphertext, sentinel, expected_pt_len=0):
-        r"""Decrypt a PKCS#1 v1.5 ciphertext.
-
-        This is the function ``RSAES-PKCS1-V1_5-DECRYPT`` specified in
-        `section 7.2.2 of RFC8017
-        <https://tools.ietf.org/html/rfc8017#page-29>`_.
-
-        Args:
-          ciphertext (bytes/bytearray/memoryview):
-            The ciphertext that contains the message to recover.
-          sentinel (any type):
-            The object to return whenever an error is detected.
-          expected_pt_len (integer):
-            The length the plaintext is known to have, or 0 if unknown.
-
-        Returns (byte string):
-            It is either the original message or the ``sentinel`` (in case of an error).
-
-        .. warning::
-            PKCS#1 v1.5 decryption is intrinsically vulnerable to timing
-            attacks (see `Bleichenbacher's`__ attack).
-            **Use PKCS#1 OAEP instead**.
-
-            This implementation attempts to mitigate the risk
-            with some constant-time constructs.
-            However, they are not sufficient by themselves: the type of protocol you
-            implement and the way you handle errors make a big difference.
-
-            Specifically, you should make it very hard for the (malicious)
-            party that submitted the ciphertext to quickly understand if decryption
-            succeeded or not.
-
-            To this end, it is recommended that your protocol only encrypts
-            plaintexts of fixed length (``expected_pt_len``),
-            that ``sentinel`` is a random byte string of the same length,
-            and that processing continues for as long
-            as possible even if ``sentinel`` is returned (i.e. in case of
-            incorrect decryption).
-
-            .. __: https://dx.doi.org/10.1007/BFb0055716
-        """
-
-        # See 7.2.2 in RFC8017
-        k = self._key.size_in_bytes()
-
-        # Step 1
-        if len(ciphertext) != k:
-            raise ValueError("Ciphertext with incorrect length (not %d bytes)" % k)
-
-        # Step 2a (O2SIP)
-        ct_int = bytes_to_long(ciphertext)
-
-        # Step 2b (RSADP)
-        m_int = self._key._decrypt(ct_int)
-
-        # Complete step 2c (I2OSP)
-        em = long_to_bytes(m_int, k)
-
-        # Step 3 (not constant time when the sentinel is not a byte string)
-        output = bytes(bytearray(k))
-        if not is_bytes(sentinel) or len(sentinel) > k:
-            size = _pkcs1_decode(em, b'', expected_pt_len, output)
-            if size < 0:
-                return sentinel
-            else:
-                return output[size:]
-
-        # Step 3 (somewhat constant time)
-        size = _pkcs1_decode(em, sentinel, expected_pt_len, output)
-        return output[size:]
-
-
-def new(key, randfunc=None):
-    """Create a cipher for performing PKCS#1 v1.5 encryption or decryption.
-
-    :param key:
-      The key to use to encrypt or decrypt the message. This is a `Crypto.PublicKey.RSA` object.
-      Decryption is only possible if *key* is a private RSA key.
-    :type key: RSA key object
-
-    :param randfunc:
-      Function that return random bytes.
-      The default is :func:`Crypto.Random.get_random_bytes`.
-    :type randfunc: callable
-
-    :returns: A cipher object `PKCS115_Cipher`.
-    """
-
-    if randfunc is None:
-        randfunc = Random.get_random_bytes
-    return PKCS115_Cipher(key, randfunc)

multilingual_toxic_comment_files/env/Lib/site-packages/Crypto/Cipher/PKCS1_v1_5.pyi

@@ -1,20 +0,0 @@
-from typing import Callable, Union, Any, Optional, TypeVar
-
-from Crypto.PublicKey.RSA import RsaKey
-
-Buffer = Union[bytes, bytearray, memoryview]
-T = TypeVar('T')
-
-class PKCS115_Cipher:
-    def __init__(self,
-                 key: RsaKey,
-                 randfunc: Callable[[int], bytes]) -> None: ...
-    def can_encrypt(self) -> bool: ...
-    def can_decrypt(self) -> bool: ...
-    def encrypt(self, message: Buffer) -> bytes: ...
-    def decrypt(self, ciphertext: Buffer,
-                sentinel: T,
-                expected_pt_len: Optional[int] = ...) -> Union[bytes, T]: ...
-
-def new(key: RsaKey,
-        randfunc: Optional[Callable[[int], bytes]] = ...) -> PKCS115_Cipher: ...

multilingual_toxic_comment_files/env/Lib/site-packages/Crypto/Cipher/Salsa20.py

@@ -1,167 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Cipher/Salsa20.py : Salsa20 stream cipher (http://cr.yp.to/snuffle.html)
-#
-# Contributed by Fabrizio Tarizzo <fabrizio@fabriziotarizzo.org>.
-#
-# ===================================================================
-# The contents of this file are dedicated to the public domain.  To
-# the extent that dedication to the public domain is not available,
-# everyone is granted a worldwide, perpetual, royalty-free,
-# non-exclusive license to exercise all rights associated with the
-# contents of this file for any purpose whatsoever.
-# No rights are reserved.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
-# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-# ===================================================================
-
-from Crypto.Util.py3compat import _copy_bytes
-from Crypto.Util._raw_api import (load_pycryptodome_raw_lib,
-                                  create_string_buffer,
-                                  get_raw_buffer, VoidPointer,
-                                  SmartPointer, c_size_t,
-                                  c_uint8_ptr, is_writeable_buffer)
-
-from Crypto.Random import get_random_bytes
-
-_raw_salsa20_lib = load_pycryptodome_raw_lib("Crypto.Cipher._Salsa20",
-                    """
-                    int Salsa20_stream_init(uint8_t *key, size_t keylen,
-                                            uint8_t *nonce, size_t nonce_len,
-                                            void **pSalsaState);
-                    int Salsa20_stream_destroy(void *salsaState);
-                    int Salsa20_stream_encrypt(void *salsaState,
-                                               const uint8_t in[],
-                                               uint8_t out[], size_t len);
-                    """)
-
-
-class Salsa20Cipher:
-    """Salsa20 cipher object. Do not create it directly. Use :py:func:`new`
-    instead.
-
-    :var nonce: The nonce with length 8
-    :vartype nonce: byte string
-    """
-
-    def __init__(self, key, nonce):
-        """Initialize a Salsa20 cipher object
-
-        See also `new()` at the module level."""
-
-        if len(key) not in key_size:
-            raise ValueError("Incorrect key length for Salsa20 (%d bytes)" % len(key))
-
-        if len(nonce) != 8:
-            raise ValueError("Incorrect nonce length for Salsa20 (%d bytes)" %
-                             len(nonce))
-
-        self.nonce = _copy_bytes(None, None, nonce)
-
-        self._state = VoidPointer()
-        result = _raw_salsa20_lib.Salsa20_stream_init(
-                        c_uint8_ptr(key),
-                        c_size_t(len(key)),
-                        c_uint8_ptr(nonce),
-                        c_size_t(len(nonce)),
-                        self._state.address_of())
-        if result:
-            raise ValueError("Error %d instantiating a Salsa20 cipher")
-        self._state = SmartPointer(self._state.get(),
-                                   _raw_salsa20_lib.Salsa20_stream_destroy)
-
-        self.block_size = 1
-        self.key_size = len(key)
-
-    def encrypt(self, plaintext, output=None):
-        """Encrypt a piece of data.
-
-        Args:
-          plaintext(bytes/bytearray/memoryview): The data to encrypt, of any size.
-        Keyword Args:
-          output(bytes/bytearray/memoryview): The location where the ciphertext
-            is written to. If ``None``, the ciphertext is returned.
-        Returns:
-          If ``output`` is ``None``, the ciphertext is returned as ``bytes``.
-          Otherwise, ``None``.
-        """
-        
-        if output is None:
-            ciphertext = create_string_buffer(len(plaintext))
-        else:
-            ciphertext = output
-           
-            if not is_writeable_buffer(output):
-                raise TypeError("output must be a bytearray or a writeable memoryview")
-        
-            if len(plaintext) != len(output):
-                raise ValueError("output must have the same length as the input"
-                                 "  (%d bytes)" % len(plaintext))
-
-        result = _raw_salsa20_lib.Salsa20_stream_encrypt(
-                                         self._state.get(),
-                                         c_uint8_ptr(plaintext),
-                                         c_uint8_ptr(ciphertext),
-                                         c_size_t(len(plaintext)))
-        if result:
-            raise ValueError("Error %d while encrypting with Salsa20" % result)
-
-        if output is None:
-            return get_raw_buffer(ciphertext)
-        else:
-            return None
-
-    def decrypt(self, ciphertext, output=None):
-        """Decrypt a piece of data.
-        
-        Args:
-          ciphertext(bytes/bytearray/memoryview): The data to decrypt, of any size.
-        Keyword Args:
-          output(bytes/bytearray/memoryview): The location where the plaintext
-            is written to. If ``None``, the plaintext is returned.
-        Returns:
-          If ``output`` is ``None``, the plaintext is returned as ``bytes``.
-          Otherwise, ``None``.
-        """
-
-        try:
-            return self.encrypt(ciphertext, output=output)
-        except ValueError as e:
-            raise ValueError(str(e).replace("enc", "dec"))
-
-
-def new(key, nonce=None):
-    """Create a new Salsa20 cipher
-
-    :keyword key: The secret key to use. It must be 16 or 32 bytes long.
-    :type key: bytes/bytearray/memoryview
-
-    :keyword nonce:
-        A value that must never be reused for any other encryption
-        done with this key. It must be 8 bytes long.
-
-        If not provided, a random byte string will be generated (you can read
-        it back via the ``nonce`` attribute of the returned object).
-    :type nonce: bytes/bytearray/memoryview
-
-    :Return: a :class:`Crypto.Cipher.Salsa20.Salsa20Cipher` object
-    """
-
-    if nonce is None:
-        nonce = get_random_bytes(8)
-
-    return Salsa20Cipher(key, nonce)
-
-# Size of a data block (in bytes)
-block_size = 1
-
-# Size of a key (in bytes)
-key_size = (16, 32)
-

multilingual_toxic_comment_files/env/Lib/site-packages/Crypto/Cipher/Salsa20.pyi

@@ -1,24 +0,0 @@
-from typing import Union, Tuple, Optional, overload, ByteString, Optional
-
-class Salsa20Cipher:
-    nonce: bytes
-    block_size: int
-    key_size: int
-
-    def __init__(self,
-                 key: ByteString,
-                 nonce: ByteString) -> None: ...
-    @overload
-    def encrypt(self, plaintext: ByteString) -> bytes: ...
-    @overload
-    def encrypt(self, plaintext: ByteString, output: Union[bytearray, memoryview]) -> None: ...
-    @overload
-    def decrypt(self, plaintext: ByteString) -> bytes: ...
-    @overload
-    def decrypt(self, plaintext: ByteString, output: Union[bytearray, memoryview]) -> None: ...
-
-def new(key: ByteString, nonce: Optional[ByteString] = ...) -> Salsa20Cipher: ...
-
-block_size: int
-key_size: Tuple[int, int]
-

multilingual_toxic_comment_files/env/Lib/site-packages/Crypto/Cipher/_EKSBlowfish.py

@@ -1,131 +0,0 @@
-# ===================================================================
-#
-# Copyright (c) 2019, Legrandin <helderijs@gmail.com>
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions
-# are met:
-#
-# 1. Redistributions of source code must retain the above copyright
-#    notice, this list of conditions and the following disclaimer.
-# 2. Redistributions in binary form must reproduce the above copyright
-#    notice, this list of conditions and the following disclaimer in
-#    the documentation and/or other materials provided with the
-#    distribution.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
-# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-# POSSIBILITY OF SUCH DAMAGE.
-# ===================================================================
-
-import sys
-
-from Crypto.Cipher import _create_cipher
-from Crypto.Util._raw_api import (load_pycryptodome_raw_lib,
-                                  VoidPointer, SmartPointer, c_size_t,
-                                  c_uint8_ptr, c_uint)
-
-_raw_blowfish_lib = load_pycryptodome_raw_lib(
-        "Crypto.Cipher._raw_eksblowfish",
-        """
-        int EKSBlowfish_start_operation(const uint8_t key[],
-                                        size_t key_len,
-                                        const uint8_t salt[16],
-                                        size_t salt_len,
-                                        unsigned cost,
-                                        unsigned invert,
-                                        void **pResult);
-        int EKSBlowfish_encrypt(const void *state,
-                                const uint8_t *in,
-                                uint8_t *out,
-                                size_t data_len);
-        int EKSBlowfish_decrypt(const void *state,
-                                const uint8_t *in,
-                                uint8_t *out,
-                                size_t data_len);
-        int EKSBlowfish_stop_operation(void *state);
-        """
-        )
-
-
-def _create_base_cipher(dict_parameters):
-    """This method instantiates and returns a smart pointer to
-    a low-level base cipher. It will absorb named parameters in
-    the process."""
-
-    try:
-        key = dict_parameters.pop("key")
-        salt = dict_parameters.pop("salt")
-        cost = dict_parameters.pop("cost")
-    except KeyError as e:
-        raise TypeError("Missing EKSBlowfish parameter: " + str(e))
-    invert = dict_parameters.pop("invert", True)
-
-    if len(key) not in key_size:
-        raise ValueError("Incorrect EKSBlowfish key length (%d bytes)" % len(key))
-
-    start_operation = _raw_blowfish_lib.EKSBlowfish_start_operation
-    stop_operation = _raw_blowfish_lib.EKSBlowfish_stop_operation
-
-    void_p = VoidPointer()
-    result = start_operation(c_uint8_ptr(key),
-                             c_size_t(len(key)),
-                             c_uint8_ptr(salt),
-                             c_size_t(len(salt)),
-                             c_uint(cost),
-                             c_uint(int(invert)),
-                             void_p.address_of())
-    if result:
-        raise ValueError("Error %X while instantiating the EKSBlowfish cipher"
-                         % result)
-    return SmartPointer(void_p.get(), stop_operation)
-
-
-def new(key, mode, salt, cost, invert):
-    """Create a new EKSBlowfish cipher
-    
-    Args:
-
-      key (bytes, bytearray, memoryview):
-        The secret key to use in the symmetric cipher.
-        Its length can vary from 0 to 72 bytes.
-
-      mode (one of the supported ``MODE_*`` constants):
-        The chaining mode to use for encryption or decryption.
-
-      salt (bytes, bytearray, memoryview):
-        The salt that bcrypt uses to thwart rainbow table attacks
-
-      cost (integer):
-        The complexity factor in bcrypt
-
-      invert (bool):
-        If ``False``, in the inner loop use ``ExpandKey`` first over the salt
-        and then over the key, as defined in
-        the `original bcrypt specification <https://www.usenix.org/legacy/events/usenix99/provos/provos_html/node4.html>`_.
-        If ``True``, reverse the order, as in the first implementation of
-        `bcrypt` in OpenBSD.
-
-    :Return: an EKSBlowfish object
-    """
-
-    kwargs = { 'salt':salt, 'cost':cost, 'invert':invert }
-    return _create_cipher(sys.modules[__name__], key, mode, **kwargs)
-
-
-MODE_ECB = 1
-
-# Size of a data block (in bytes)
-block_size = 8
-# Size of a key (in bytes)
-key_size = range(0, 72 + 1)

multilingual_toxic_comment_files/env/Lib/site-packages/Crypto/Cipher/_EKSBlowfish.pyi

@@ -1,15 +0,0 @@
-from typing import Union, Iterable
-
-from Crypto.Cipher._mode_ecb import EcbMode
-
-MODE_ECB: int
-
-Buffer = Union[bytes, bytearray, memoryview]
-
-def new(key: Buffer,
-        mode: int,
-	salt: Buffer,
-	cost: int) -> EcbMode: ...
-
-block_size: int
-key_size: Iterable[int]

multilingual_toxic_comment_files/env/Lib/site-packages/Crypto/Cipher/__init__.py

@@ -1,79 +0,0 @@
-#
-# A block cipher is instantiated as a combination of:
-# 1. A base cipher (such as AES)
-# 2. A mode of operation (such as CBC)
-#
-# Both items are implemented as C modules.
-#
-# The API of #1 is (replace "AES" with the name of the actual cipher):
-# - AES_start_operaion(key) --> base_cipher_state
-# - AES_encrypt(base_cipher_state, in, out, length)
-# - AES_decrypt(base_cipher_state, in, out, length)
-# - AES_stop_operation(base_cipher_state)
-#
-# Where base_cipher_state is AES_State, a struct with BlockBase (set of
-# pointers to encrypt/decrypt/stop) followed by cipher-specific data.
-#
-# The API of #2 is (replace "CBC" with the name of the actual mode):
-# - CBC_start_operation(base_cipher_state) --> mode_state
-# - CBC_encrypt(mode_state, in, out, length)
-# - CBC_decrypt(mode_state, in, out, length)
-# - CBC_stop_operation(mode_state)
-#
-# where mode_state is a a pointer to base_cipher_state plus mode-specific data.
-
-import os
-
-from Crypto.Cipher._mode_ecb import _create_ecb_cipher
-from Crypto.Cipher._mode_cbc import _create_cbc_cipher
-from Crypto.Cipher._mode_cfb import _create_cfb_cipher
-from Crypto.Cipher._mode_ofb import _create_ofb_cipher
-from Crypto.Cipher._mode_ctr import _create_ctr_cipher
-from Crypto.Cipher._mode_openpgp import _create_openpgp_cipher
-from Crypto.Cipher._mode_ccm import _create_ccm_cipher
-from Crypto.Cipher._mode_eax import _create_eax_cipher
-from Crypto.Cipher._mode_siv import _create_siv_cipher
-from Crypto.Cipher._mode_gcm import _create_gcm_cipher
-from Crypto.Cipher._mode_ocb import _create_ocb_cipher
-
-_modes = { 1:_create_ecb_cipher,
-           2:_create_cbc_cipher,
-           3:_create_cfb_cipher,
-           5:_create_ofb_cipher,
-           6:_create_ctr_cipher,
-           7:_create_openpgp_cipher,
-           9:_create_eax_cipher
-           }
-
-_extra_modes = { 8:_create_ccm_cipher,
-                10:_create_siv_cipher,
-                11:_create_gcm_cipher,
-                12:_create_ocb_cipher
-                }
-
-def _create_cipher(factory, key, mode, *args, **kwargs):
-
-    kwargs["key"] = key
-
-    modes = dict(_modes)
-    if kwargs.pop("add_aes_modes", False):
-        modes.update(_extra_modes)
-    if not mode in modes:
-        raise ValueError("Mode not supported")
-
-    if args:
-        if mode in (8, 9, 10, 11, 12):
-            if len(args) > 1:
-                raise TypeError("Too many arguments for this mode")
-            kwargs["nonce"] = args[0]
-        elif mode in (2, 3, 5, 7):
-            if len(args) > 1:
-                raise TypeError("Too many arguments for this mode")
-            kwargs["IV"] = args[0]
-        elif mode == 6:
-            if len(args) > 0:
-                raise TypeError("Too many arguments for this mode")
-        elif mode == 1:
-            raise TypeError("IV is not meaningful for the ECB mode")
-
-    return modes[mode](factory, **kwargs)