hashmama@crypto:~$ ./free_tools.sh
$ ./free_tools.sh

🛠️ Free Hashing Tools

Interactive tools for learning hash functions, HMAC, avalanche effects, and more

hashmama@crypto:~$ hash_calc --algorithm=sha256
$ hash_calc --algorithm=sha256
=== LIVE HASH CALCULATOR ===
Compute cryptographic digests locally
Use SHA-256/SHA-512 for integrity; avoid MD5/SHA-1 for security
=====================================

$ live hash calculator Open the command reference

Compute cryptographic digests locally. Use SHA-256/SHA-512 for integrity; avoid MD5/SHA-1 for security. Optionally compute an HMAC for message authentication.

Characters: 0 Bytes: 0
SHA-256
—
digest length: 256 bits
MD5 (insecure, for demo)
—
HMAC
—
hashmama@crypto:~$ collision_demo --algorithm=md5 --warning=true
$ collision_demo --algorithm=md5 --warning=true
=== COLLISION DEMO (MD5) ===
⚠️ WARNING: MD5 is collision-prone
Below are two inputs designed to be similar
Experiment to see how trivial it is to search for partial prefix matches
=====================================

$ collision demonstration Open the command reference

Explore hash collisions and understand why some algorithms are cryptographically broken. See how different inputs can produce the same hash output.

Status: 🔴 Broken
Input 1
Hash:
—
Input 2
Hash:
—
Collision Analysis
—
Known Collision Examples
Understanding Hash Collisions
What is a Hash Collision?

A collision occurs when two different inputs produce the same hash output. This is a fundamental weakness in cryptographic hash functions.

Why Do Collisions Matter?

Collisions can be exploited to create fake documents, bypass security checks, or forge digital signatures. The goal is to make collisions computationally infeasible.

Algorithm Security Status:
  • 🔴 MD5: Broken - collisions found in 2004
  • 🟡 SHA-1: Weak - collisions found in 2017
  • 🟢 SHA-256: Secure - no collisions found
How to Test:
  • • Use the prefill buttons to try real collision examples
  • • Switch between algorithms to see security differences
  • • Try the known collision examples (MD5/SHA-1)
  • • Use the random collision finder to demonstrate birthday paradox
Random Collision Finder
Generate random inputs to demonstrate the birthday paradox and find potential collisions.
Attempts: 0
Unique hashes: 0
Collisions found: 0
Current hash: —
Collision probability: —
Ready to start collision finding

Quick Collision Analysis

—
—
—
hashmama@crypto:~$ avalanche --algorithm=sha256 --visualize=true
$ avalanche --algorithm=sha256 --visualize=true
=== AVALANCHE EFFECT VISUALIZER ===
Observe how single-bit changes cascade through hash outputs
Strong avalanche effect indicates good cryptographic properties
=========================================

$ avalanche effect (SHA-256) What is diffusion?

Demonstrates diffusion: a single-character change flips many output bits in a secure hash. Edit either side and observe the bit-difference grid and statistics.

SHA-256
—
SHA-256
—
different bits: 0 • 0.00% (of 256 bits)
hashmama@crypto:~$ hash_table --size=16 --chaining=separate
$ hash_table --size=16 --chaining=separate
=== HASH TABLE LABORATORY ===
Interactive hash table implementation with collision resolution
Explore separate chaining and open addressing strategies
=====================================

$ visualization_lab --interactive=true --live-data=true Learn more

Advanced hash table visualization with real-world data integration. Observe the avalanche effect, experiment with operations, and analyze live blockchain data patterns.

Operations/sec
0
Memory Usage
0 KB
Hash Quality
—
Load Factor
0.00
Hash function: simpleHash(key) % 16 • Collisions: 0 • Load factor: 0.00
hashmama@crypto:~$ hkdf --hash=sha256 --length=32
$ hkdf --hash=sha256 --length=32
=== HMAC-BASED KEY DERIVATION ===
RFC 5869 compliant key derivation function
Extract and expand phases for secure key generation
=====================================

$ HKDF (HMAC-based key derivation) Derivation guide

Derive subkeys from a master key using HKDF-Extract and HKDF-Expand with HMAC-SHA-256.

