SHA-224 Use Cases

// Example of ECDSA signature using SHA-224 with Node.js crypto module
const crypto = require('crypto');

// Generate key pair based on P-224 curve (matching security level)
const { privateKey, publicKey } = crypto.generateKeyPairSync('ec', {
  namedCurve: 'P-224',
  publicKeyEncoding: {
    type: 'spki',
    format: 'pem'
  },
  privateKeyEncoding: {
    type: 'pkcs8',
    format: 'pem'
  }
});

// Message to be signed
const message = 'This is a secure message signed with SHA-224 and ECDSA';

// Create signature
const signer = crypto.createSign('SHA224');
signer.update(message);
signer.end();
const signature = signer.sign(privateKey);

// Verify signature
const verifier = crypto.createVerify('SHA224');
verifier.update(message);
verifier.end();
const isVerified = verifier.verify(publicKey, signature);

console.log(`Signature verified: ${isVerified}`);
// Output: Signature verified: true

# Generate a private key
openssl genpkey -algorithm RSA -out private.key -pkeyopt rsa_keygen_bits:2048

# Create a certificate signing request (CSR)
openssl req -new -key private.key -out request.csr

# Create a self-signed certificate using SHA-224
openssl x509 -req -days 365 -in request.csr -signkey private.key \
  -out certificate.crt -sha224

# Verify the certificate signature algorithm
openssl x509 -in certificate.crt -text -noout | grep "Signature Algorithm"
# Output: Signature Algorithm: sha224WithRSAEncryption

const crypto = require('crypto');

function hashPassword(password) {
  // Generate a random salt (16 bytes)
  const salt = crypto.randomBytes(16);
  
  // Use PBKDF2 with SHA-224 and 10,000 iterations
  return new Promise((resolve, reject) => {
    crypto.pbkdf2(password, salt, 10000, 28, 'sha224', (err, derivedKey) => {
      if (err) return reject(err);
      
      // Format: iterations:salt:hash
      const hash = `10000:${salt.toString('hex')}:${derivedKey.toString('hex')}`;
      resolve(hash);
    });
  });
}

function verifyPassword(storedHash, suppliedPassword) {
  return new Promise((resolve, reject) => {
    // Extract the iterations, salt, and hash
    const [iterations, salt, hash] = storedHash.split(':');
    const saltBuffer = Buffer.from(salt, 'hex');
    
    // Compute hash of supplied password
    crypto.pbkdf2(suppliedPassword, saltBuffer, parseInt(iterations), 28, 'sha224', 
      (err, derivedKey) => {
        if (err) return reject(err);
        resolve(derivedKey.toString('hex') === hash);
    });
  });
}

// Example usage
async function example() {
  const password = 'MySecurePassword123';
  
  // Store password
  const storedHash = await hashPassword(password);
  console.log(`Stored hash: ${storedHash}`);
  
  // Verify correct password
  const isValid = await verifyPassword(storedHash, password);
  console.log(`Password valid: ${isValid}`);
  
  // Verify incorrect password
  const isInvalid = await verifyPassword(storedHash, 'WrongPassword');
  console.log(`Wrong password valid: ${isInvalid}`);
}

# Generate SHA-224 checksum
openssl dgst -sha224 filename.iso > filename.sha224

# Verify a file against its checksum
echo "$(cat filename.sha224) filename.iso" | sha224sum -c
# Output: filename.iso: OK

import hmac
import hashlib

def create_hmac(message, key):
    """Create an HMAC signature using SHA-224"""
    h = hmac.new(key.encode(), message.encode(), hashlib.sha224)
    return h.hexdigest()

def verify_hmac(message, key, signature):
    """Verify a message using its HMAC signature"""
    h = hmac.new(key.encode(), message.encode(), hashlib.sha224)
    calculated = h.hexdigest()
    return hmac.compare_digest(calculated, signature)

