Overview

THIS IS WORK IN PROGRESS!!

Hasher is a customizable hashing tool implemented in Python. It allows users to hash various data types such as strings, integers, floats, lists, dictionaries, bytes, and even files with a standalone, configurable hashing algorithm. It offers additional security features such as configurable rounds, block sizes, and hash lengths, as well as optional salt and pepper for each hash.

Features

• Supports hashing of multiple data types: str, int, float, list, dict, tuple, bytes, and files.
• Customizable parameters:
  • rounds: Number of rounds for the hashing process.
  • block_size: Size of the data blocks used for hashing.
  • hash_length: Length of the final hash output.
  • salt: Optional salt to add randomness to the hash.
  • pepper: An additional user-defined key that acts as a second salt.
• Provides both base64 and hex output formats.
• Standalone script that does not depend on external libraries like hashlib or hmac.

Installation

Simply download or clone this repository. No additional libraries are required.

Usage

Import and Initialize

```python from configurable_hasher import ConfigurableHasher

Initialize the hasher with custom parameters

hasher = ConfigurableHasher( rounds=100, blocksize=512, hashlength=256, salt="customsalt", pepper="extrasecretpepper", outputformat="base64" ) ```

Hashing Data

```python

Hash a string

data = "hello world" hashvalue = hasher.hash(data) print(f"Hash of '{data}': {hashvalue}")

Hash an integer

integerdata = 12345 integerhash = hasher.hash(integerdata) print(f"Hash of {integerdata}: {integer_hash}")

Hash a file

filepath = "example.txt" filehash = hasher.hashfile(filepath) print(f"Hash of file '{filepath}': {filehash}") ```

Validating Hashes

To ensure the integrity of a hashed item, use the validate or validate_file method to compare the computed hash with an existing hash.

```python

Validate a string hash

isvalid = hasher.validate(data, hashvalue) print(f"Is the hash valid? {is_valid}")

Validate a file hash

isfilevalid = hasher.validatefile(filepath, filehash) print(f"Is the file hash valid? {isfile_valid}") ```

Example Use Cases

• Data Integrity Verification: Use this tool to verify if data has been altered by comparing the hash before and after.
• Password Storage: Store passwords as salted and hashed strings for enhanced security.
• File Change Detection: Monitor changes in files by hashing their content and comparing it with stored hash values.

Parameters

The following parameters can be configured in the ConfigurableHasher class:

• rounds (int): Number of rounds to use in the hashing algorithm. Minimum is 64.
• block_size (int): Size of the data blocks for hashing in bits, must be between 128 and 2048. Adjusted to be a multiple of 64.
• hash_length (int): Length of the final hash output in bits, up to 512.
• salt (Any): Optional salt for the hash. Accepts str, int, float, list, dict, tuple, and bytes. It is converted to bytes and truncated/padded to 16 bytes.
• pepper (Any): Optional pepper for the hash. Accepts the same types as salt, converted to bytes and truncated/padded to 16 bytes.
• output_format (str): Output format of the hash, either 'hex' or 'base64'.

Supported Data Types

The hash method accepts a variety of data types: - str: String data. - int: Integer data (signed and unsigned). - float: Floating-point numbers. - list: Lists containing any of the supported data types. - dict: Dictionaries with string keys and supported data types as values. - tuple: Tuples containing any of the supported data types. - bytes: Raw byte data.

Limitations

• Integer Size: Integers are constrained by the block_size to prevent overflow errors. The maximum size is capped based on the block size in bits.
• File Size: The maximum file size is limited by the available memory, as the file is processed in blocks equal to block_size // 8.

Security Considerations

The ConfigurableHasher offers a flexible and customizable hashing approach, but it's important to understand the security limitations: - This hashing implementation is not cryptographically secure compared to standard algorithms like SHA-256 or bcrypt. - Suitable for data integrity checks or non-critical hashing needs, but not recommended for highly sensitive information such as password hashing in a production environment. - Salting: The script allows for a fixed salt and pepper, making it easier to validate hashes but less secure than dynamic salting for each hash. Always use unique salts when possible for added security.