PRK (extract)
—
OKM (expand)
—
Understanding HKDF
What is HKDF?

HKDF (HMAC-based Key Derivation Function) is a standardized method for deriving multiple cryptographic keys from a single master secret. It's used in TLS, VPNs, and secure messaging protocols.

Two-Phase Process:
  • 🔵 Extract: Converts input keying material (IKM) to a pseudorandom key (PRK) using HMAC-SHA-256
  • 🟢 Expand: Derives output keying material (OKM) from PRK using HMAC-SHA-256
Prefill Examples:
  • • TLS Key Derivation: Standard TLS 1.2 key expansion process
  • • Encryption Keys: Deriving encryption keys from Diffie-Hellman shared secrets
  • • Authentication Keys: Creating authentication keys with random salts
  • • Session Keys: Generating longer session keys for extended sessions
Security Benefits:
  • • Prevents key reuse attacks through unique salts and context
  • • Ensures cryptographic separation between different key purposes
  • • Provides forward secrecy when used with ephemeral keys
  • • Standardized and well-vetted by the cryptographic community
hashmama@crypto:~$ merkle --leaves=8 --hash=sha256
$ merkle --leaves=8 --hash=sha256
=== MERKLE TREE LABORATORY ===
Construct and verify cryptographic hash trees
Generate inclusion proofs for data integrity verification
=====================================

$ Merkle Tree (SHA-256) - Advanced Cryptographic Tool Merkle Reference

Professional Merkle tree implementation for cryptographic verification, blockchain analysis, and inclusion proof validation.

Cryptographic Examples:
Click any example to load real cryptographic data and see inclusion proofs in action. Each demonstrates different aspects of Merkle tree applications.
💡 Educational Value: Each example demonstrates real-world cryptographic applications with detailed inclusion proofs, statistics, and security properties.
Tree Structure Visualization:
Click a prefill button to visualize the Merkle tree structure
Real-World Cryptographic Statistics:
Select an example to see real-world statistics and cryptographic details
Cryptographic Properties & Security:
Select an example to see cryptographic properties and security implications
Enter transaction hashes, file hashes, or any data to build the tree
Merkle Root (SHA-256)
—
Tree Height: 0 • Total Nodes: 0
The data item you want to prove is included
Ordered list of sibling hashes from leaf to root
Proof Path Visualization:
Proof path will be shown here after verification
Cryptographic Examples Explained
Bitcoin Block #800000
  • • 8 transactions: Coinbase, Payment, Exchange, DeFi, NFT, Lightning, Mixing, Settlement
  • • Real hashes: SHA-256 transaction identifiers
  • • Inclusion proof: Verify any transaction exists in block
  • • Blockchain security: Merkle root links to previous block
Ethereum Block #18,000,000
  • • 6 transactions: Uniswap, USDC, NFT, DeFi, L2 Bridge, MEV
  • • Real hashes: 0x-prefixed transaction hashes
  • • Inclusion proof: Verify transaction in Ethereum state
  • • Smart contracts: Complex transaction verification
Lightning Network Channels
  • • 6 channels: Major exchange connections
  • • Channel states: Commitment transaction hashes
  • • Inclusion proof: Verify channel state in network
  • • Payment routing: Efficient path verification
IPFS Content Hashes
  • • 8 documents: Whitepapers, protocols, research
  • • Content IDs: Qm-prefixed multihash identifiers
  • • Inclusion proof: Verify document in distributed storage
  • • Content addressing: Decentralized file verification
Git Commit History
  • • 8 commits: Project setup, features, tests, docs
  • • Commit hashes: SHA-1 (40-character) identifiers
  • • Inclusion proof: Verify commit in repository history
  • • Version control: Immutable development timeline
SSL Certificate Chain
  • • 6 certificates: Root CA, Intermediate, Domain certs
  • • Certificate hashes: SHA-256 fingerprint verification
  • • Inclusion proof: Verify cert in trust chain
  • • PKI security: Trust path validation
