hashprint-cli 1.0.0__py3-none-any.whl

HashPrint/__init__.py

@@ -0,0 +1,7 @@
+# In the Name of God, the Most Compassionate, Most Merciful
+
+
+from importlib.metadata import version, metadata
+
+__version__ = version("HashPrint")
+__project_name__ = metadata("HashPrint").get("Name")

HashPrint/cli.py

@@ -0,0 +1,100 @@
+# In the Name of God, the Most Compassionate, Most Merciful
+
+
+import argparse
+import pyfiglet
+from rich_argparse import RichHelpFormatter
+from rich.console import Console
+from rich.theme import Theme
+import sys
+from HashPrint import __project_name__
+
+DISCLAIMER_MESSAGE = "Hash identification is based on pattern matching - therefore some hashes cannot be identified with certainty"
+POSSIBILITY_MESSAGE = "The string may not be a real hash"
+SUCCESS_MESSAGE = f"{__project_name__} ran successfully"
+
+
+class Parser(argparse.ArgumentParser):
+    def error(self, message):
+        console.print(f"[error]\nError: {message}[/error]")
+        console.print(f"[hint]{hint_line}[/hint]")
+        sys.exit()
+
+
+def print_banner():
+    banner = pyfiglet.figlet_format(__project_name__, font="slant")
+    console.print(f"[banner]{banner}[/banner]")
+
+
+theme = Theme(
+    {
+        "success": "#00A86B",  # Jade color
+        "information": "#00D084",  # Bright Jade color
+        "error": "bold #FF4A4A",  # Coral red color
+        "fail": "#EC5B38",  # Warm orange-red color
+        "hint": "#FF5FCF",  # Bright hot pink color
+        "banner": "#499A13",  # Vida Loca color
+        "description": "#24B1B1",  # Medium dark teal color
+        "usage": "#2F2FE4",  # Electric blue color
+        "disclaimer": "#B8860B",  # Dark goldenrod color
+        "warning": "#FFFF00",  # Yellow color
+    }
+)
+
+RichHelpFormatter.styles["argparse.args"] = "#03AED2"  # Sky blue color
+RichHelpFormatter.styles["argparse.groups"] = "#FF6D1F"  # Bright orange color
+RichHelpFormatter.styles["argparse.text"] = "#24B1B1"  # Medium dark teal color
+
+console = Console(highlight=False, theme=theme)
+
+
+description = "\nA forensic CLI tool for hash identification"
+hint_line = "\nRun with -h for usage information"
+program_name_cli = "hashprint"
+format_choices = ["text", "json", "yaml"]
+
+
+def cli_parser():
+    if len(sys.argv) == 1:
+        print_banner()
+        console.print(f"[description]{description}[/description]")
+        console.print(f"[hint]{hint_line}[/hint]")
+        sys.exit()
+
+    parser = Parser(
+        prog=program_name_cli,
+        description=description,
+        formatter_class=RichHelpFormatter,
+        color=False,
+    )
+    parser.add_argument(
+        "-f",
+        "--hash-file",
+        action="append",
+        help="path to a text (.txt) file containing one hash per line",
+    )
+    parser.add_argument(
+        "-c",
+        "--hash",
+        dest="candidate_hash",
+        action="append",
+        help="hash to identify between single quotes and without the 0x prefix",
+    )
+    parser.add_argument("-x", "--format", choices=format_choices, help="output format")
+    parser.add_argument(
+        "-p",
+        "--path",
+        metavar="PATH",
+        help="path of the output file - overwrites the file if it is not empty",
+    )
+    parser.add_argument(
+        "-w",
+        "--walk",
+        metavar="PATH",
+        help="recursively scans a directory for text (.txt) files - containing one hash per line",
+    )
+    parser.add_argument(
+        "-v", "--version", action="store_true", help="displays the version number"
+    )
+    args = parser.parse_args()
+    return args

HashPrint/database.py

