0UT1S's

lib64/python3.8/

By Order of Mr.0UT1S

N/A

[DIR] __pycache__

N/A

N/A

[DIR] collections

N/A

[DIR] concurrent

N/A

[DIR] config-3.8-x86_64-linux-gnu

N/A

N/A

N/A

N/A

[DIR] distutils

N/A

N/A

[DIR] encodings

N/A

[DIR] ensurepip

N/A

N/A

N/A

[DIR] importlib

N/A

N/A

[DIR] lib-dynload

N/A

N/A

N/A

[DIR] multiprocessing

N/A

[DIR] pydoc_data

N/A

[DIR] site-packages

N/A

N/A

N/A

[DIR] turtledemo

N/A

N/A

N/A

N/A

N/A

N/A

N/A

13.61 KB

5.03 KB

__phello__.foo.py

64 bytes

1.76 KB

_collections_abc.py

25.49 KB

_compat_pickle.py

8.54 KB

_compression.py

5.21 KB

_dummy_thread.py

5.89 KB

14.26 KB

_osx_support.py

21.26 KB

6.04 KB

223.31 KB

90.99 KB

_sitebuiltins.py

3.04 KB

24.68 KB

_sysconfigdata__linux_x86_64-linux-gnu.py

37.61 KB

_sysconfigdata_d_linux_x86_64-linux-gnu.py

37.34 KB

_threading_local.py

7.05 KB

5.60 KB

4.38 KB

32.04 KB

477 bytes

93.76 KB

18.78 KB

11.06 KB

19.62 KB

19.90 KB

31.30 KB

13.63 KB

2.16 KB

12.26 KB

6.85 KB

24.25 KB

33.14 KB

11.81 KB

5.31 KB

14.51 KB

10.37 KB

35.81 KB

6.18 KB

3.97 KB

13.36 KB

configparser.py

53.10 KB

24.41 KB

129 bytes

8.46 KB

6.97 KB

3.53 KB

15.77 KB

48.80 KB

86.22 KB

320 bytes

82.09 KB

20.09 KB

102.09 KB

dummy_threading.py

2.75 KB

37.24 KB

9.60 KB

14.36 KB

3.98 KB

14.79 KB

23.76 KB

34.31 KB

36.53 KB

4.86 KB

7.31 KB

5.85 KB

26.50 KB

5.56 KB

20.91 KB

8.14 KB

22.34 KB

7.67 KB

52.35 KB

3.72 KB

10.29 KB

115.77 KB

3.46 KB

69.96 KB

945 bytes

5.21 KB

76.36 KB

12.68 KB

76.82 KB

8.85 KB

21.16 KB

modulefinder.py

23.86 KB

5.44 KB

42.25 KB

27.08 KB

2.82 KB

10.00 KB

5.67 KB

10.46 KB

58.95 KB

38.08 KB

51.38 KB

61.27 KB

62.96 KB

91.29 KB

8.71 KB

21.00 KB

39.48 KB

31.46 KB

14.72 KB

15.26 KB

20.98 KB

22.99 KB

26.70 KB

4.69 KB

8.01 KB

14.90 KB

104.20 KB

11.09 KB

7.08 KB

28.13 KB

15.49 KB

5.14 KB

6.93 KB

11.77 KB

6.29 KB

1.99 KB

18.13 KB

8.33 KB

13.01 KB

50.55 KB

2.22 KB

21.33 KB

33.90 KB

43.95 KB

6.93 KB

34.42 KB

socketserver.py

26.66 KB

26.07 KB

sre_constants.py

6.99 KB

39.29 KB

49.57 KB

5.36 KB

38.76 KB

10.29 KB

12.61 KB

257 bytes

76.42 KB

17.94 KB

2.06 KB

7.83 KB

24.31 KB

11.14 KB

103.98 KB

22.71 KB

26.89 KB

18.95 KB

1003 bytes

49.63 KB

13.16 KB