Merkle Tree Properties
  • • Deterministic: Same input always produces same root
  • • Tamper-evident: Any change affects the entire path to root
  • • Efficient verification: O(log n) proof size for n leaves
  • • Cryptographic security: Based on SHA-256 collision resistance
  • • Blockchain: Bitcoin transaction verification
  • • Distributed systems: IPFS content addressing
  • • Cryptocurrency: Light client verification
  • • File systems: Integrity verification
hashmama@crypto:~$ blockchain --network=bitcoin --explore=true
$ blockchain --network=bitcoin --explore=true
=== BLOCKCHAIN EXPLORER ===
Analyze Bitcoin block headers and cryptographic linking
Generate keypairs and addresses with proper validation
=====================================

$ blockchain_explorer --network=bitcoin --advanced=true Blockchain Basics

Advanced cryptographic blockchain explorer with real-time Bitcoin analysis, transaction verification, cryptographic proof validation, and blockchain mechanics exploration.

Network Configuration

Provider: — | Status: — | Last Update: —

Latest Block Analysis

Block Header Analysis
Height: —
Version: —
Timestamp: —
Difficulty: —
Nonce: —
Bits: —
Chainwork: —
Confirmations: —
Cryptographic Hashes
Block Hash (SHA-256):
—
Previous Block Hash:
—
Merkle Root:
—
Block Statistics
Transaction Count: —
Block Size: —
Weight Units: —
Fee Pool: —
Advanced Block Analysis
Block Age: —
Confirmations: —
Next Block: —
Block Reward: 6.25 BTC
Block Validation Status
Header Validation: Valid
Transaction Validation: Valid
Merkle Root: Valid
Difficulty Target: Valid

Advanced Cryptographic Analysis

Hash Properties
Length: —
Format: —
Leading Zeros: —
Trailing Zeros: —
Cryptographic Verification
Hash Integrity: —
Merkle Proof: —
Difficulty Target: —
Hash Distribution Analysis
Character Frequency:
—
Entropy Score: —
Pattern Detection: —
Hash Collision Risk: —
Randomness Score: —
Advanced Cryptographic Metrics
Avalanche Effect: —
Bit Independence: —
Non-Linearity: —
Differential Cryptanalysis: —

Bitcoin Address Analyzer

Example addresses to analyze:

Advanced Transaction Analysis

Transaction hashes should be 64-character hexadecimal strings (e.g., a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d)
💡 Having trouble? Try the example transactions below, or ensure your hash is from a confirmed transaction (not pending).
Example transactions to analyze (click to load):
💡 Tip: Use these example transactions to test the explorer. All examples use real, verified transaction hashes.

Advanced Blockchain Metrics

Network Statistics
Total Supply: ~19.6M BTC
Circulating Supply: ~19.6M BTC
Market Cap: ~$1.2T
24h Volume: ~$45B
Mining Information
Hash Rate: ~500 EH/s
Difficulty: ~50.0T
Block Reward: 6.25 BTC
Next Halving: ~2024
Proof of Work
• SHA-256 double-hashing for block header
• Difficulty adjustment every 2016 blocks
• Target hash must be below difficulty threshold
• Nonce incrementation for hash collision
• ASIC-resistant mining algorithm
• Energy consumption: ~130 TWh/year
Merkle Tree Structure
• Binary tree of transaction hashes
• Root hash commits to all transactions
• Efficient proof of inclusion
• Tamper-evident data structure
• SPV (Simple Payment Verification) support
• Compact block optimization
Block Validation
• Hash meets difficulty target
• Previous block hash validation
• Merkle root verification
• Transaction format compliance
• Script validation and execution
• Consensus rule enforcement
Advanced Features
• SegWit (Segregated Witness) support
• Lightning Network compatibility
• Taproot and Schnorr signatures
• BIP-340, BIP-341, BIP-342 implementation
• Multi-signature and smart contracts
• Atomic swaps and cross-chain bridges

Advanced Cryptographic Tools

Hash Calculator
💡 Press Enter to calculate SHA-256 hash
* RIPEMD-160 uses SHA-256 as fallback (not available in Web Crypto API)
Address Generator
Generate Keypair: Creates a complete keypair with private key, public key, and address
Generate Address: Creates just a new Bitcoin address (private key not shown)
Merkle Tree Builder