


'''simple docstring'''







import os
import random
import sys

from . import cryptomath_module as cryptoMath  # noqa: N812
from . import rabin_miller as rabinMiller  # noqa: N812






def       lowercase					():







       """simple docstring"""







       print('Making key files...'       )
       make_key_files('rsa' ,    1_0_2_4       )
       print('Key files generation successful.'       )






def       lowercase					(_A       ):







       """simple docstring"""







       print('Generating prime p...'       )
       _lowerCAmelCase     :				Optional[int]       =							rabinMiller.generate_large_prime(_A       )
       print('Generating prime q...'       )
       _lowerCAmelCase     :				int       =							rabinMiller.generate_large_prime(_A       )
       _lowerCAmelCase     :				str       =							p * q

       print('Generating e that is relatively prime to (p - 1) * (q - 1)...'       )
       while True:
              _lowerCAmelCase     :				List[Any]       =							random.randrange(2 ** (key_size - 1) ,    2 ** (key_size)       )
              if cryptoMath.gcd(_A ,    (p - 1) * (q - 1)       ) == 1:
                     break

       print('Calculating d that is mod inverse of e...'       )
       _lowerCAmelCase     :				int       =							cryptoMath.find_mod_inverse(_A ,    (p - 1) * (q - 1)       )

       _lowerCAmelCase     :				int       =							(n, e)
       _lowerCAmelCase     :				Any       =							(n, d)
       return (public_key, private_key)






def       lowercase					(_A ,    _A       ):







       """simple docstring"""







       if os.path.exists(f'{name}_pubkey.txt'       ) or os.path.exists(f'{name}_privkey.txt'       ):
              print('\nWARNING:'       )
              print(
                  f'\"{name}_pubkey.txt\" or \"{name}_privkey.txt\" already exists. \n'
                  'Use a different name or delete these files and re-run this program.'       )
              sys.exit()

       _lowerCAmelCase      ,  _lowerCAmelCase     :				Optional[Any]       =							generate_key(_A       )
       print(f'\nWriting public key to file {name}_pubkey.txt...'       )
       with open(f'{name}_pubkey.txt' ,    'w'       ) as out_file:
              out_file.write(f'{key_size},{public_key[0]},{public_key[1]}'       )

       print(f'Writing private key to file {name}_privkey.txt...'       )
       with open(f'{name}_privkey.txt' ,    'w'       ) as out_file:
              out_file.write(f'{key_size},{private_key[0]},{private_key[1]}'       )


if __name__ == "__main__":
       main()



"""simple docstring"""



import math
import unittest


def 			_UpperCamelCase						(    _A   )     ->	bool:





    """simple docstring"""

    assert isinstance(_A       ,   _A   ) and (
        number >= 0
    ), "'number' must been an int and positive"

    if 1 < number < 4:
        # 2 and 3 are primes
        return True
    elif number < 2 or number % 2 == 0 or number % 3 == 0:
        # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
        return False

    # All primes number are in format of 6k +/- 1
    for i in range(5       ,   int(math.sqrt(_A   ) + 1   )       ,   6   ):
        if number % i == 0 or number % (i + 2) == 0:
            return False
    return True




class 		a_    (			unittest.TestCase						):







    def   _snake_case       (      self      :							int  )		->Optional[int]:






        '''simple docstring'''






        self.assertTrue(is_prime(2  )  )
        self.assertTrue(is_prime(3  )  )
        self.assertTrue(is_prime(5  )  )
        self.assertTrue(is_prime(7  )  )
        self.assertTrue(is_prime(11  )  )
        self.assertTrue(is_prime(13  )  )
        self.assertTrue(is_prime(17  )  )
        self.assertTrue(is_prime(19  )  )
        self.assertTrue(is_prime(23  )  )
        self.assertTrue(is_prime(29  )  )







    def   _snake_case       (      self      :							Union[str, Any]  )		->Optional[Any]:






        '''simple docstring'''






        with self.assertRaises(__UpperCamelCase  ):
            is_prime(-19  )
        self.assertFalse(
            is_prime(0  )  ,       """Zero doesn't have any positive factors, primes must have exactly two."""  ,       )
        self.assertFalse(
            is_prime(1  )  ,       """One only has 1 positive factor, primes must have exactly two."""  ,       )
        self.assertFalse(is_prime(2 * 2  )  )
        self.assertFalse(is_prime(2 * 3  )  )
        self.assertFalse(is_prime(3 * 3  )  )
        self.assertFalse(is_prime(3 * 5  )  )
        self.assertFalse(is_prime(3 * 5 * 7  )  )


if __name__ == "__main__":
 unittest.main()