SHA-224 Hash Length

4575bb4ec129df6380cedde6d71217fe0536f8ffc4e18bca530a7a1b

4575bb4ec129df6380cedde6d71217fe0536f8ffc4e18bca530a7a1b

RXW7TsEp32OAzt3m1xIX/gU2+P/E4YvKUwp6Gw==

01000101011101011011101101001110110000010010100111011111011000111000000011001110110111011110011011010001001000010111111111100000010100110110111110001111111111000100111000011011110010100101000111010100001011

RXW7TsEp32OAzt3m1xIX_gU2-P_E4YvKUwp6Gw==

// Using the Web Crypto API
async function sha224Hash(message) {
  // Convert message string to bytes
  const msgBuffer = new TextEncoder().encode(message);
  
  // Note: Web Crypto doesn't directly support SHA-224, so use SHA-256 and truncate
  const hashBuffer = await crypto.subtle.digest('SHA-256', msgBuffer);
  
  // Convert to byte array
  const hashArray = Array.from(new Uint8Array(hashBuffer));
  
  // Take only first 28 bytes (224 bits)
  const sha224Array = hashArray.slice(0, 28);
  
  // Convert to hex string
  const hashHex = sha224Array.map(b => b.toString(16).padStart(2, '0')).join('');
  
  console.log(`SHA-224 hash: ${hashHex}`);
  console.log(`Hash length in bits: ${sha224Array.length * 8}`);
  console.log(`Hash length in bytes: ${sha224Array.length}`);
  console.log(`Hex string length: ${hashHex.length}`);
  
  return hashHex;
}

import hashlib
import base64

def sha224_demo(message):
    # Create a SHA-224 hash object
    sha224 = hashlib.sha224()
    
    # Update with message bytes
    sha224.update(message.encode('utf-8'))
    
    # Get the hash digest as bytes (28 bytes / 224 bits)
    digest_bytes = sha224.digest()
    
    # Get the hexadecimal representation (56 characters)
    hex_digest = sha224.hexdigest()
    
    # Get the Base64 representation
    base64_digest = base64.b64encode(digest_bytes).decode('utf-8')
    
    # Create binary representation
    binary_digest = ''.join(format(byte, '08b') for byte in digest_bytes)
    
    print(f"Message: {message}")
    print(f"SHA-224 hash (hex): {hex_digest}")
    print(f"SHA-224 hash (Base64): {base64_digest}")
    print(f"Hash length in bits: {len(digest_bytes) * 8}")
    print(f"Hash length in bytes: {len(digest_bytes)}")
    print(f"Hex string length: {len(hex_digest)}")
    print(f"Base64 string length: {len(base64_digest)}")
    
    return hex_digest

# Example usage
sha224_demo("Hello, world!")

import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Base64;

public class SHA224Demo {
    public static void main(String[] args) throws NoSuchAlgorithmException {
        String message = "Hello, world!";
        
        // Create SHA-224 MessageDigest instance
        MessageDigest digest = MessageDigest.getInstance("SHA-224");
        
        // Update with message bytes
        byte[] hashBytes = digest.digest(message.getBytes(StandardCharsets.UTF_8));
        
        // Convert to hexadecimal representation
        StringBuilder hexString = new StringBuilder();
        for (byte b : hashBytes) {
            String hex = Integer.toHexString(0xff & b);
            if (hex.length() == 1) {
                hexString.append('0');
            }
            hexString.append(hex);
        }
        String hexDigest = hexString.toString();
        
        // Convert to Base64 representation
        String base64Digest = Base64.getEncoder().encodeToString(hashBytes);
        
        // Output results
        System.out.println("Message: " + message);
        System.out.println("SHA-224 hash (hex): " + hexDigest);
        System.out.println("SHA-224 hash (Base64): " + base64Digest);
        System.out.println("Hash length in bits: " + (hashBytes.length * 8));
        System.out.println("Hash length in bytes: " + hashBytes.length);
        System.out.println("Hex string length: " + hexDigest.length());
        System.out.println("Base64 string length: " + base64Digest.length());
    }
}