py2docfx 0.1.16rc2051518__py3-none-any.whl → 0.1.17__py3-none-any.whl

py2docfx/venv/venv1/Lib/site-packages/rsa/pkcs1_v2.py

@@ -1,100 +1,100 @@
-#  Copyright 2011 Sybren A. Stüvel <sybren@stuvel.eu>
-#
-#  Licensed under the Apache License, Version 2.0 (the "License");
-#  you may not use this file except in compliance with the License.
-#  You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under the License is distributed on an "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#  See the License for the specific language governing permissions and
-#  limitations under the License.
-
-"""Functions for PKCS#1 version 2 encryption and signing
-
-This module implements certain functionality from PKCS#1 version 2. Main
-documentation is RFC 2437: https://tools.ietf.org/html/rfc2437
-"""
-
-from rsa import (
-    common,
-    pkcs1,
-    transform,
-)
-
-
-def mgf1(seed: bytes, length: int, hasher: str = "SHA-1") -> bytes:
-    """
-    MGF1 is a Mask Generation Function based on a hash function.
-
-    A mask generation function takes an octet string of variable length and a
-    desired output length as input, and outputs an octet string of the desired
-    length. The plaintext-awareness of RSAES-OAEP relies on the random nature of
-    the output of the mask generation function, which in turn relies on the
-    random nature of the underlying hash.
-
-    :param bytes seed: seed from which mask is generated, an octet string
-    :param int length: intended length in octets of the mask, at most 2^32(hLen)
-    :param str hasher: hash function (hLen denotes the length in octets of the hash
-        function output)
-
-    :return: mask, an octet string of length `length`
-    :rtype: bytes
-
-    :raise OverflowError: when `length` is too large for the specified `hasher`
-    :raise ValueError: when specified `hasher` is invalid
-    """
-
-    try:
-        hash_length = pkcs1.HASH_METHODS[hasher]().digest_size
-    except KeyError as ex:
-        raise ValueError(
-            "Invalid `hasher` specified. Please select one of: {hash_list}".format(
-                hash_list=", ".join(sorted(pkcs1.HASH_METHODS.keys()))
-            )
-        ) from ex
-
-    # If l > 2^32(hLen), output "mask too long" and stop.
-    if length > (2 ** 32 * hash_length):
-        raise OverflowError(
-            "Desired length should be at most 2**32 times the hasher's output "
-            "length ({hash_length} for {hasher} function)".format(
-                hash_length=hash_length,
-                hasher=hasher,
-            )
-        )
-
-    # Looping `counter` from 0 to ceil(l / hLen)-1, build `output` based on the
-    # hashes formed by (`seed` + C), being `C` an octet string of length 4
-    # generated by converting `counter` with the primitive I2OSP
-    output = b"".join(
-        pkcs1.compute_hash(
-            seed + transform.int2bytes(counter, fill_size=4),
-            method_name=hasher,
-        )
-        for counter in range(common.ceil_div(length, hash_length) + 1)
-    )
-
-    # Output the leading `length` octets of `output` as the octet string mask.
-    return output[:length]
-
-
-__all__ = [
-    "mgf1",
-]
-
-if __name__ == "__main__":
-    print("Running doctests 1000x or until failure")
-    import doctest
-
-    for count in range(1000):
-        (failures, tests) = doctest.testmod()
-        if failures:
-            break
-
-        if count % 100 == 0 and count:
-            print("%i times" % count)
-
-    print("Doctests done")
+#  Copyright 2011 Sybren A. Stüvel <sybren@stuvel.eu>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+"""Functions for PKCS#1 version 2 encryption and signing
+
+This module implements certain functionality from PKCS#1 version 2. Main
+documentation is RFC 2437: https://tools.ietf.org/html/rfc2437
+"""
+
+from rsa import (
+    common,
+    pkcs1,
+    transform,
+)
+
+
+def mgf1(seed: bytes, length: int, hasher: str = "SHA-1") -> bytes:
+    """
+    MGF1 is a Mask Generation Function based on a hash function.
+
+    A mask generation function takes an octet string of variable length and a
+    desired output length as input, and outputs an octet string of the desired
+    length. The plaintext-awareness of RSAES-OAEP relies on the random nature of
+    the output of the mask generation function, which in turn relies on the
+    random nature of the underlying hash.
+
+    :param bytes seed: seed from which mask is generated, an octet string
+    :param int length: intended length in octets of the mask, at most 2^32(hLen)
+    :param str hasher: hash function (hLen denotes the length in octets of the hash
+        function output)
+
+    :return: mask, an octet string of length `length`
+    :rtype: bytes
+
+    :raise OverflowError: when `length` is too large for the specified `hasher`
+    :raise ValueError: when specified `hasher` is invalid
+    """
+
+    try:
+        hash_length = pkcs1.HASH_METHODS[hasher]().digest_size
+    except KeyError as ex:
+        raise ValueError(
+            "Invalid `hasher` specified. Please select one of: {hash_list}".format(
+                hash_list=", ".join(sorted(pkcs1.HASH_METHODS.keys()))
+            )
+        ) from ex
+
+    # If l > 2^32(hLen), output "mask too long" and stop.
+    if length > (2 ** 32 * hash_length):
+        raise OverflowError(
+            "Desired length should be at most 2**32 times the hasher's output "
+            "length ({hash_length} for {hasher} function)".format(
+                hash_length=hash_length,
+                hasher=hasher,
+            )
+        )
+
+    # Looping `counter` from 0 to ceil(l / hLen)-1, build `output` based on the
+    # hashes formed by (`seed` + C), being `C` an octet string of length 4
+    # generated by converting `counter` with the primitive I2OSP
+    output = b"".join(
+        pkcs1.compute_hash(
+            seed + transform.int2bytes(counter, fill_size=4),
+            method_name=hasher,
+        )
+        for counter in range(common.ceil_div(length, hash_length) + 1)
+    )
+
+    # Output the leading `length` octets of `output` as the octet string mask.
+    return output[:length]
+
+
+__all__ = [
+    "mgf1",
+]
+
+if __name__ == "__main__":
+    print("Running doctests 1000x or until failure")
+    import doctest
+
+    for count in range(1000):
+        (failures, tests) = doctest.testmod()
+        if failures:
+            break
+
+        if count % 100 == 0 and count:
+            print("%i times" % count)
+
+    print("Doctests done")

py2docfx/venv/venv1/Lib/site-packages/rsa/prime.py

@@ -1,198 +1,198 @@
-#  Copyright 2011 Sybren A. Stüvel <sybren@stuvel.eu>
-#
-#  Licensed under the Apache License, Version 2.0 (the "License");
-#  you may not use this file except in compliance with the License.
-#  You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under the License is distributed on an "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#  See the License for the specific language governing permissions and
-#  limitations under the License.
-
-"""Numerical functions related to primes.
-
-Implementation based on the book Algorithm Design by Michael T. Goodrich and
-Roberto Tamassia, 2002.
-"""
-
-import rsa.common
-import rsa.randnum
-
-__all__ = ["getprime", "are_relatively_prime"]
-
-
-def gcd(p: int, q: int) -> int:
-    """Returns the greatest common divisor of p and q
-
-    >>> gcd(48, 180)
-    12
-    """
-
-    while q != 0:
-        (p, q) = (q, p % q)
-    return p
-
-
-def get_primality_testing_rounds(number: int) -> int:
-    """Returns minimum number of rounds for Miller-Rabing primality testing,
-    based on number bitsize.
-
-    According to NIST FIPS 186-4, Appendix C, Table C.3, minimum number of
-    rounds of M-R testing, using an error probability of 2 ** (-100), for
-    different p, q bitsizes are:
-      * p, q bitsize: 512; rounds: 7
-      * p, q bitsize: 1024; rounds: 4
-      * p, q bitsize: 1536; rounds: 3
-    See: http://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.186-4.pdf
-    """
-
-    # Calculate number bitsize.
-    bitsize = rsa.common.bit_size(number)
-    # Set number of rounds.
-    if bitsize >= 1536:
-        return 3
-    if bitsize >= 1024:
-        return 4
-    if bitsize >= 512:
-        return 7
-    # For smaller bitsizes, set arbitrary number of rounds.
-    return 10
-
-
-def miller_rabin_primality_testing(n: int, k: int) -> bool:
-    """Calculates whether n is composite (which is always correct) or prime
-    (which theoretically is incorrect with error probability 4**-k), by
-    applying Miller-Rabin primality testing.
-
-    For reference and implementation example, see:
-    https://en.wikipedia.org/wiki/Miller%E2%80%93Rabin_primality_test
-
-    :param n: Integer to be tested for primality.
-    :type n: int
-    :param k: Number of rounds (witnesses) of Miller-Rabin testing.
-    :type k: int
-    :return: False if the number is composite, True if it's probably prime.
-    :rtype: bool
-    """
-
-    # prevent potential infinite loop when d = 0
-    if n < 2:
-        return False
-
-    # Decompose (n - 1) to write it as (2 ** r) * d
-    # While d is even, divide it by 2 and increase the exponent.
-    d = n - 1
-    r = 0
-
-    while not (d & 1):
-        r += 1
-        d >>= 1
-
-    # Test k witnesses.
-    for _ in range(k):
-        # Generate random integer a, where 2 <= a <= (n - 2)
-        a = rsa.randnum.randint(n - 3) + 1
-
-        x = pow(a, d, n)
-        if x == 1 or x == n - 1:
-            continue
-
-        for _ in range(r - 1):
-            x = pow(x, 2, n)
-            if x == 1:
-                # n is composite.
-                return False
-            if x == n - 1:
-                # Exit inner loop and continue with next witness.
-                break
-        else:
-            # If loop doesn't break, n is composite.
-            return False
-
-    return True
-
-
-def is_prime(number: int) -> bool:
-    """Returns True if the number is prime, and False otherwise.
-
-    >>> is_prime(2)
-    True
-    >>> is_prime(42)
-    False
-    >>> is_prime(41)
-    True
-    """
-
-    # Check for small numbers.
-    if number < 10:
-        return number in {2, 3, 5, 7}
-
-    # Check for even numbers.
-    if not (number & 1):
-        return False
-
-    # Calculate minimum number of rounds.
-    k = get_primality_testing_rounds(number)
-
-    # Run primality testing with (minimum + 1) rounds.
-    return miller_rabin_primality_testing(number, k + 1)
-
-
-def getprime(nbits: int) -> int:
-    """Returns a prime number that can be stored in 'nbits' bits.
-
-    >>> p = getprime(128)
-    >>> is_prime(p-1)
-    False
-    >>> is_prime(p)
-    True
-    >>> is_prime(p+1)
-    False
-
-    >>> from rsa import common
-    >>> common.bit_size(p) == 128
-    True
-    """
-
-    assert nbits > 3  # the loop will hang on too small numbers
-
-    while True:
-        integer = rsa.randnum.read_random_odd_int(nbits)
-
-        # Test for primeness
-        if is_prime(integer):
-            return integer
-
-            # Retry if not prime
-
-
-def are_relatively_prime(a: int, b: int) -> bool:
-    """Returns True if a and b are relatively prime, and False if they
-    are not.
-
-    >>> are_relatively_prime(2, 3)
-    True
-    >>> are_relatively_prime(2, 4)
-    False
-    """
-
-    d = gcd(a, b)
-    return d == 1
-
-
-if __name__ == "__main__":
-    print("Running doctests 1000x or until failure")
-    import doctest
-
-    for count in range(1000):
-        (failures, tests) = doctest.testmod()
-        if failures:
-            break
-
-        if count % 100 == 0 and count:
-            print("%i times" % count)
-
-    print("Doctests done")
+#  Copyright 2011 Sybren A. Stüvel <sybren@stuvel.eu>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+"""Numerical functions related to primes.
+
+Implementation based on the book Algorithm Design by Michael T. Goodrich and
+Roberto Tamassia, 2002.
+"""
+
+import rsa.common
+import rsa.randnum
+
+__all__ = ["getprime", "are_relatively_prime"]
+
+
+def gcd(p: int, q: int) -> int:
+    """Returns the greatest common divisor of p and q
+
+    >>> gcd(48, 180)
+    12
+    """
+
+    while q != 0:
+        (p, q) = (q, p % q)
+    return p
+
+
+def get_primality_testing_rounds(number: int) -> int:
+    """Returns minimum number of rounds for Miller-Rabing primality testing,
+    based on number bitsize.
+
+    According to NIST FIPS 186-4, Appendix C, Table C.3, minimum number of
+    rounds of M-R testing, using an error probability of 2 ** (-100), for
+    different p, q bitsizes are:
+      * p, q bitsize: 512; rounds: 7
+      * p, q bitsize: 1024; rounds: 4
+      * p, q bitsize: 1536; rounds: 3
+    See: http://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.186-4.pdf
+    """
+
+    # Calculate number bitsize.
+    bitsize = rsa.common.bit_size(number)
+    # Set number of rounds.
+    if bitsize >= 1536:
+        return 3
+    if bitsize >= 1024:
+        return 4
+    if bitsize >= 512:
+        return 7
+    # For smaller bitsizes, set arbitrary number of rounds.
+    return 10
+
+
+def miller_rabin_primality_testing(n: int, k: int) -> bool:
+    """Calculates whether n is composite (which is always correct) or prime
+    (which theoretically is incorrect with error probability 4**-k), by
+    applying Miller-Rabin primality testing.
+
+    For reference and implementation example, see:
+    https://en.wikipedia.org/wiki/Miller%E2%80%93Rabin_primality_test
+
+    :param n: Integer to be tested for primality.
+    :type n: int
+    :param k: Number of rounds (witnesses) of Miller-Rabin testing.
+    :type k: int
+    :return: False if the number is composite, True if it's probably prime.
+    :rtype: bool
+    """
+
+    # prevent potential infinite loop when d = 0
+    if n < 2:
+        return False
+
+    # Decompose (n - 1) to write it as (2 ** r) * d
+    # While d is even, divide it by 2 and increase the exponent.
+    d = n - 1
+    r = 0
+
+    while not (d & 1):
+        r += 1
+        d >>= 1
+
+    # Test k witnesses.
+    for _ in range(k):
+        # Generate random integer a, where 2 <= a <= (n - 2)
+        a = rsa.randnum.randint(n - 3) + 1
+
+        x = pow(a, d, n)
+        if x == 1 or x == n - 1:
+            continue
+
+        for _ in range(r - 1):
+            x = pow(x, 2, n)
+            if x == 1:
+                # n is composite.
+                return False
+            if x == n - 1:
+                # Exit inner loop and continue with next witness.
+                break
+        else:
+            # If loop doesn't break, n is composite.
+            return False
+
+    return True
+
+
+def is_prime(number: int) -> bool:
+    """Returns True if the number is prime, and False otherwise.
+
+    >>> is_prime(2)
+    True
+    >>> is_prime(42)
+    False
+    >>> is_prime(41)
+    True
+    """
+
+    # Check for small numbers.
+    if number < 10:
+        return number in {2, 3, 5, 7}
+
+    # Check for even numbers.
+    if not (number & 1):
+        return False
+
+    # Calculate minimum number of rounds.
+    k = get_primality_testing_rounds(number)
+
+    # Run primality testing with (minimum + 1) rounds.
+    return miller_rabin_primality_testing(number, k + 1)
+
+
+def getprime(nbits: int) -> int:
+    """Returns a prime number that can be stored in 'nbits' bits.
+
+    >>> p = getprime(128)
+    >>> is_prime(p-1)
+    False
+    >>> is_prime(p)
+    True
+    >>> is_prime(p+1)
+    False
+
+    >>> from rsa import common
+    >>> common.bit_size(p) == 128
+    True
+    """
+
+    assert nbits > 3  # the loop will hang on too small numbers
+
+    while True:
+        integer = rsa.randnum.read_random_odd_int(nbits)
+
+        # Test for primeness
+        if is_prime(integer):
+            return integer
+
+            # Retry if not prime
+
+
+def are_relatively_prime(a: int, b: int) -> bool:
+    """Returns True if a and b are relatively prime, and False if they
+    are not.
+
+    >>> are_relatively_prime(2, 3)
+    True
+    >>> are_relatively_prime(2, 4)
+    False
+    """
+
+    d = gcd(a, b)
+    return d == 1
+
+
+if __name__ == "__main__":
+    print("Running doctests 1000x or until failure")
+    import doctest
+
+    for count in range(1000):
+        (failures, tests) = doctest.testmod()
+        if failures:
+            break
+
+        if count % 100 == 0 and count:
+            print("%i times" % count)
+
+    print("Doctests done")

py2docfx/venv/venv1/Lib/site-packages/rsa/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561.  The rsa package uses inline types.