# Example usage
secret_key = "shared_secret_key_between_parties"
message = "Important message that needs integrity protection"

# Sender creates HMAC
signature = create_hmac(message, secret_key)
print(f"Message: {message}")
print(f"HMAC-SHA224: {signature}")

# Receiver verifies HMAC
is_valid = verify_hmac(message, secret_key, signature)
print(f"Integrity verified: {is_valid}")

# Example of tampered message
tampered = message + " with unauthorized changes"
is_valid = verify_hmac(tampered, secret_key, signature)
print(f"Tampered message integrity: {is_valid}")  # Will be False

class Block {
  constructor(index, timestamp, data, previousHash = '') {
    this.index = index;
    this.timestamp = timestamp;
    this.data = data;
    this.previousHash = previousHash;
    this.hash = this.calculateHash();
    this.nonce = 0;
  }

  calculateHash() {
    // Use SHA-224 for block hashing
    return SHA224.hash(
      this.index + 
      this.previousHash + 
      this.timestamp + 
      JSON.stringify(this.data) + 
      this.nonce
    );
  }

  mineBlock(difficulty) {
    // Simplified proof-of-work: find hash with leading zeros
    const target = Array(difficulty + 1).join('0');
    while (this.hash.substring(0, difficulty) !== target) {
      this.nonce++;
      this.hash = this.calculateHash();
    }
    console.log(`Block mined: ${this.hash}`);
  }
}

class Blockchain {
  constructor() {
    // Genesis block
    this.chain = [this.createGenesisBlock()];
    this.difficulty = 4;
  }

  createGenesisBlock() {
    return new Block(0, new Date().toISOString(), 'Genesis Block', '0');
  }

  getLatestBlock() {
    return this.chain[this.chain.length - 1];
  }

  addBlock(newBlock) {
    newBlock.previousHash = this.getLatestBlock().hash;
    newBlock.hash = newBlock.calculateHash();
    newBlock.mineBlock(this.difficulty);
    this.chain.push(newBlock);
  }

  isChainValid() {
    for (let i = 1; i < this.chain.length; i++) {
      const currentBlock = this.chain[i];
      const previousBlock = this.chain[i - 1];

      // Verify current block's hash
      if (currentBlock.hash !== currentBlock.calculateHash()) {
        return false;
      }

      // Verify chain linkage
      if (currentBlock.previousHash !== previousBlock.hash) {
        return false;
      }
    }
    return true;
  }
}

class SHA224PRNG {
  constructor(seed) {
    // Initialize with a seed
    this.state = String(seed || Date.now());
    // Internal counter for additional entropy
    this.counter = 0;
  }

  // Get next random bytes
  getRandomBytes(numBytes) {
    const result = new Uint8Array(numBytes);
    let offset = 0;
    
    while (offset < numBytes) {
      // Update internal state
      this.counter++;
      // Generate next hash value
      const hash = SHA224.hash(this.state + this.counter);
      // Convert hex to bytes
      const hashBytes = this._hexToBytes(hash);
      
      // Copy bytes to result
      const toCopy = Math.min(hashBytes.length, numBytes - offset);
      for (let i = 0; i < toCopy; i++) {
        result[offset + i] = hashBytes[i];
      }
      offset += toCopy;
      
      // Update state with new hash
      this.state = hash;
    }
    
    return result;
  }
  
  // Get random integer in range [min, max]
  getRandomInt(min, max) {
    const range = max - min + 1;
    const bytesNeeded = Math.ceil(Math.log2(range) / 8);
    const randomBytes = this.getRandomBytes(bytesNeeded);
    
    // Convert bytes to number
    let value = 0;
    for (let i = 0; i < randomBytes.length; i++) {
      value = (value << 8) | randomBytes[i];
    }
    
    // Ensure uniform distribution
    return min + (value % range);
  }
  