@@ -0,0 +1,660 @@
+# In the Name of God, the Most Compassionate, Most Merciful
+
+
+import re
+
+
+class Hash:
+    def __init__(self, pattern, name, family, popularity, source=None):
+        self.pattern = re.compile(pattern)
+        self.name = name
+        self.family = family
+        self.popularity = popularity
+        self.source = source
+
+
+POPULARITY_RANKING = {
+    "Very High": 8,
+    "High": 7,
+    "Moderate/High": 6,
+    "Growing": 5,
+    "Moderate": 4,
+    "Low/Moderate": 3,
+    "Low": 2,
+    "Very Low": 1,
+}
+
+HASH_DATA = (
+    Hash(
+        r"^[a-fA-F0-9]{2}$",
+        "CRC-8 (Generic)",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["High"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{2}$",
+        "CRC-8/SAE-J1850",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["High"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{2}$",
+        "CRC-8/MAXIM (MAXIM-DOW)",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["High"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{2}$",
+        "CRC-8/CDMA2000",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["Moderate"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{2}$",
+        "CRC-8/DARC",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["Low"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{2}$",
+        "CRC-8/DVB-S2",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["Moderate"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{2}$",
+        "CRC-8/EBU (AES/EBU)",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["Moderate"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{2}$",
+        "CRC-8/I-CODE",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["Low"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{2}$",
+        "CRC-8/ITU (CRC-8/ATM)",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["Moderate"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{2}$",
+        "CRC-8/ROHC",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["Moderate"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{2}$",
+        "CRC-8/WCDMA",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["Moderate"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{2}$",
+        "Fletcher-8",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["Low/Moderate"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{4}$",
+        "CRC-16 (Generic)",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["High"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{4}$",
+        "CRC-16/CCITT (CRC-16/CCITT-FALSE)",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["Very High"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{4}$",
+        "CRC-16/ARC (CRC-16/IBM or CRC-16/LHA)",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["High"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{4}$",
+        "CRC-16/MODBUS",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["High"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{4}$",
+        "CRC-16/XMODEM",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["High"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{4}$",
+        "CRC-16/USB",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["Moderate"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{4}$",
+        "CRC-16/DNP",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["Moderate"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{4}$",
+        "CRC-16/KERMIT",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["Moderate"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{4}$",
+        "CRC-16/MCRF4XX",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["Low"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{4}$",
+        "CRC-16/T10-DIF",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["Low/Moderate"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{4}$",
+        "Fletcher-16",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["Moderate"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{6}$",
+        "CRC-24 (OpenPGP)",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["Moderate/High"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{6}$",
+        "CRC-24/BLE",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["Moderate"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{6}$",
+        "CRC-24/FLEXRAY-A",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["Low/Moderate"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{6}$",
+        "CRC-24/FLEXRAY-B",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["Low/Moderate"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{6}$",
+        "CRC-24/LTE-A",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["Low/Moderate"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{6}$",
+        "CRC-24/LTE-B",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["Low/Moderate"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{6}$",
+        "CRC-24/INTERLAKEN",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["Low"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{6}$",
+        "CRC-24/OS-9",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["Low"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{8}$",
+        "CRC-32 (Standard/ISO-HDLC)",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["Very High"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{8}$",
+        "CRC-32/BZIP2",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["Moderate"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{8}$",
+        "CRC-32C (Castagnoli)",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["High"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{8}$",
+        "CRC-32/MPEG-2",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["Low/Moderate"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{8}$",
+        "CRC-32/JAMCRC",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["Low"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{8}$",
+        "Adler-32",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["Moderate"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{8}$",
+        "Fletcher-32",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["Moderate"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{8}$",
+        "MurmurHash3 (32-bit variant)",
+        "Non-Cryptographic Hash",
+        POPULARITY_RANKING["High"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{8}$",
+        "FNV-1/FNV-1a (32-bit)",
+        "Non-Cryptographic Hash",
+        POPULARITY_RANKING["High"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{8}$",
+        "xxHash32",
+        "Non-Cryptographic Hash",
+        POPULARITY_RANKING["High"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{8}$",
+        "CityHash32",
+        "Non-Cryptographic Hash",
+        POPULARITY_RANKING["Moderate"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{8}$",
+        "Jenkins hash (one-at-a-time, 32-bit)",
+        "Non-Cryptographic Hash",
+        POPULARITY_RANKING["Moderate"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{16}$",
+        "CRC-64/XZ",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["Moderate"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{16}$",
+        "CRC-64/ECMA-182",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["Low/Moderate"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{16}$",
+        "CRC-64/GO-ISO",
+        "Error Detection Checksum",
+        POPULARITY_RANKING["Low"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{16}$",
+        "xxHash64",
+        "Non-Cryptographic Hash",
+        POPULARITY_RANKING["Very High"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{16}$",
+        "FNV-1/FNV-1a (64-bit)",
+        "Non-Cryptographic Hash",
+        POPULARITY_RANKING["High"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{16}$",
+        "MurmurHash3 (64-bit / x64 variant)",
+        "Non-Cryptographic Hash",
+        POPULARITY_RANKING["High"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{16}$",
+        "CityHash64",
+        "Non-Cryptographic Hash",
+        POPULARITY_RANKING["Moderate"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{16}$",
+        "SipHash (64-bit output)",
+        "Non-Cryptographic Hash",
+        POPULARITY_RANKING["High"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{16}$",
+        "FarmHash64",
+        "Non-Cryptographic Hash",
+        POPULARITY_RANKING["Low/Moderate"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{32}$",
+        "MD5",
+        "Cryptographic Hash",
+        POPULARITY_RANKING["Very High"],
+    ),
+    Hash(r"^[a-fA-F0-9]{32}$", "MD4", "Cryptographic Hash", POPULARITY_RANKING["Low"]),
+    Hash(
+        r"^[a-fA-F0-9]{32}$",
+        "RIPEMD-128",
+        "Cryptographic Hash",
+        POPULARITY_RANKING["Low"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{32}$",
+        "Tiger-128 (truncated)",
+        "Cryptographic Hash",
+        POPULARITY_RANKING["Very Low"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{32}$",
+        "Haval-128",
+        "Cryptographic Hash",
+        POPULARITY_RANKING["Very Low"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{32}$",
+        "MurmurHash3 (128-bit variant, x64)",
+        "Non-Cryptographic Hash",
+        POPULARITY_RANKING["Moderate"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{32}$",
+        "CityHash128",
+        "Non-Cryptographic Hash",
+        POPULARITY_RANKING["Low/Moderate"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{32}$",
+        "FarmHash128",
+        "Non-Cryptographic Hash",
+        POPULARITY_RANKING["Low"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{32}$",
+        "xxHash128 (XXH3-128)",
+        "Non-Cryptographic Hash",
+        POPULARITY_RANKING["Growing"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{32}$", "NTLM", "Cryptographic Hash", POPULARITY_RANKING["High"]
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{40}$",
+        "SHA-1",
+        "Cryptographic Hash",
+        POPULARITY_RANKING["Very High"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{40}$",
+        "RIPEMD-160",
+        "Cryptographic Hash",
+        POPULARITY_RANKING["Moderate"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{40}$",
+        "Tiger-160 (truncated)",
+        "Cryptographic Hash",
+        POPULARITY_RANKING["Low"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{40}$",
+        "HAS-160",
+        "Cryptographic Hash",
+        POPULARITY_RANKING["Very Low"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{56}$",
+        "SHA-224",
+        "Cryptographic Hash",
+        POPULARITY_RANKING["Moderate"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{56}$",
+        "SHA3-224",
+        "Cryptographic Hash",
+        POPULARITY_RANKING["Low/Moderate"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{56}$",
+        "RIPEMD-224",
+        "Cryptographic Hash",
+        POPULARITY_RANKING["Low"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{56}$",
+        "HAVAL-224",
+        "Cryptographic Hash",
+        POPULARITY_RANKING["Very Low"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{64}$",
+        "SHA-256",
+        "Cryptographic Hash",
+        POPULARITY_RANKING["Very High"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{64}$",
+        "SHA3-256",
+        "Cryptographic Hash",
+        POPULARITY_RANKING["Moderate/High"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{64}$",
+        "BLAKE2s",
+        "Cryptographic Hash",
+        POPULARITY_RANKING["Moderate"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{64}$",
+        "BLAKE3",
+        "Cryptographic Hash",
+        POPULARITY_RANKING["Growing"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{64}$",
+        "RIPEMD-256",
+        "Cryptographic Hash",
+        POPULARITY_RANKING["Low"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{64}$",
+        "GOST R 34.11-2012 (Streebog-256)",
+        "Cryptographic Hash",
+        POPULARITY_RANKING["Low"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{64}$",
+        "Whirlpool (truncated)",
+        "Cryptographic Hash",
+        POPULARITY_RANKING["Very Low"],
+    ),
+    Hash(r"^[a-fA-F0-9]{64}$", "SM3", "Cryptographic Hash", POPULARITY_RANKING["Low"]),
+    Hash(
+        r"^[a-fA-F0-9]{80}$",
+        "RIPEMD-320",
+        "Cryptographic Hash",
+        POPULARITY_RANKING["Low"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{96}$",
+        "SHA-384",
+        "Cryptographic Hash",
+        POPULARITY_RANKING["Moderate/High"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{96}$",
+        "SHA3-384",
+        "Cryptographic Hash",
+        POPULARITY_RANKING["Low/Moderate"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{96}$",
+        "Whirlpool (truncated)",
+        "Cryptographic Hash",
+        POPULARITY_RANKING["Very Low"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{96}$",
+        "Skein-384",
+        "Cryptographic Hash",
+        POPULARITY_RANKING["Very Low"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{128}$",
+        "SHA-512",
+        "Cryptographic Hash",
+        POPULARITY_RANKING["Very High"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{128}$",
+        "SHA3-512",
+        "Cryptographic Hash",
+        POPULARITY_RANKING["Moderate"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{128}$",
+        "Whirlpool",
+        "Cryptographic Hash",
+        POPULARITY_RANKING["Low/Moderate"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{128}$",
+        "BLAKE2b",
+        "Cryptographic Hash",
+        POPULARITY_RANKING["Moderate"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{128}$",
+        "Skein-512",
+        "Cryptographic Hash",
+        POPULARITY_RANKING["Low"],
+    ),
+    Hash(
+        r"^[a-fA-F0-9]{128}$",
+        "GOST R 34.11-2012 (Streebog-512)",
+        "Cryptographic Hash",
+        POPULARITY_RANKING["Low"],
+    ),
+)
+
+PASSWORD_HASH_DATA = (
+    Hash(
+        r"^\$2[abxy]?\$(?:0[4-9]|[12][0-9]|3[01])\$[a-zA-Z0-9./]{53}$",
+        "bcrypt",
+        "Password Hashing Function",
+        POPULARITY_RANKING["Very High"],
+    ),
+    Hash(
+        r"^\$argon2(i|d|id)\$v=\d+\$m=\d+,t=\d+,p=\d+\$[a-zA-Z0-9+/]+={0,2}\$[a-zA-Z0-9+/]+={0,2}$",
+        "Argon2",
+        "Password Hashing Function",
+        POPULARITY_RANKING["Very High"],
+    ),
+    Hash(
+        r"^pbkdf2_(?:sha256|sha512)\$\d+\$[a-zA-Z0-9+/=]+\$[a-zA-Z0-9+/=]+$",
+        "PBKDF2 (Django-style)",
+        "Password Hashing Function",
+        POPULARITY_RANKING["High"],
+    ),
+    Hash(
+        r"^\$pbkdf2(-sha1|-sha256|-sha512)?\$\d+\$[a-zA-Z0-9./+]+\$[a-zA-Z0-9./+]+$",
+        "PBKDF2 (crypt-style)",
+        "Password Hashing Function",
+        POPULARITY_RANKING["Low/Moderate"],
+    ),
+    Hash(
+        r"^\$(?:y|7)\$[a-zA-Z0-9./]+\$[a-zA-Z0-9./]+\$[a-zA-Z0-9./]+$",
+        "yescrypt",
+        "Password Hashing Function",
+        POPULARITY_RANKING["Moderate"],
+    ),
+    Hash(
+        r"^\$scrypt\$(?:ln=\d+,r=\d+,p=\d+|N=\d+,r=\d+,p=\d+)\$[a-zA-Z0-9+/=]+\$[a-zA-Z0-9+/=]+$",
+        "scrypt",
+        "Password Hashing Function",
+        POPULARITY_RANKING["Moderate"],
+    ),
+    Hash(
+        r"^\$6\$(rounds=\d+\$)?[./a-zA-Z0-9]{1,16}\$[./a-zA-Z0-9]{86}$",
+        "SHA-512-crypt",
+        "Password Hashing Function",
+        POPULARITY_RANKING["Moderate"],
+    ),
+    Hash(
+        r"^\$5\$(rounds=\d+\$)?[./a-zA-Z0-9]{1,16}\$[./a-zA-Z0-9]{43}$",
+        "SHA-256-crypt",
+        "Password Hashing Function",
+        POPULARITY_RANKING["Low"],
+    ),
+    Hash(
+        r"^\$1\$[./a-zA-Z0-9]{1,8}\$[./a-zA-Z0-9]{22}$",
+        "MD5-crypt",
+        "Password Hashing Function",
+        POPULARITY_RANKING["Low"],
+    ),
+    Hash(
+        r"^[./a-zA-Z0-9]{13}$",
+        "Traditional DES crypt",
+        "Password Hashing Function",
+        POPULARITY_RANKING["Very Low"],
+    ),
+    Hash(
+        r"^\$lyra2\$t=\d+,m=\d+,p=\d+\$[a-zA-Z0-9+/=]+\$[a-zA-Z0-9+/=]+$",
+        "Lyra2",
+        "Password Hashing Function",
+        POPULARITY_RANKING["Very Low"],
+    ),
+    Hash(
+        r"^\$2[ay]\$[a-zA-Z0-9./]{53}$",
+        "bcrypt (PHP)",
+        "Password Hashing Function (PHP)",
+        POPULARITY_RANKING["High"],
+    ),
+    Hash(
+        r"^\$P\$[a-zA-Z0-9./]{31}$",
+        "phpass (WordPress)",
+        "Password Hashing Function",
+        POPULARITY_RANKING["High"],
+    ),
+    Hash(
+        r"^argon2\$[a-zA-Z0-9+/=]+\$[a-zA-Z0-9+/=]+$",
+        "Argon2 (Django)",
+        "Password Hashing Function",
+        POPULARITY_RANKING["Moderate"],
+    ),
+    Hash(
+        r"^\{[A-Z]+\}[a-zA-Z0-9+/=]+$",
+        "LDAP Hash",
+        "Password Hashing Function",
+        POPULARITY_RANKING["Low/Moderate"],
+    ),
+    Hash(
+        r"^\*[a-fA-F0-9]{40}$",
+        "MySQL Password",
+        "Database Password Hash",
+        POPULARITY_RANKING["Low"],
+    ),
+    Hash(
+        r"^md5[a-fA-F0-9]{32}$",
+        "PostgreSQL MD5",
+        "Database Password Hash",
+        POPULARITY_RANKING["Low"],
+    ),
+    Hash(
+        r"^\{bcrypt\}[a-zA-Z0-9./]{60}$",
+        "Spring Security BCrypt",
+        "Password Hashing Function",
+        POPULARITY_RANKING["Moderate"],
+    ),
+)

HashPrint/formatter.py

@@ -0,0 +1,119 @@
+# In the Name of God, the Most Compassionate, Most Merciful
+
+
+from HashPrint.cli import console, DISCLAIMER_MESSAGE, SUCCESS_MESSAGE
+from HashPrint import __project_name__, __version__
+from datetime import datetime
+import json
+import yaml
+
+timestamp = datetime.now()
+formatted_timestamp = timestamp.strftime("%Y-%m-%d %H:%M:%S")
+
+
+def format_data(results):
+    data = [
+        {
+            "timestamp": f"{formatted_timestamp} by {__project_name__} v{__version__}",
+            "success": SUCCESS_MESSAGE,
+            "disclaimer": DISCLAIMER_MESSAGE,
+        }
+    ]
+    for result in results:
+        info = {
+            "Hash": result["Hash"],
+            "Source": result["Source"],
+            "Possible Algorithms": [
+                {
+                    "Name": algorithm.name,
+                    "Family": algorithm.family,
+                    "Popularity Score": algorithm.popularity,
+                }
+                for algorithm in result["Matches"]
+            ],
+            "Error": result["Error"],
+        }
+        data.append(info)
+    return data
+
+
+def write_text(file_path, data):
+    try:
+        with open(file_path, "w", encoding="utf-8") as text_file:
+            text_file.write(f"Generated at: {formatted_timestamp} by {__project_name__} v{__version__}\n")
+            text_file.write(f"{SUCCESS_MESSAGE}\n")
+            text_file.write(f"DISCLAIMER: {DISCLAIMER_MESSAGE}\n\n")
+            for result in data[1:]:
+                text_file.write(f"Source: {result["Source"]}\n")
+                text_file.write(f"Hash: '{result["Hash"]}'\n")
+                if not result["Possible Algorithms"]:
+                    text_file.write("Possible Algorithms: None\n")
+                else:
+                    text_file.write("Possible Algorithms:\n")
+                    for algorithm in result["Possible Algorithms"]:
+                        text_file.write(f"[#] Name: {algorithm["Name"]}\n")
+                        text_file.write(f"\t[-] Family: {algorithm["Family"]}\n")
+                if not result["Error"]:
+                    text_file.write("Error: None\n\n")
+                else:
+                    text_file.write(f"Error: {result["Error"]}\n\n")
+    except FileNotFoundError:
+        console.print(
+            f"[error]\nError: a directory in the path: '{file_path}' does not exist\n[/error]"
+        )
+    except PermissionError:
+        console.print(
+            f"[error]\nError: write permission to the path: '{file_path}' denied\n[/error]"
+        )
+    except IsADirectoryError:
+        console.print(
+            f"[error]\nError: the path: '{file_path}' is a directory not a file\n[/error]"
+        )
+    except OSError as exception:
+        console.print(
+            f"[error\n]Error: cannot write to the path: '{file_path}' - {exception}\n[/error]"
+        )
+
+
+def write_json(file_path, data):
+    try:
+        with open(file_path, "w", encoding="utf-8") as json_file:
+            json.dump(data, json_file, indent=2)
+    except FileNotFoundError:
+        console.print(
+            f"[error]\nError: a directory in the path: '{file_path}' does not exist\n[/error]"
+        )
+    except PermissionError:
+        console.print(
+            f"[error]\nError: write permission to the path: '{file_path}' denied\n[/error]"
+        )
+    except IsADirectoryError:
+        console.print(
+            f"[error]\nError: the path: '{file_path}' is a directory not a file\n[/error]"
+        )
+    except OSError as exception:
+        console.print(
+            f"[error]\nError: cannot write to the path: '{file_path}' - {exception}\n[/error]"
+        )
+
+
+def write_yaml(file_path, data):
+    try:
+        with open(file_path, "w", encoding="utf-8") as yaml_file:
+            yaml.dump(data, yaml_file, encoding="utf-8", sort_keys=False)
+    except FileNotFoundError:
+        console.print(
+            f"[error]\nError: a directory in the path: '{file_path}' does not exist\n[/error]"
+        )
+    except PermissionError:
+        console.print(
+            f"[error]\nError: write permission to the path: '{file_path}' denied\n[/error]"
+        )
+    except IsADirectoryError:
+        console.print(
+            f"[error]\nError: the path: '{file_path}' is a directory not a file\n[/error]"
+        )
+    except OSError as exception:
+        console.print(
+            f"[error]\nError: cannot write to the path: '{file_path}' - {exception}\n[/error]"
+        )

HashPrint/identifier.py

@@ -0,0 +1,27 @@
+# In the Name of God, the Most Compassionate, Most Merciful
+
+
+from HashPrint.database import HASH_DATA, PASSWORD_HASH_DATA
+import re
+
+
+def is_hex_encoded(candidate_hash):
+    hex_regex = re.compile(r"^[a-fA-F0-9]+$")
+    if hex_regex.fullmatch(candidate_hash):
+        return True
+    return False
+
+
+def identify(candidate_hash):
+    possible_matches = []
+    if is_hex_encoded(candidate_hash):
+        for HASH_INFO in HASH_DATA:
+            if HASH_INFO.pattern.fullmatch(candidate_hash):
+                possible_matches.append(HASH_INFO)
+    else:
+        for PASSWORD_HASH_INFO in PASSWORD_HASH_DATA:
+            if PASSWORD_HASH_INFO.pattern.fullmatch(candidate_hash):
+                possible_matches.append(PASSWORD_HASH_INFO)
+    return sorted(
+        possible_matches, key=lambda matches: matches.popularity, reverse=True
+    )

HashPrint/main.py

@@ -0,0 +1,134 @@
+# In the Name of God, the Most Compassionate, Most Merciful
+
+
+import sys
+from HashPrint.cli import (
+    cli_parser,
+    console,
+    hint_line,
+    DISCLAIMER_MESSAGE,
+    POSSIBILITY_MESSAGE,
+    SUCCESS_MESSAGE,
+    print_banner,
+)
+from HashPrint.validator import validate
+from HashPrint.identifier import identify
+from HashPrint.printer import print_results_to_console
+from HashPrint.reader import read_hashes
+from HashPrint.walker import walker
+from HashPrint.formatter import (
+    write_text,
+    write_json,
+    write_yaml,
+    format_data,
+)
+from HashPrint import __version__, __project_name__
+
+EXIT_SUCCESS = 0
+EXIT_GENERAL_ERROR = 1
+EXIT_USAGE_ERROR = 2
+
+WRITERS = {
+    "text": write_text,
+    "json": write_json,
+    "yaml": write_yaml,
+}
+
+
+def main():
+    args = cli_parser()
+    candidate_hash_values_data = []
+    results = []
+
+    input_option_count = sum(
+        [bool(args.candidate_hash), bool(args.hash_file), bool(args.walk)]
+    )
+
+    if input_option_count > 1:
+        console.print(
+            f"[error]\nError: only one input option (--hash --hash-file --walk) can be used at a time[/error]"
+        )
+        console.print(f"[hint]{hint_line}[/hint]")
+        return EXIT_USAGE_ERROR
+
+    print_banner()
+
+    if args.version:
+        console.print(f"[description]{__project_name__} v{__version__}[/description]")
+        return EXIT_SUCCESS
+
+    # args.candidate_hash is a list
+    if args.candidate_hash:
+        for candidate_hash in args.candidate_hash:
+            candidate_hash_values_data.append(
+                {"Hash": candidate_hash, "Source": "command-line"}
+            )
+    # args.hash_file is also a list
+    elif args.hash_file:
+        for hash_file in args.hash_file:
+            file_hashes = read_hashes(hash_file)
+            for file_hash in file_hashes:
+                candidate_hash_values_data.append(
+                    {"Hash": file_hash, "Source": hash_file}
+                )
+    elif args.walk:
+        text_files = walker(args.walk)
+        if not text_files:
+            console.print(
+                "[error]Error: no text (.txt) files found in the given directory[/error]"
+            )
+            return EXIT_GENERAL_ERROR
+        for text_file in text_files:
+            text_file_hashes = read_hashes(text_file)
+            for text_file_hash in text_file_hashes:
+                candidate_hash_values_data.append(
+                    {"Hash": text_file_hash, "Source": text_file}
+                )
+
+    for candidate_hash_info in candidate_hash_values_data:
+        is_hash_valid, error_msg = validate(candidate_hash_info["Hash"])
+        if not is_hash_valid:
+            results.append(
+                {
+                    "Hash": candidate_hash_info["Hash"],
+                    "Source": candidate_hash_info["Source"],
+                    "Error": error_msg,
+                    "Matches": [],
+                }
+            )
+            continue
+        matches = identify(candidate_hash_info["Hash"])
+        results.append(
+            {
+                "Hash": candidate_hash_info["Hash"],
+                "Source": candidate_hash_info["Source"],
+                "Error": error_msg,
+                "Matches": matches,
+            }
+        )
+
+    if not args.path and args.format:
+        console.print("[error]\nError: missing option: '--path'[/error]")
+        console.print(f"[hint]{hint_line}[/hint]")
+        return EXIT_USAGE_ERROR
+    elif not args.format and args.path:
+        console.print("[error]\nError: missing option: '--format'[/error]")
+        console.print(f"[hint]{hint_line}[/hint]")
+        return EXIT_USAGE_ERROR
+    elif args.format and args.path:
+        data = format_data(results)
+        WRITERS[args.format](args.path, data)
+        console.print(f"[success]\n{SUCCESS_MESSAGE}[/success]")
+        console.print(
+            f"[disclaimer]File is overwritten if it was not empty[/disclaimer]"
+        )
+        console.print(f"\n[disclaimer]DISCLAIMER: {DISCLAIMER_MESSAGE}[/disclaimer]")
+        return EXIT_SUCCESS
+
+    print_results_to_console(results, DISCLAIMER_MESSAGE, POSSIBILITY_MESSAGE)
+
+    return EXIT_SUCCESS
+
+
+if __name__ == "__main__":
+    sys.exit(main())

HashPrint/printer.py

@@ -0,0 +1,26 @@
+# In the Name of God, the Most Compassionate, Most Merciful
+
+
+from HashPrint.cli import console
+
+
+def print_results_to_console(results, DISCLAIMER_MESSAGE, POSSIBILITY_MESSAGE):
+    for result in results:
+        if not result["Error"]:
+            if not result["Matches"]:
+                console.print(f"[hint]\nSource: {result["Source"]}[hint]")
+                console.print(f"[fail]Hash: '{result["Hash"]}'[/fail]")
+                console.print("[fail]No algorithms produce the given hash[/fail]")
+                console.print(f"[hint]Note: {POSSIBILITY_MESSAGE}[/hint]")
+                continue
+            console.print(f"[hint]\nSource: {result["Source"]}[/hint]")
+            console.print(f"[information]Hash: '{result["Hash"]}'[/information]")
+            console.print(f"[information]Possible Algorithms:\n[/information]")
+            for algorithm in result["Matches"]:
+                console.print(f"[success]\\[#] {algorithm.name}[/success]")
+                console.print(f"[success]\tFamily: {algorithm.family}[/success]")
+        else:
+            console.print(f"[hint]\nSource: {result["Source"]}[/hint]")
+            console.print(f"[error]Hash: '{result["Hash"]}'[/error]")
+            console.print(f"[error]Error: {result["Error"]}[/error]")
+    console.print(f"[disclaimer]\nDISCLAIMER: {DISCLAIMER_MESSAGE}[/disclaimer]")

HashPrint/reader.py

@@ -0,0 +1,29 @@
+# In the Name of God, the Most Compassionate, Most Merciful
+
+
+from HashPrint.cli import console
+
+
+def read_hashes(file_path):
+    try:
+        with open(file_path, "r") as hash_file:
+            for line in hash_file:
+                stripped_line = line.strip()
+                if stripped_line:
+                    yield stripped_line
+    except FileNotFoundError:
+        console.print(
+            f"[error]Error: file at the path: '{file_path}' not found - please check the path[/error]"
+        )
+    except PermissionError:
+        console.print(
+            f"[error]Error: read permission to the path: '{file_path}' denied[/error]"
+        )
+    except IsADirectoryError:
+        console.print(
+            f"[error]Error: the path: '{file_path}' is a directory not a file[/error]"
+        )
+    except OSError as exception:
+        console.print(
+            f"[error]Error: cannot write to the path: '{file_path}' - {exception}[/error]"
+        )

HashPrint/validator.py

@@ -0,0 +1,33 @@
+# In the Name of God, the Most Compassionate, Most Merciful
+
+
+def validate(raw_hash):
+    INVALID = {
+        "!",
+        "@",
+        "#",
+        "%",
+        "^",
+        "&",
+        "(",
+        ")",
+        "[",
+        "]",
+        "'",
+        '"',
+        "<",
+        ">",
+        ";",
+        ":",
+        "\\",
+    }
+    cleaned_hash = raw_hash.strip()
+    if not cleaned_hash:
+        return False, "hash is empty"
+    for char in cleaned_hash:
+        if char.isspace():
+            return False, "hash contains whitespace(s)"
+    for hash_char in cleaned_hash:
+        if hash_char in INVALID:
+            return False, "hash contains invalid charater(s)"
+    return True, ""

HashPrint/walker.py

@@ -0,0 +1,34 @@
+# In the Name of God, the Most Compassionate, Most Merciful
+
+
+import os
+from HashPrint.cli import console
+
+
+def is_probably_text_file(file_path, sample_size=1024):
+    try:
+        with open(file_path, "rb") as file:
+            sample = file.read(sample_size)
+        if b"\00" in sample:
+            console.print(
+                f"[warning]Warning: file at path: '{file_path}' skipped - has .txt extensions but appears to be binary[/warning]"
+            )
+            return False
+    except PermissionError:
+        console.print("[error]Error: [/error]")
+        return False
+    except OSError as exception:
+        console.print(f"[error]Error: something went wrong - {exception}[/error]")
+        return False
+    return True
+
+
+def walker(start_dir):
+    text_files = []
+    for directory_root, _, files in os.walk(start_dir):
+        for file in files:
+            if file.endswith(".txt"):
+                file_path = os.path.join(directory_root, file)
+                if is_probably_text_file(file_path):
+                    text_files.append(file_path)
+    return text_files

hashprint_cli-1.0.0.dist-info/METADATA

@@ -0,0 +1,135 @@
+Metadata-Version: 2.5
+Name: hashprint-cli
+Version: 1.0.0
+Summary: A forensic CLI tool for hash identification
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.14
+Requires-Dist: pyfiglet>=1.0.4
+Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: rich-argparse>=1.8.0
+Requires-Dist: rich>=15.0.0
+Description-Content-Type: text/markdown
+
+# HashPrint
+
+## What's this?
+
+***Note: this is a student project***
+
+Surely a random string like ***'b318c90ba09d05dfc9ff3991974eee68'*** can look scary.
+Be afraid no more, HashPrint got your back.
+
+## About HashPrint
+
+HashPrint is a forensic CLI tool that can identify which algorithm (like MD5, bcrypt, SHA256) produced the scary looking string, called a hash, like the above one.
+
+## Features of HashPrint
+
+1. **Hash Support:** HashPrint can identify 90+ hashes.
+2. **Export Options:** HashPrint allows you to export results in various formats, like JSON and YAML.
+3. **Multiple Hashes:** HashPrint can read multiple hashes from a text file. It can recursively scan a directory to locate text files that contain hashes. It can also accept multiple hashes from the command-line.
+4. **Coloured Output:** HashPrint outputs coloured results, making them easier to read.
+5. **Easy to use:** if you ever feel stuck, remember help is just a flag away.
+
+## Installation
+
+***Requires Python 3.14+***
+
+If installing with pip, then you must have Python 3.14 or higher installed on your system
+
+```console
+$ pip install hashprint
+```
+
+**OR with uv**
+
+uv installs the correct Python version if necessary
+
+**First setup a virtual environment:**
+
+```console
+$ uv venv
+```
+
+**Then install:**
+
+```console
+$ uv pip install hashprint
+```
+
+**Use without installing**
+
+***Requires uv***
+
+```console
+$ uv tool run hashprint
+```
+
+**OR**
+
+```console
+$ uvx hashprint
+```
+
+## How to use HashPrint?
+
+| Option | Purpose |
+|:------:|:-------------|
+*-h*, *--help* | shows the help message and exits. |
+*-f*, *--hash-file* | this option takes a path to a text file as an argument. With this option, HashPrint will read the file at the specified path for hashes. The file must contain one hash per line. |
+*-c*, *--hash* | this option takes a hash as an argument and identifies it. It should be between single quotes and without the 0x prefix. |
+*-x*, *--format* | this option lets you choose between the export formats. You can export the results in JSON, YAML and text formats. This option cannot work without the *-p*, *--path* option. |
+*-p*, *--path* | this option specifies the path of the export file. If a path to a pre-existing file is specified, it will be overwritten if it already contains content. If the file at the specified path does not exist, HashPrint will create it. |
+*-w*, *--walk* | this option recursively scans a directory at the specified path for text files, containing one hash per line. |
+*-v*, *--version* | this option displays the version number of HashPrint. |
+
+## Usage examples
+
+**For help**
+
+```console
+$ hashprint --help
+```
+
+**Display the version number**
+
+```console
+$ hashprint --version
+```
+
+**Identify a single hash**
+
+```console
+$ hashprint -c 'a9993e364706816aba3e25717850c26c9cd0d89d'
+```
+
+OR
+
+```console
+$ hashprint --hash 'a9993e364706816aba3e25717850c26c9cd0d89d'
+```
+
+**Identify multiple hashes**
+
+```console
+$ hashprint -c '0cc175b9c0f1b6a831c399e269772661' -c 'e8b7be43'
+```
+
+**Identify hashes from a file + export results to a file**
+
+```console
+$ hashprint -f path/to/txt/file/containing/hashes -x text -p path/of/export/file
+```
+
+The above command exports results in a human readable text format at a file of your choice. HashPrint will create the file if it does not exist.
+
+**Recursive Directory Scanner + exporting results to a file**
+
+```console
+$ hashprint -w path/to/directory -x format -p path/of/export/file
+```
+
+## LICENSE
+
+[MIT](./LICENSE)

hashprint_cli-1.0.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+HashPrint/__init__.py,sha256=OebTeKOAc7DjK3HihaQBe76OVswJ7Al7_ZwQBqfW4ak,207
+HashPrint/cli.py,sha256=nFJF3Cm67TB0xFYF75lxMrCSc8pmVLqz7xhhE7u78yI,3284
+HashPrint/database.py,sha256=7V4NWAjtzyEXIPrnHTgUG1xc8dEmE_F397CH2jM5o1Y,17227
+HashPrint/formatter.py,sha256=Xcye85fzvG0QXTrdFGCxb0GZ6xFtpQJ5toxLqTyAL7k,4532
+HashPrint/identifier.py,sha256=nTTeOR10NiVFOI9a6-ujHQoCLHuL_nzp8XPZDzWPHfU,866
+HashPrint/main.py,sha256=vWpERUhiuETkn-6Ahs6NpSVdoJCDrb0NvLm_ltxTwG4,4320
+HashPrint/printer.py,sha256=jlyHjnufgFSNokpdTptq_rAwwIgYcC13-ExWDoc-tgs,1379
+HashPrint/reader.py,sha256=bdk85Oe6LG80I2yaK3urhdZeFuu4Y17Cl3eWXacQgQs,987
+HashPrint/validator.py,sha256=OoRj1ewSjbalzZfAIIBZpzeeTmFnAi7S9ssGt-WQMGc,725
+HashPrint/walker.py,sha256=ApyyJKXTPQMAfMbF_4tRnU7CO8LOVtwAYU6hyhGyXKo,1123
+hashprint_cli-1.0.0.dist-info/METADATA,sha256=W354Mg-eTH1IzM-qEb1hoXUOkjuY9y0OceCTScNJRhc,3821
+hashprint_cli-1.0.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+hashprint_cli-1.0.0.dist-info/entry_points.txt,sha256=PhiEyYfr-dqSeQImQdCRudA3UJXtJ8qOdiOWpRrxo4Q,50
+hashprint_cli-1.0.0.dist-info/licenses/LICENSE,sha256=SS-4C6Y9mUNXzoD2fj_MSqX-6mYc3Z9tIMts3FiAWd0,1089
+hashprint_cli-1.0.0.dist-info/RECORD,,

hashprint_cli-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

hashprint_cli-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+hashprint = HashPrint.main:main

hashprint_cli-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Taha Qaisar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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.