Function hash 

pub fn hash(input: &str) -> Result<String>

Computes the SHA-256 hash of the input text.

This function implements the complete SHA-256 algorithm including:

• Message preprocessing and padding
• Processing in 512-bit blocks
• 64 rounds of compression per block
• Final hash value computation

Arguments

• input - The text to hash (any UTF-8 string)

Returns

Returns a 64-character lowercase hexadecimal string representing the 256-bit hash value.

Examples

use ruscrypt::hash::sha256;

// Empty string
let hash = sha256::hash("").unwrap();
assert_eq!(hash, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855");

// Simple text
let hash = sha256::hash("abc").unwrap();
assert_eq!(hash, "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad");

// Unicode support
let hash = sha256::hash("Hello 世界").unwrap();
assert_eq!(hash.len(), 64);

// Consistency check
let hash1 = sha256::hash("test").unwrap();
let hash2 = sha256::hash("test").unwrap();
assert_eq!(hash1, hash2);

Algorithm Details

The implementation follows RFC 6234 and includes:

• Proper message padding with length encoding
• 64 rounds of SHA-256 compression function
• Correct handling of endianness
• Support for messages of any length

Examples found in repository

examples/quick_start.rs (line 154)

fn quick_hash_example() -> Result<()> {
    println!("{}", "   Creates unique fingerprints for any data.".white());
    println!("{}", "   ✅ Secure: Perfect for data integrity and passwords".green());
    
    let messages = vec!["Hello", "Hello!", "hello"];
    
    for (i, message) in messages.iter().enumerate() {
        let hash = sha256::hash(message)?;
        println!("   📝 Input {}: {} → Hash: {}...", 
                (i + 1).to_string().white(),
                message.cyan(), 
                hash[..16].green().bold()
        );
    }
    
    // Show consistency
    let test = "consistency";
    let hash1 = sha256::hash(test)?;
    let hash2 = sha256::hash(test)?;
    println!("   🔍 Consistency: {} → {}", 
            if hash1 == hash2 { "✅ Always same result" } else { "❌ Error" },
            if hash1 == hash2 { "Perfect!" } else { "Failed!" }
    );
    
    println!("   ✨ Notice: Small input changes = Completely different hashes!");
    println!("   💡 Try: {}", "cargo run -- hash --sha256".bright_green());
    
    Ok(())
}

examples/demo.rs (line 250)

fn demo_hash_functions() -> Result<()> {
    let sample_texts = vec![
        "Hello, World!",
        "RusCrypt is awesome!",
        "Secure hashing with Rust",
        "Small change", 
        "small change", // Demonstrate avalanche effect
    ];
    
    println!("{}", "Hash Function Comparison:".yellow());
    println!("{}", "═════════════════════════".yellow());
    
    for (i, text) in sample_texts.iter().enumerate() {
        println!("\n{} {}:", "Sample".cyan(), (i + 1).to_string().cyan());
        println!("   Input: {}", text.white());
        
        // MD5 Hash
        let md5_hash = md5::hash(text)?;
        println!("   MD5    (128-bit): {}", md5_hash.bright_red());
        
        // SHA-1 Hash
        let sha1_hash = sha1::hash(text)?;
        println!("   SHA-1  (160-bit): {}", sha1_hash.bright_yellow());
        
        // SHA-256 Hash
        let sha256_hash = sha256::hash(text)?;
        println!("   SHA-256(256-bit): {}", sha256_hash.bright_green());
        
        if i == 3 { // Show avalanche effect
            println!("   💡 Notice how 'Small change' vs 'small change' produces completely different hashes!");
        }
    }
    
    // Security status
    println!("\n{}", "Security Status:".yellow());
    println!("   ❌ MD5:    BROKEN - Collision attacks possible");
    println!("   ⚠️  SHA-1:  DEPRECATED - Use only for legacy compatibility");
    println!("   ✅ SHA-256: SECURE - Recommended for modern applications");
    
    // Demonstrate hash consistency
    println!("\n{}", "🔍 Hash Consistency Verification:".yellow());
    let test_input = "consistency_test";
    let hash1 = sha256::hash(test_input)?;
    let hash2 = sha256::hash(test_input)?;
    println!("   Input: {}", test_input.white());
    println!("   Hash 1: {}", hash1.green());
    println!("   Hash 2: {}", hash2.green());
    println!("   Match: {}", if hash1 == hash2 { "✅ Perfect consistency".bright_green() } else { "❌ Error!".bright_red() });
    
    Ok(())
}