  // Helper to convert hex string to bytes
  _hexToBytes(hex) {
    const bytes = new Uint8Array(hex.length / 2);
    for (let i = 0; i < hex.length; i += 2) {
      bytes[i/2] = parseInt(hex.substring(i, i+2), 16);
    }
    return bytes;
  }
}

// Example usage
const rng = new SHA224PRNG("my-secure-seed");
const randomBytes = rng.getRandomBytes(16);
console.log("Random bytes:", Array.from(randomBytes).map(b => b.toString(16).padStart(2, '0')).join(''));
console.log("Random number between 1-100:", rng.getRandomInt(1, 100));

# Linux/macOS (OpenSSL)
openssl dgst -sha224 filename.zip > filename.sha224

# Linux (sha224sum)
sha224sum filename.zip > filename.sha224

# Windows (CertUtil)
certutil -hashfile filename.zip SHA224 > filename.sha224

# Verification (Linux/macOS)
sha224sum -c filename.sha224

import hashlib
import os

def calculate_sha224(filename, block_size=65536):
    """Calculate SHA-224 hash of a file"""
    sha224 = hashlib.sha224()
    with open(filename, 'rb') as f:
        for block in iter(lambda: f.read(block_size), b''):
            sha224.update(block)
    return sha224.hexdigest()

def verify_checksum(filename, expected_checksum):
    """Verify a file against its expected SHA-224 checksum"""
    actual_checksum = calculate_sha224(filename)
    return actual_checksum == expected_checksum

def generate_checksums_for_directory(directory, output_file='checksums.sha224'):
    """Generate SHA-224 checksums for all files in a directory"""
    with open(output_file, 'w') as f:
        for root, _, files in os.walk(directory):
            for file in files:
                if file == output_file:
                    continue
                file_path = os.path.join(root, file)
                checksum = calculate_sha224(file_path)
                relative_path = os.path.relpath(file_path, directory)
                f.write(f"{checksum}  {relative_path}\n")
    print(f"Checksums written to {output_file}")

def verify_checksums_from_file(checksum_file, base_directory='.'):
    """Verify multiple files against checksums stored in a file"""
    failed = []
    verified = 0
    
    with open(checksum_file, 'r') as f:
        for line in f:
            parts = line.strip().split('  ', 1)
            if len(parts) != 2:
                continue
                
            expected_checksum, relative_path = parts
            file_path = os.path.join(base_directory, relative_path)
            
            if not os.path.exists(file_path):
                failed.append((relative_path, "File not found"))
                continue
                
            if verify_checksum(file_path, expected_checksum):
                verified += 1
            else:
                actual_checksum = calculate_sha224(file_path)
                failed.append((relative_path, f"Expected: {expected_checksum}, Got: {actual_checksum}"))
    
    return verified, failed

# Example usage
if __name__ == "__main__":
    # Generate checksums for a directory
    generate_checksums_for_directory("./downloads")
    
    # Verify checksums
    verified, failed = verify_checksums_from_file("checksums.sha224")
    print(f"Verified {verified} files successfully")
    
    if failed:
        print(f"Failed to verify {len(failed)} files:")
        for file, reason in failed:
            print(f"  - {file}: {reason}")

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.Base64;

public class SecureMessaging {
    private final Mac hmacSha224;
    private final SecretKeySpec secretKey;

    public SecureMessaging(String sharedSecret) throws NoSuchAlgorithmException {
        // Initialize HMAC with SHA-224
        hmacSha224 = Mac.getInstance("HmacSHA224");
        secretKey = new SecretKeySpec(sharedSecret.getBytes(), "HmacSHA224");
    }

    public String createAuthenticatedMessage(String message) 
            throws InvalidKeyException {
        // Reset the MAC with our key
        hmacSha224.init(secretKey);
        
        // Compute the HMAC
        byte[] hmacValue = hmacSha224.doFinal(message.getBytes());
        String encodedHmac = Base64.getEncoder().encodeToString(hmacValue);
        
        // Format: Base64(HMAC-SHA224) + ":" + message
        return encodedHmac + ":" + message;
    }