2.31 KB

25.24 KB

29.17 KB

23.06 KB

16.68 KB

879 bytes

140.35 KB

9.49 KB

67.35 KB

7.11 KB

29.80 KB

19.23 KB

17.80 KB

20.89 KB

23.52 KB

5.77 KB

7.36 KB

85.67 KB

30.04 KB

"""Wrapper to the POSIX crypt library call and associated functionality."""

import sys as _sys

try:
    import _crypt
except ModuleNotFoundError:
    if _sys.platform == 'win32':
        raise ImportError("The crypt module is not supported on Windows")
    else:
        raise ImportError("The required _crypt module was not built as part of CPython")

import string as _string
from random import SystemRandom as _SystemRandom
from collections import namedtuple as _namedtuple

_saltchars = _string.ascii_letters + _string.digits + './'
_sr = _SystemRandom()

class _Method(_namedtuple('_Method', 'name ident salt_chars total_size')):

"""Class representing a salt method per the Modular Crypt Format or the
    legacy 2-character crypt method."""

def __repr__(self):
        return '<crypt.METHOD_{}>'.format(self.name)

def mksalt(method=None, *, rounds=None):
    """Generate a salt for the specified method.

If not specified, the strongest available method will be used.

"""
    if method is None:
        method = methods[0]
    if rounds is not None and not isinstance(rounds, int):
        raise TypeError(f'{rounds.__class__.__name__} object cannot be '
                        f'interpreted as an integer')
    if not method.ident:  # traditional
        s = ''
    else:  # modular
        s = f'${method.ident}$'

if method.ident and method.ident[0] == '2':  # Blowfish variants
        if rounds is None:
            log_rounds = 12
        else:
            log_rounds = int.bit_length(rounds-1)
            if rounds != 1 << log_rounds:
                raise ValueError('rounds must be a power of 2')
            if not 4 <= log_rounds <= 31:
                raise ValueError('rounds out of the range 2**4 to 2**31')
        s += f'{log_rounds:02d}$'
    elif method.ident in ('5', '6'):  # SHA-2
        if rounds is not None:
            if not 1000 <= rounds <= 999_999_999:
                raise ValueError('rounds out of the range 1000 to 999_999_999')
            s += f'rounds={rounds}$'
    elif rounds is not None:
        raise ValueError(f"{method} doesn't support the rounds argument")

s += ''.join(_sr.choice(_saltchars) for char in range(method.salt_chars))
    return s

def crypt(word, salt=None):
    """Return a string representing the one-way hash of a password, with a salt
    prepended.

If ``salt`` is not specified or is ``None``, the strongest
    available method will be selected and a salt generated.  Otherwise,
    ``salt`` may be one of the ``crypt.METHOD_*`` values, or a string as
    returned by ``crypt.mksalt()``.

"""
    if salt is None or isinstance(salt, _Method):
        salt = mksalt(salt)
    return _crypt.crypt(word, salt)

#  available salting/crypto methods
methods = []

def _add_method(name, *args, rounds=None):
    method = _Method(name, *args)
    globals()['METHOD_' + name] = method
    salt = mksalt(method, rounds=rounds)
    result = crypt('', salt)
    if result and len(result) == method.total_size:
        methods.append(method)
        return True
    return False

_add_method('SHA512', '6', 16, 106)
_add_method('SHA256', '5', 16, 63)

# Choose the strongest supported version of Blowfish hashing.
# Early versions have flaws.  Version 'a' fixes flaws of
# the initial implementation, 'b' fixes flaws of 'a'.
# 'y' is the same as 'b', for compatibility
# with openwall crypt_blowfish.
for _v in 'b', 'y', 'a', '':
    if _add_method('BLOWFISH', '2' + _v, 22, 59 + len(_v), rounds=1<<4):
        break

_add_method('MD5', '1', 8, 34)
_add_method('CRYPT', None, 2, 13)

del _v, _add_method