purepycrypto 3.2.0__py3-none-any.whl

purepycrypto/__init__.py

@@ -0,0 +1,389 @@
+# -*- coding: utf-8 -*-
+"""
+purepycrypto
+============
+Pure-Python cryptography library (zero third-party dependencies) - developed by Dvs(DvsXT).
+
+Hash
+----
+- SHA-256 / SHA-512 / BLAKE2b          (``hash``)
+- SHA-3 / Keccak / SHAKE, HMAC-SHA3     (``sha3``)
+
+Key derivation
+--------
+- HMAC-SHA256/512, PBKDF2, HKDF, scrypt, Argon2id   (``kdf``)
+
+Symmetric encryption
+--------
+- AES-128/192/256: ECB / CBC / CTR / CFB / OFB / GCM  (``aes``)
+- AES-GCM-SIV (RFC 8452, nonce-misuse resistant)              (``aes_gcm_siv``)
+- ChaCha20-Poly1305 / XChaCha20-Poly1305               (``chacha``)
+
+Public key
+----
+- X25519 (RFC 7748)                     (``x25519``)
+- Ed25519 (RFC 8032)                    (``ed25519``)
+- RSA: keygen / OAEP / PSS / PEM        (``rsa``)
+- ASN.1 DER / PEM                       (``der``)
+
+Utilities
+----
+- Constant-time comparison, secure random, multiprocessing    (``common`` / ``parallel``)
+
+Usage
+----
+    from purepycrypto import sha256, sha3_256, AES, ed25519_sign
+
+    digest = sha256(b"hello")
+    aes = AES(b"0" * 16)
+    ct, tag = aes.gcm_encrypt(b"\\x00" * 12, b"secret")
+
+Command line
+------
+One command, two modes (call it directly after install, no python -m needed):
+
+    purepycrypto                            # no args -> interactive TUI
+    purepycrypto hash --algo sha256 --text abc --hex    # with args -> CLI
+    purepycrypto --help                     # CLI help
+    purepycrypto version                    # show version
+    purepycrypto selftest                   # run built-in self-test
+
+Equivalent invocation (when not installed):
+
+    python -m purepycrypto                  # TUI
+    python -m purepycrypto hash --text abc --hex        # CLI
+"""
+
+# ------------------------------------------------------------------
+# Public API exports
+# ------------------------------------------------------------------
+# ---- Unified error system (the single place where errors are defined) ----
+from ._ppyc_error import (
+    PPYC_ERR,
+    PPYCError,
+    CryptoError,
+    DecryptionError,
+    Ed25519Error,
+    ok, err, is_ok, is_err, raise_ppyc, OK_TUPLE,
+    PPYCResult,
+    ALL_ERROR_CODES,
+    PPYC_ERR_PREFIX,
+)
+
+from .common import (
+    _consttime_eq,
+    _consttime_int_eq,
+    _consttime_select,
+    rand_int,
+    rand_bytes,
+    MASK32, MASK64, MASK128,
+    POLY1305_P,
+    GHASH_R,
+    R_CONST,
+)
+
+from .hash import sha256, sha512, blake2b
+
+from .kdf import (
+    hmac_sha256,
+    hmac_sha512,
+    pbkdf2_hmac,
+    hkdf,
+    hkdf_extract,
+    hkdf_expand,
+    scrypt,
+    argon2id,
+)
+
+from .aes import AES
+
+from .chacha import (
+    poly1305_mac,
+    chacha20poly1305_encrypt,
+    chacha20poly1305_decrypt,
+    xchacha20poly1305_encrypt,
+    xchacha20poly1305_decrypt,
+)
+
+from .x25519 import (
+    x25519,
+    x25519_base,
+    x25519_shared,
+    x25519_generate_keypair,
+)
+
+from .rsa import (
+    RSAPublicKey,
+    RSAPrivateKey,
+    rsa_keygen,
+    rsa_oaep_encrypt,
+    rsa_oaep_decrypt,
+    rsa_pss_sign,
+    rsa_pss_verify,
+)
+
+from .der import (
+    private_key_to_pkcs1_der,
+    public_key_to_pkcs1_der,
+    private_key_to_pkcs8_der,
+    public_key_to_spki_der,
+    private_key_to_pem,
+    public_key_to_pem,
+    parse_private_pem,
+)
+
+from .parallel import _HAS_MP
+
+# ---- Algorithms added in v1.1 (optional: skipped if the module is missing, for gradual upgrades) ----
+try:
+    from .sha3 import (
+        sha3_224, sha3_256, sha3_384, sha3_512,
+        shake128, shake256,
+        hmac_sha3_256, hmac_sha3_512,
+        sha3_batch,
+    )
+    _HAS_SHA3 = True
+except ImportError:
+    _HAS_SHA3 = False
+
+try:
+    from .ed25519 import (
+        ed25519_keygen,
+        ed25519_publickey,
+        ed25519_sign,
+        ed25519_verify,
+    )
+    _HAS_ED25519 = True
+except ImportError:
+    _HAS_ED25519 = False
+
+try:
+    from .aes_gcm_siv import (
+        aes128_gcm_siv_encrypt,
+        aes128_gcm_siv_decrypt,
+        aes256_gcm_siv_encrypt,
+        aes256_gcm_siv_decrypt,
+        aes_gcm_siv_encrypt,
+        aes_gcm_siv_decrypt,
+        set_cache_enabled,
+        cache_enabled,
+        clear_caches,
+    )
+    _HAS_GCM_SIV = True
+except ImportError:
+    _HAS_GCM_SIV = False
+
+# ---- Modules added in v3.2.0 (optional: skipped when the module is missing, for gradual upgrades) ----
+try:
+    from .kdf2 import (
+        pbkdf2, argon2id_hash, argon2id_verify, argon2i_hash, argon2d_hash,
+        argon2id_hash_encoded, scrypt_simple,
+    )
+    _HAS_KDF2 = True
+except ImportError:
+    _HAS_KDF2 = False
+
+try:
+    from .encoding import (
+        b64encode, b64decode, b64encode_urlsafe, b64decode_urlsafe,
+        b64encode_nopad, b64decode_nopad,
+        b32encode, b32decode, b32encode_hex, b32decode_hex,
+        hex_encode, hex_decode, hex_encode_sep, hex_decode_sep,
+        b58encode, b58decode,
+    )
+    _HAS_ENCODING = True
+except ImportError:
+    _HAS_ENCODING = False
+
+try:
+    from .rand import (
+        random_bytes, random_int, random_below, random_bit, random_bits,
+        token_bytes, token_hex, token_urlsafe,
+        random_string, random_password, random_uuid4,
+        random_choice, random_sample,
+    )
+    _HAS_RAND = True
+except ImportError:
+    _HAS_RAND = False
+
+try:
+    from ._version import __version__
+except ImportError:  # fallback when _version.py has not been generated in a dev environment
+    __version__ = "3.2.0"
+
+__author__ = "Dvs(DvsXT)"
+__license__ = "MIT"
+
+
+# ------------------------------------------------------------------
+# Entry points: reuse the single-file build from build_single or the in-package entry modules
+# ------------------------------------------------------------------
+
+def run_tui(argv=None):
+    """Start the interactive TUI.
+
+    Prefers the in-package ``purepycrypto.cli``; if unavailable (e.g. a trimmed distribution),
+    it falls back to generating and running a single-file TUI build via ``scripts.build_single``.
+    """
+    try:
+        from . import cli
+        return cli._tui_main()
+    except ImportError:
+        return _run_from_build_single("tui", argv)
+
+
+def run_cli(argv=None):
+    """Run the command-line argument version (subcommands: hash/kdf/aes/x25519/rsa/...).
+
+    Prefers the in-package ``purepycrypto.cli_args``; otherwise falls back to the single-file CLI build from build_single.
+    """
+    try:
+        from . import cli_args
+        return cli_args._cli_main(argv)
+    except ImportError:
+        return _run_from_build_single("cli", argv)
+
+
+def _run_from_build_single(mode, argv=None):
+    """Fallback path: generate and execute a single-file build of the given mode via scripts/build_single.
+
+    This guarantees that even if the package layout is trimmed, as long as scripts/build_single.py is
+    reachable, the full TUI / CLI remains available. build_single itself can also be run standalone.
+    """
+    import os
+    import runpy
+    import subprocess
+    import sys
+    import tempfile
+
+    here = os.path.dirname(os.path.abspath(__file__))
+    build_script = os.path.join(here, "scripts", "build_single.py")
+    if not os.path.exists(build_script):
+        raise SystemExit(
+            "[✗] Neither the cli/cli_args module nor scripts/build_single.py is available; "
+            "cannot start " + mode + "."
+        )
+
+    out_dir = tempfile.mkdtemp(prefix="purepycrypto_")
+    out_file = os.path.join(out_dir, "purepycrypto_%s.py" % mode)
+
+    # Invoke build_single to generate the single file (subprocess, avoids polluting this namespace)
+    rc = subprocess.call([sys.executable, build_script, "--mode", mode, "-o", out_file])
+    if rc != 0 or not os.path.exists(out_file):
+        raise SystemExit("[✗] build_single failed to generate " + mode)
+
+    # Run the single file; in CLI mode pass argv through
+    if mode == "cli" and argv is not None:
+        return subprocess.call([sys.executable, out_file] + list(argv))
+    return runpy.run_path(out_file, run_name="__main__")
+
+
+def main(argv=None):
+    """Unified entry point (serves both the console script ``purepycrypto`` and ``python -m purepycrypto``).
+
+    Behavior
+    ----
+    * ``purepycrypto``                (no args)       -> start the interactive TUI
+    * ``purepycrypto --help``         (with args)     -> CLI help
+    * ``purepycrypto hash --algo ...``(with args)     -> CLI mode
+    * ``purepycrypto tui``            (explicit)      -> start the TUI
+    * ``purepycrypto cli ...``        (legacy form)   -> CLI mode
+
+    That is: **one command -- no args enters the TUI, args go to the CLI**.
+    """
+    import sys
+
+    argv = list(sys.argv[1:] if argv is None else argv)
+
+    # No args -> TUI
+    if not argv:
+        return run_tui([])
+
+    first = argv[0]
+
+    # Explicit legacy form compatibility
+    if first == "tui":
+        return run_tui(argv[1:])
+    if first == "cli":
+        return run_cli(argv[1:])
+
+    # Any other args (subcommand, or --help/-h/-V/--version, etc.) -> CLI mode
+    return run_cli(argv)
+
+
+__all__ = [
+    # Unified error system
+    "PPYC_ERR", "PPYCError", "CryptoError", "DecryptionError", "Ed25519Error",
+    "ok", "err", "is_ok", "is_err", "raise_ppyc", "OK_TUPLE", "PPYCResult",
+    "ALL_ERROR_CODES", "PPYC_ERR_PREFIX",
+    # common
+    "rand_int", "rand_bytes",
+    "MASK32", "MASK64", "MASK128", "POLY1305_P", "GHASH_R", "R_CONST",
+    # hash
+    "sha256", "sha512", "blake2b",
+    # kdf
+    "hmac_sha256", "hmac_sha512", "pbkdf2_hmac",
+    "hkdf", "hkdf_extract", "hkdf_expand", "scrypt", "argon2id",
+    # aes
+    "AES",
+    # chacha
+    "poly1305_mac",
+    "chacha20poly1305_encrypt", "chacha20poly1305_decrypt",
+    "xchacha20poly1305_encrypt", "xchacha20poly1305_decrypt",
+    # x25519
+    "x25519", "x25519_base", "x25519_shared", "x25519_generate_keypair",
+    # rsa
+    "RSAPublicKey", "RSAPrivateKey", "rsa_keygen",
+    "rsa_oaep_encrypt", "rsa_oaep_decrypt", "rsa_pss_sign", "rsa_pss_verify",
+    # der
+    "private_key_to_pkcs1_der", "public_key_to_pkcs1_der",
+    "private_key_to_pkcs8_der", "public_key_to_spki_der",
+    "private_key_to_pem", "public_key_to_pem", "parse_private_pem",
+    # Entry points
+    "run_tui", "run_cli", "main",
+    # meta
+    "__version__", "__author__", "__license__",
+]
+
+# v1.1 algorithms (added to __all__ when present)
+if _HAS_SHA3:
+    __all__ += ["sha3_224", "sha3_256", "sha3_384", "sha3_512",
+                "shake128", "shake256", "hmac_sha3_256", "hmac_sha3_512",
+                "sha3_batch"]
+if _HAS_ED25519:
+    __all__ += ["ed25519_keygen", "ed25519_publickey",
+                "ed25519_sign", "ed25519_verify"]
+if _HAS_GCM_SIV:
+    __all__ += ["aes128_gcm_siv_encrypt", "aes128_gcm_siv_decrypt",
+                "aes256_gcm_siv_encrypt", "aes256_gcm_siv_decrypt",
+                "aes_gcm_siv_encrypt", "aes_gcm_siv_decrypt",
+                "set_cache_enabled", "cache_enabled", "clear_caches"]
+
+# v3.2.0 module exports
+if _HAS_KDF2:
+    __all__ += ["pbkdf2", "argon2id_hash", "argon2id_verify",
+                "argon2i_hash", "argon2d_hash", "argon2id_hash_encoded",
+                "scrypt_simple"]
+if _HAS_ENCODING:
+    __all__ += ["b64encode", "b64decode", "b64encode_urlsafe", "b64decode_urlsafe",
+                "b64encode_nopad", "b64decode_nopad",
+                "b32encode", "b32decode", "b32encode_hex", "b32decode_hex",
+                "hex_encode", "hex_decode", "hex_encode_sep", "hex_decode_sep",
+                "b58encode", "b58decode"]
+if _HAS_RAND:
+    __all__ += ["random_bytes", "random_int", "random_below", "random_bit",
+                "random_bits", "token_bytes", "token_hex", "token_urlsafe",
+                "random_string", "random_password", "random_uuid4",
+                "random_choice", "random_sample"]
+
+# Export all error code constants (PPYC_ERR_xxx) so users can reference them directly
+#   Note: the constant names must actually be imported into this namespace for "from purepycrypto import PPYC_ERR_xxx" to work
+from . import _ppyc_error as _ppyc_error_mod
+for _name in dir(_ppyc_error_mod):
+    if _name.startswith("PPYC_ERR_") and _name != "PPYC_ERR_PREFIX":
+        globals()[_name] = getattr(_ppyc_error_mod, _name)
+        if _name not in __all__:
+            __all__.append(_name)
+del _name
+
+__version_tuple__ = tuple(int(x) for x in __version__.split(".")[:3])

purepycrypto/__main__.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+"""``python -m purepycrypto`` entry point (behaves the same as the console script ``purepycrypto``).
+
+Usage
+-----
+    python -m purepycrypto                       # no arguments -> interactive TUI
+    python -m purepycrypto hash --algo sha256 --text abc --hex   # with arguments -> CLI
+    python -m purepycrypto --help                # help for the argument-based CLI
+
+After installation you can use the same-named command (located in the Python Scripts directory):
+
+    purepycrypto                                 # TUI
+    purepycrypto hash --text abc --hex           # CLI
+"""
+import sys
+
+from . import main
+
+if __name__ == "__main__":
+    sys.exit(main() or 0)