Metadata-Version: 2.4
Name: bis512
Version: 1.0.3
Summary: BIS512 - Custom 512-bit cryptographic hash function for blockchain
Author-email: Biswajit Saha <biswajit519saha@gmail.com>
License: MIT
Project-URL: Homepage, https://github.com/Biswajit78u/bis512
Project-URL: Repository, https://github.com/Biswajit78u/bis512.git
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Classifier: Topic :: Security :: Cryptography
Requires-Python: >=3.8
Description-Content-Type: text/markdown
License-File: LICENSE
Dynamic: license-file

# BIS512 - Custom 512-bit Cryptographic Hash Function 
# ⚠️ DO NOT USE THIS FOR REAL SECURITY ⚠️

This is an **educational experiment** only. 
It has **not been audited** and is **almost certainly broken**.

BIS512 uses a purely self‑contained implementation: no calls to OpenSSL, LibTomCrypt, or any other cryptographic library. All operations (rotations, additions, XOR, non‑linear functions, and constants) are manually implemented in the base language without reliance on pre‑existing hash primitives


**Author:** Biswajit Saha

education purpose only 

## Features

- ✅ **512-bit output** (128 hex characters)
- ✅ **ASIC-resistant** - Fair CPU/GPU mining
- ✅ **Strong avalanche effect** (49.7% bit change)
- ✅ **No collisions detected** in 5000+ tests
- ✅ **Pure Python** - Works everywhere, no compiler needed
- ✅ **Fast enough** for blockchain applications(education only)


## User Guide for BIS512 Hash Function

### 📦 Installation

```bash
pip install bis512
```

### 🚀 Basic Usage

```python
# Import the hash function
from bis512 import hash_string, hash_bytes, hash_hex

# Method 1: Hash a string (returns hex string)
hash_value = hash_string("Hello, World!")
print(hash_value)
# Output: 128-character hexadecimal string

# Method 2: Hash bytes (returns bytes)
data = b"Blockchain data"
hash_bytes_result = hash_bytes(data)

# Method 3: Hash bytes and get hex
hex_result = hash_hex(b"Any input data")
```

### 💡 Quick Examples

```python
from bis512 import hash

# Hash a simple message
print(hash("hello"))

# Hash a number
print(hash(str(12345)))

# Hash in a loop
for i in range(5):
    print(hash(f"message_{i}"))

# Hash from file
with open("myfile.txt", "rb") as f:
    file_hash = hash(f.read().decode())
    print(file_hash)
```

### 🔗 For Blockchain Applications

```python
from bis512 import hash

# Block header hashing
def hash_block(previous_hash, transactions, nonce):
    block_data = f"{previous_hash}{transactions}{nonce}"
    return hash(block_data)

# Merkle tree hashing
def merkle_root(transactions):
    if len(transactions) == 1:
        return hash(transactions[0])
    
    new_level = []
    for i in range(0, len(transactions), 2):
        left = transactions[i]
        right = transactions[i+1] if i+1 < len(transactions) else left
        combined = left + right
        new_level.append(hash(combined))
    
    return merkle_root(new_level)

# Transaction hashing
def hash_transaction(sender, receiver, amount, timestamp):
    tx_data = f"{sender}{receiver}{amount}{timestamp}"
    return hash(tx_data)
```

### 🏗️ Mining Example

```python
from bis512 import hash

def mine_block(previous_hash, transactions, difficulty):
    nonce = 0
    target = "0" * difficulty
    
    while True:
        block_data = f"{previous_hash}{transactions}{nonce}"
        block_hash = hash(block_data)
        
        if block_hash[:difficulty] == target:
            return nonce, block_hash
        nonce += 1

# Mine with difficulty 4
nonce, block_hash = mine_block("previous_hash_here", "transactions_data", 4)
print(f"Mined! Nonce: {nonce}, Hash: {block_hash}")
```

### 📝 Command Line Usage

```bash
# Quick hash from terminal
python -c "from bis512 import hash; print(hash('hello'))"

# Hash from file content
python -c "from bis512 import hash; print(hash(open('file.txt').read()))"

# Hash multiple inputs
python -c "from bis512 import hash; [print(hash(f'input_{i}')) for i in range(10)]"
```

### 🔐 Password Hashing Example

```python
from bis512 import hash
import getpass

# Simple password hashing
password = getpass.getpass("Enter password: ")
password_hash = hash(password)
print(f"Password hash: {password_hash}")

# Verify password
def verify_password(input_password, stored_hash):
    return hash(input_password) == stored_hash

# Usage
stored = hash("mysecret123")
is_valid = verify_password("mysecret123", stored)
print(f"Password valid: {is_valid}")
```

### 📊 Performance Testing

```python
from bis512 import hash
import time

# Test speed
start = time.time()
for i in range(100):
    hash(f"test_message_{i}")
end = time.time()

print(f"100 hashes in {end-start:.2f} seconds")
print(f"Speed: {100/(end-start):.0f} hashes/second")
```

### 🧪 Testing Different Inputs

```python
from bis512 import hash

test_inputs = [
    "a",
    "aa", 
    "aaa",
    "Hello World",
    "Blockchain Technology",
    "1234567890",
    "The quick brown fox jumps over the lazy dog"
]

for inp in test_inputs:
    h = hash(inp)
    print(f"Input: {inp:40} -> Hash: {h[:16]}...")
```

### ⚠️ Important Notes

1. **Output is always 128 hex characters** (512 bits)
2. **Same input always produces same hash**
3. **Different inputs produce completely different hashes**
4. **Pure Python - no external dependencies**

### 🆘 Need Help?

```python
# Check version
import bis512
print(f"BIS512 version: {bis512.__version__}")
print(f"Author: {bis512.__author__}")

# Get help
help(bis512)
```

### ✅ Quick Test

```python
from bis512 import hash

# Test if working correctly
test_hash = hash("test")
print(f"Hash length: {len(test_hash)} characters")
print(f"Is 128 chars? {len(test_hash) == 128}")
print(f"First 16 chars: {test_hash[:16]}...")
```

### 📦 Uninstall

```bash
pip uninstall bis512
```

---

**That's it! Your hash function is ready to use! 🚀**