    public boolean verifyAuthenticatedMessage(String authenticatedMessage) 
            throws InvalidKeyException {
        // Split into HMAC and original message
        String[] parts = authenticatedMessage.split(":", 2);
        if (parts.length != 2) {
            return false;
        }
        
        String receivedHmac = parts[0];
        String message = parts[1];
        
        // Recompute HMAC
        hmacSha224.init(secretKey);
        byte[] expectedHmac = hmacSha224.doFinal(message.getBytes());
        String encodedExpectedHmac = Base64.getEncoder().encodeToString(expectedHmac);
        
        // Compare HMACs (using constant-time comparison to prevent timing attacks)
        return constantTimeEquals(receivedHmac, encodedExpectedHmac);
    }
    
    // Constant-time string comparison to prevent timing attacks
    private boolean constantTimeEquals(String a, String b) {
        if (a.length() != b.length()) {
            return false;
        }
        
        int result = 0;
        for (int i = 0; i < a.length(); i++) {
            result |= a.charAt(i) ^ b.charAt(i);
        }
        return result == 0;
    }

    // Example usage
    public static void main(String[] args) {
        try {
            SecureMessaging secure = new SecureMessaging("shared_secret_key_1234");
            
            // Alice creates an authenticated message
            String authenticatedMessage = secure.createAuthenticatedMessage("Hello Bob, this is a secure message");
            System.out.println("Authenticated message: " + authenticatedMessage);
            
            // Bob verifies the message
            boolean isValid = secure.verifyAuthenticatedMessage(authenticatedMessage);
            System.out.println("Message integrity verified: " + isValid);
            
            // Example of tampered message
            String[] parts = authenticatedMessage.split(":", 2);
            String tamperedMessage = parts[0] + ":Hello Bob, this message was TAMPERED WITH";
            boolean isTamperedValid = secure.verifyAuthenticatedMessage(tamperedMessage);
            System.out.println("Tampered message verified: " + isTamperedValid); // Should be false
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

using System;
using System.Security.Cryptography;
using System.Text;

class KeyDerivation
{
    // Simple key derivation function using SHA-224
    public static byte[] DeriveKey(string masterKey, string purpose, int keyLengthBytes)
    {
        using (var sha224 = SHA224.Create())
        {
            // Combine master key with purpose
            byte[] masterKeyBytes = Encoding.UTF8.GetBytes(masterKey);
            byte[] purposeBytes = Encoding.UTF8.GetBytes(purpose);
            byte[] combined = new byte[masterKeyBytes.Length + purposeBytes.Length];
            
            Buffer.BlockCopy(masterKeyBytes, 0, combined, 0, masterKeyBytes.Length);
            Buffer.BlockCopy(purposeBytes, 0, combined, masterKeyBytes.Length, purposeBytes.Length);
            
            // Basic key stretching with iterations
            byte[] result = combined;
            for (int i = 0; i < 10000; i++)
            {
                result = sha224.ComputeHash(result);
            }
            
            // Truncate or expand if needed
            if (result.Length == keyLengthBytes)
            {
                return result;
            }
            else if (result.Length > keyLengthBytes)
            {
                byte[] truncated = new byte[keyLengthBytes];
                Buffer.BlockCopy(result, 0, truncated, 0, keyLengthBytes);
                return truncated;
            }
            else
            {
                // Need more bytes - perform additional hashing with counters
                byte[] expanded = new byte[keyLengthBytes];
                int offset = 0;
                int counter = 0;
                
                while (offset < keyLengthBytes)
                {
                    // Create a new hash with the counter
                    byte[] counterBytes = BitConverter.GetBytes(counter);
                    byte[] toHash = new byte[result.Length + counterBytes.Length];
                    Buffer.BlockCopy(result, 0, toHash, 0, result.Length);
                    Buffer.BlockCopy(counterBytes, 0, toHash, result.Length, counterBytes.Length);
                    
                    byte[] counterHash = sha224.ComputeHash(toHash);
                    
                    // Copy as many bytes as needed
                    int toCopy = Math.Min(counterHash.Length, keyLengthBytes - offset);
                    Buffer.BlockCopy(counterHash, 0, expanded, offset, toCopy);
                    
                    offset += toCopy;
                    counter++;
                }
                
                return expanded;
            }
        }
    }
    
    // Example usage
    static void Main()
    {
        // Master key from a key exchange protocol
        string masterKey = "shared_secret_established_via_key_exchange";
        
        // Derive different keys for different purposes
        byte[] encryptionKey = DeriveKey(masterKey, "AES_ENCRYPTION", 32); // 256-bit AES key
        byte[] hmacKey = DeriveKey(masterKey, "HMAC", 28); // 224-bit HMAC key
        
        Console.WriteLine("Encryption Key: " + BitConverter.ToString(encryptionKey).Replace("-", ""));
        Console.WriteLine("HMAC Key: " + BitConverter.ToString(hmacKey).Replace("-", ""));
    }
}

import hashlib
import pandas as pd
import numpy as np
from typing import Dict, Any, Optional, List

class DatasetFingerprinter:
    """Generates cryptographic fingerprints for ML datasets using SHA-224"""
    
    @staticmethod
    def fingerprint_dataframe(df: pd.DataFrame, 
                              include_metadata: bool = True,
                              sorted_by: Optional[List[str]] = None) -> Dict[str, Any]:
        """
        Create a SHA-224 fingerprint of a pandas DataFrame
        
        Args:
            df: The DataFrame to fingerprint
            include_metadata: Whether to include column names and dtypes in the fingerprint
            sorted_by: Optional columns to sort by before fingerprinting (for reproducibility)
            
        Returns:
            Dictionary with fingerprint hash and metadata
        """
        # Start with a copy to avoid modifying the original
        df_copy = df.copy()
        
        # Sort if requested (important for reproducibility)
        if sorted_by:
            df_copy = df_copy.sort_values(by=sorted_by).reset_index(drop=True)
        
        # Initialize hasher
        hasher = hashlib.sha224()
        
        # Add metadata if requested
        if include_metadata:
            # Hash column names
            columns_str = ','.join(df_copy.columns.astype(str))
            hasher.update(columns_str.encode())
            
            # Hash datatypes
            dtypes_str = str(df_copy.dtypes)
            hasher.update(dtypes_str.encode())
            
            # Hash shape
            shape_str = f"{df_copy.shape[0]},{df_copy.shape[1]}"
            hasher.update(shape_str.encode())
        
        # Hash the actual data, handling different data types appropriately
        for column in df_copy.columns:
            col_data = df_copy[column]
            
            # Handle different data types
            if np.issubdtype(col_data.dtype, np.number):
                # For numeric data, convert to consistent string representation
                values = col_data.fillna('NaN').astype(str).values
            elif col_data.dtype == 'object':
                # For object/string data
                values = col_data.fillna('').astype(str).values
            elif pd.api.types.is_datetime64_any_dtype(col_data):
                # For datetime, use ISO format
                values = col_data.fillna(pd.NaT).dt.strftime('%Y-%m-%dT%H:%M:%S.%f').values
            else:
                # Default fallback
                values = col_data.fillna('').astype(str).values
                
            # Update hash with this column's data
            hasher.update(','.join(values).encode())
        
        # Generate final fingerprint
        fingerprint = hasher.hexdigest()
        
        # Return fingerprint with metadata
        return {
            'hash': fingerprint,
            'algorithm': 'sha224',
            'rows': df_copy.shape[0],
            'columns': df_copy.shape[1],
            'column_names': list(df_copy.columns),
            'include_metadata': include_metadata,
            'sorted_by': sorted_by
        }
    
    @staticmethod
    def verify_dataframe(df: pd.DataFrame, expected_fingerprint: Dict[str, Any]) -> bool:
        """
        Verify a DataFrame against a previously generated fingerprint
        
        Args:
            df: The DataFrame to verify
            expected_fingerprint: The expected fingerprint dictionary
            
        Returns:
            True if verification succeeds, False otherwise
        """
        # Generate new fingerprint with the same parameters
        current_fingerprint = DatasetFingerprinter.fingerprint_dataframe(
            df=df,
            include_metadata=expected_fingerprint['include_metadata'],
            sorted_by=expected_fingerprint.get('sorted_by')
        )
        
        # Compare only the hash values (constant-time comparison)
        expected_hash = expected_fingerprint['hash']
        current_hash = current_fingerprint['hash']
        
        if len(expected_hash) != len(current_hash):
            return False
            
        result = 0
        for a, b in zip(expected_hash, current_hash):
            result |= ord(a) ^ ord(b)
            
        return result == 0

# Example usage
if __name__ == "__main__":
    # Create sample dataset
    data = {
        'id': range(1000),
        'value': np.random.randn(1000),
        'category': np.random.choice(['A', 'B', 'C'], 1000)
    }
    df = pd.DataFrame(data)
    
    # Generate fingerprint
    fingerprint = DatasetFingerprinter.fingerprint_dataframe(df, sorted_by=['id'])
    print(f"Dataset fingerprint: {fingerprint['hash']}")
    
    # Later, verify the dataset hasn't changed
    is_valid = DatasetFingerprinter.verify_dataframe(df, fingerprint)
    print(f"Verification result: {is_valid}")
    
    # Demonstrate what happens with modified data
    df_modified = df.copy()
    df_modified.loc[0, 'value'] = 999.999  # Change one value
    
    is_still_valid = DatasetFingerprinter.verify_dataframe(df_modified, fingerprint)
    print(f"Modified data verification: {is_still_valid}")  # Should be False

<?php
class TokenManager {
    private $serverSecret;
    private $defaultExpiration;
    
    /**
     * Initialize the token manager
     * 
     * @param string $serverSecret A secret key known only to the server
     * @param int $defaultExpiration Default token expiration in seconds
     */
    public function __construct($serverSecret, $defaultExpiration = 3600) {
        $this->serverSecret = $serverSecret;
        $this->defaultExpiration = $defaultExpiration;
    }
    
    /**
     * Generate a secure token for a given purpose and identifier
     * 
     * @param string $purpose What the token is for (e.g., "reset_password", "email_verification")
     * @param string $identifier User identifier (e.g., user ID, email)
     * @param int $expiration Token validity period in seconds (optional)
     * @return array Token data including the actual token and expiration timestamp
     */
    public function generateToken($purpose, $identifier, $expiration = null) {
        // Use default expiration if not specified
        if ($expiration === null) {
            $expiration = $this->defaultExpiration;
        }
        
        // Create expiration timestamp
        $expiresAt = time() + $expiration;
        
        // Create a random component to prevent token prediction
        $randomBytes = random_bytes(16);
        $randomComponent = bin2hex($randomBytes);
        
        // Combine all elements to create the token data
        $tokenData = [
            'purpose' => $purpose,
            'identifier' => $identifier,
            'expires' => $expiresAt,
            'random' => $randomComponent
        ];
        
        // Create a signature using SHA-224
        $dataString = json_encode($tokenData);
        $signature = hash_hmac('sha224', $dataString, $this->serverSecret);
        
        // Combine data and signature
        $token = base64_encode($dataString) . '.' . $signature;
        
        return [
            'token' => $token,
            'expires_at' => $expiresAt
        ];
    }
    
    /**
     * Verify a token and extract its data if valid
     * 
     * @param string $token The token to verify
     * @param string $purpose Expected purpose
     * @param string $identifier Expected identifier
     * @return array|bool Token data if valid, false otherwise
     */
    public function verifyToken($token, $purpose, $identifier = null) {
        // Split token into data and signature parts
        $parts = explode('.', $token);
        if (count($parts) !== 2) {
            return false; // Invalid token format
        }
        
        $dataEncoded = $parts[0];
        $signature = $parts[1];
        
        // Decode the data
        try {
            $dataString = base64_decode($dataEncoded);
            $data = json_decode($dataString, true);
        } catch (Exception $e) {
            return false; // Invalid data encoding
        }
        
        // Check if token data is complete
        if (!isset($data['purpose']) || !isset($data['identifier']) || 
            !isset($data['expires']) || !isset($data['random'])) {
            return false; // Invalid token structure
        }
        
        // Verify signature
        $expectedSignature = hash_hmac('sha224', $dataString, $this->serverSecret);
        if (!hash_equals($expectedSignature, $signature)) {
            return false; // Invalid signature
        }
        
        // Check expiration
        if (time() > $data['expires']) {
            return false; // Token expired
        }
        
        // Check purpose
        if ($data['purpose'] !== $purpose) {
            return false; // Wrong purpose
        }
        
        // Check identifier if provided
        if ($identifier !== null && $data['identifier'] !== $identifier) {
            return false; // Wrong identifier
        }
        
        // Token is valid, return the data
        return $data;
    }
    
    /**
     * Invalidate a token by generating a new server secret
     * Note: This invalidates ALL tokens - for selective invalidation
     * you would need to maintain a token blacklist or use a different approach
     */
    public function rotateServerSecret() {
        $this->serverSecret = bin2hex(random_bytes(32));
        return $this->serverSecret;
    }
}

// Example usage
$tokenManager = new TokenManager('my_server_secret_key_change_in_production');

// Generate a password reset token for user 123
$resetToken = $tokenManager->generateToken('reset_password', '123', 1800); // 30 minutes

echo "Password Reset Token: " . $resetToken['token'] . "\n";
echo "Expires at: " . date('Y-m-d H:i:s', $resetToken['expires_at']) . "\n";

// Later, verify the token
$tokenData = $tokenManager->verifyToken($resetToken['token'], 'reset_password', '123');
if ($tokenData) {
    echo "Token is valid, user can reset password\n";
} else {
    echo "Token is invalid or expired\n";
}
?>

// Note: This example uses the 'jsonwebtoken' library
// which may need to be extended to support SHA-224
// npm install jsonwebtoken

const jwt = require('jsonwebtoken');
const crypto = require('crypto');

// Custom SHA-224 signing function
function sign224(data, secret) {
  return crypto
    .createHmac('sha224', secret)
    .update(data)
    .digest('base64url');
}

// Create a JWT with a custom SHA-224 algorithm
function createJWT(payload, secret) {
  // Create the JWT header
  const header = {
    alg: 'HS224', // Custom algorithm identifier for SHA-224
    typ: 'JWT'
  };
  
  // Encode header and payload
  const encodedHeader = Buffer.from(JSON.stringify(header)).toString('base64url');
  const encodedPayload = Buffer.from(JSON.stringify(payload)).toString('base64url');
  
  // Create the signature
  const data = `${encodedHeader}.${encodedPayload}`;
  const signature = sign224(data, secret);
  
  // Return the complete JWT
  return `${data}.${signature}`;
}

// Verify a JWT signed with SHA-224
function verifyJWT(token, secret) {
  // Split the token
  const parts = token.split('.');
  if (parts.length !== 3) {
    throw new Error('Invalid token format');
  }
  
  const [encodedHeader, encodedPayload, receivedSignature] = parts;
  
  // Verify the signature
  const data = `${encodedHeader}.${encodedPayload}`;
  const expectedSignature = sign224(data, secret);
  
  if (receivedSignature !== expectedSignature) {
    throw new Error('Invalid signature');
  }
  
  // Decode the payload
  try {
    const payload = JSON.parse(Buffer.from(encodedPayload, 'base64url').toString());
    
    // Check expiration
    if (payload.exp && Date.now() >= payload.exp * 1000) {
      throw new Error('Token expired');
    }
    
    return payload;
  } catch (e) {
    throw new Error('Invalid payload: ' + e.message);
  }
}

// Example usage
const secret = 'your-256-bit-secret';
const payload = {
  sub: '1234567890',
  name: 'John Doe',
  admin: true,
  iat: Math.floor(Date.now() / 1000),
  exp: Math.floor(Date.now() / 1000) + 3600 // Expires in 1 hour
};

const token = createJWT(payload, secret);
console.log('Generated JWT:', token);

try {
  const decodedPayload = verifyJWT(token, secret);
  console.log('Decoded payload:', decodedPayload);
} catch (e) {
  console.error('Verification failed:', e.message);
}

#include 
#include 
#include 

// SHA-224 defines
#define SHA224_BLOCK_SIZE 64
#define SHA224_DIGEST_SIZE 28

// SHA-224 context structure
typedef struct {
    uint32_t state[8];          // State variables
    uint64_t count;             // Number of bits processed
    uint8_t buffer[64];         // Input buffer
} SHA224_CTX;

// Function declarations
void sha224_init(SHA224_CTX *ctx);
void sha224_update(SHA224_CTX *ctx, const uint8_t *data, size_t len);
void sha224_final(SHA224_CTX *ctx, uint8_t digest[SHA224_DIGEST_SIZE]);
void sha224_transform(SHA224_CTX *ctx, const uint8_t *data);

// Firmware verification function
int verify_firmware(const uint8_t *firmware, size_t firmware_size, 
                    const uint8_t expected_digest[SHA224_DIGEST_SIZE]) {
    SHA224_CTX ctx;
    uint8_t digest[SHA224_DIGEST_SIZE];
    
    // Initialize SHA-224 context
    sha224_init(&ctx);
    
    // Update with firmware data
    sha224_update(&ctx, firmware, firmware_size);
    
    // Finalize and get digest
    sha224_final(&ctx, digest);
    
    // Compare computed digest with expected digest
    return memcmp(digest, expected_digest, SHA224_DIGEST_SIZE) == 0;
}

// Secure boot implementation
int secure_boot(const uint8_t *firmware, size_t firmware_size) {
    // These would typically be stored in secure storage or hardware security module
    static const uint8_t expected_firmware_digest[SHA224_DIGEST_SIZE] = {
        0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
        0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
        0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
        0x99, 0xAA, 0xBB, 0xCC
    };
    
    printf("Starting secure boot process...\n");
    printf("Verifying firmware integrity...\n");
    
    if (!verify_firmware(firmware, firmware_size, expected_firmware_digest)) {
        printf("ERROR: Firmware verification failed!\n");
        printf("Boot process aborted for security reasons.\n");
        return -1; // Boot failure
    }
    
    printf("Firmware verification successful.\n");
    printf("Continuing boot process...\n");
    
    // Additional security checks could be performed here
    
    return 0; // Boot success
}

// Example usage in main
int main() {
    // In a real embedded system, this would be loaded from flash memory
    // This is just an example
    uint8_t example_firmware[1024];
    size_t firmware_size = sizeof(example_firmware);
    
    // Initialize example firmware with some data
    for (int i = 0; i < firmware_size; i++) {
        example_firmware[i] = i & 0xFF;
    }
    
    // Attempt secure boot
    int boot_result = secure_boot(example_firmware, firmware_size);
    
    if (boot_result == 0) {
        printf("System booted successfully.\n");
        // Start main application
    } else {
        printf("System in recovery mode due to boot failure.\n");
        // Enter recovery or fail-safe mode
    }
    
    return 0;
}