SHA-224 Real-World Case Studies

import hashlib
import json
import time
from decimal import Decimal
from typing import Dict, Optional
import redis
import logging

class TransactionHasher:
    """
    Production transaction integrity system using SHA-224
    """

    def __init__(self, redis_client: redis.Redis):
        self.redis = redis_client
        self.logger = logging.getLogger(__name__)

    def hash_transaction(self, transaction: Dict) -> str:
        """
        Create deterministic hash of transaction for integrity verification
        """
        # Normalize transaction data
        normalized = self._normalize_transaction(transaction)

        # Create canonical JSON representation
        canonical = json.dumps(normalized, sort_keys=True, separators=(',', ':'))

        # Generate SHA-224 hash
        hash_value = hashlib.sha224(canonical.encode('utf-8')).hexdigest()

        # Store in cache for quick verification
        cache_key = f"tx_hash:{transaction['id']}"
        self.redis.setex(cache_key, 86400, hash_value)  # 24-hour TTL

        return hash_value

    def _normalize_transaction(self, tx: Dict) -> Dict:
        """
        Normalize transaction data for consistent hashing
        """
        return {
            'id': tx['id'],
            'timestamp': int(tx['timestamp']),  # Remove microseconds
            'from_account': tx['from_account'].upper(),
            'to_account': tx['to_account'].upper(),
            'amount': str(Decimal(str(tx['amount'])).quantize(Decimal('0.01'))),
            'currency': tx['currency'].upper(),
            'type': tx['type'].upper()
        }

    def verify_transaction_chain(self, transactions: List[Dict]) -> bool:
        """
        Verify integrity of transaction chain
        """
        for i, tx in enumerate(transactions):
            if i == 0:
                continue

            # Each transaction includes hash of previous
            prev_hash = self.hash_transaction(transactions[i-1])
            if tx.get('prev_hash') != prev_hash:
                self.logger.error(f"Chain broken at transaction {tx['id']}")
                return False

        return True

    def batch_verify(self, transaction_ids: List[str]) -> Dict[str, bool]:
        """
        Efficiently verify multiple transactions
        """
        pipeline = self.redis.pipeline()

        for tx_id in transaction_ids:
            pipeline.get(f"tx_hash:{tx_id}")

        cached_hashes = pipeline.execute()

        results = {}
        for tx_id, cached_hash in zip(transaction_ids, cached_hashes):
            if cached_hash:
                # Retrieve and verify transaction
                tx = self._get_transaction(tx_id)
                current_hash = self.hash_transaction(tx)
                results[tx_id] = current_hash == cached_hash.decode('utf-8')
            else:
                results[tx_id] = None  # Not in cache

        return results

# Production configuration
REDIS_CONFIG = {
    'host': 'redis-cluster.bank.internal',
    'port': 6379,
    'db': 0,
    'decode_responses': False,
    'socket_keepalive': True,
    'socket_keepalive_options': {
        1: 1,  # TCP_KEEPIDLE
        2: 1,  # TCP_KEEPINTVL
        3: 3,  # TCP_KEEPCNT
    }
}

const crypto = require('crypto');
const { Pool } = require('pg');

class MedicalRecordIntegrity {
  constructor(dbPool) {
    this.db = dbPool;
    this.hashAlgorithm = 'sha224';
  }

  /**
   * Create tamper-evident medical record
   */
  async createRecord(patientId, recordData, metadata) {
    // Separate PII from medical data
    const { pii, medical } = this.separateData(recordData);

    // Hash medical data for integrity
    const medicalHash = this.hashMedicalData(medical);

    // Create audit entry
    const auditHash = await this.createAuditEntry({
      patientId: this.hashPII(patientId),
      action: 'CREATE',
      dataHash: medicalHash,
      timestamp: Date.now(),
      metadata
    });

    // Store with hash chain
    const record = {
      id: crypto.randomUUID(),
      patientIdHash: this.hashPII(patientId),
      medicalDataHash: medicalHash,
      auditHash,
      prevRecordHash: await this.getPreviousRecordHash(patientId),
      timestamp: Date.now(),
      signature: this.signRecord(medicalHash)
    };

    await this.db.query(
      `INSERT INTO medical_records
       (id, patient_id_hash, data_hash, audit_hash, prev_hash, timestamp, signature)
       VALUES ($1, $2, $3, $4, $5, $6, $7)`,
      [record.id, record.patientIdHash, record.medicalDataHash,
       record.auditHash, record.prevRecordHash, record.timestamp, record.signature]
    );

    return record;
  }

  /**
   * Hash medical data with structured format
   */
  hashMedicalData(data) {
    // Normalize data structure
    const normalized = {
      diagnosis: data.diagnosis?.map(d => ({
        code: d.code,
        description: d.description,
        date: Math.floor(d.date / 1000) // Remove milliseconds
      })).sort((a, b) => a.code.localeCompare(b.code)),

      medications: data.medications?.map(m => ({
        name: m.name.toLowerCase(),
        dosage: m.dosage,
        frequency: m.frequency
      })).sort((a, b) => a.name.localeCompare(b.name)),

      vitals: data.vitals ? {
        bloodPressure: data.vitals.bloodPressure,
        heartRate: data.vitals.heartRate,
        temperature: data.vitals.temperature
      } : null,

      labResults: data.labResults?.map(l => ({
        test: l.test,
        value: l.value,
        unit: l.unit,
        date: Math.floor(l.date / 1000)
      })).sort((a, b) => a.test.localeCompare(b.test))
    };

    // Create canonical JSON
    const canonical = JSON.stringify(normalized, null, 0);

    // Generate SHA-224 hash
    return crypto
      .createHash(this.hashAlgorithm)
      .update(canonical)
      .digest('hex');
  }

  /**
   * Hash PII with salt for privacy
   */
  hashPII(pii) {
    const salt = process.env.PII_SALT || 'default-salt';
    return crypto
      .createHash(this.hashAlgorithm)
      .update(salt + pii)
      .digest('hex');
  }

  /**
   * Verify record integrity
   */
  async verifyRecord(recordId) {
    const result = await this.db.query(
      'SELECT * FROM medical_records WHERE id = $1',
      [recordId]
    );

    if (result.rows.length === 0) {
      throw new Error('Record not found');
    }

    const record = result.rows[0];

    // Verify hash chain
    if (record.prev_hash) {
      const prevRecord = await this.db.query(
        'SELECT data_hash FROM medical_records WHERE data_hash = $1',
        [record.prev_hash]
      );

      if (prevRecord.rows.length === 0) {
        return { valid: false, reason: 'Broken hash chain' };
      }
    }

    // Verify signature
    const signatureValid = this.verifySignature(
      record.data_hash,
      record.signature
    );

    if (!signatureValid) {
      return { valid: false, reason: 'Invalid signature' };
    }

    // Verify audit trail
    const auditValid = await this.verifyAuditTrail(record.audit_hash);

    if (!auditValid) {
      return { valid: false, reason: 'Audit trail compromised' };
    }

    return { valid: true, verifiedAt: Date.now() };
  }

  /**
   * Create audit log with hash chain
   */
  async createAuditEntry(data) {
    const prevAuditHash = await this.getLastAuditHash();

    const auditData = {
      ...data,
      prevHash: prevAuditHash
    };

    const auditHash = crypto
      .createHash(this.hashAlgorithm)
      .update(JSON.stringify(auditData))
      .digest('hex');

    await this.db.query(
      `INSERT INTO audit_log (hash, data, prev_hash, timestamp)
       VALUES ($1, $2, $3, $4)`,
      [auditHash, JSON.stringify(data), prevAuditHash, Date.now()]
    );

    return auditHash;
  }

  /**
   * Bulk verify records for compliance
   */
  async bulkVerify(startDate, endDate) {
    const records = await this.db.query(
      `SELECT id FROM medical_records
       WHERE timestamp BETWEEN $1 AND $2`,
      [startDate, endDate]
    );

    const results = {
      total: records.rows.length,
      valid: 0,
      invalid: []
    };

    for (const record of records.rows) {
      const verification = await this.verifyRecord(record.id);

      if (verification.valid) {
        results.valid++;
      } else {
        results.invalid.push({
          id: record.id,
          reason: verification.reason
        });
      }
    }

    return results;
  }
}

module.exports = MedicalRecordIntegrity;

import { createHash } from 'crypto';
import { MerkleTree } from 'merkletreejs';

interface GameAsset {
  id: string;
  type: 'weapon' | 'armor' | 'consumable' | 'currency';
  rarity: 'common' | 'rare' | 'epic' | 'legendary';
  attributes: Record;
  owner: string;
  created: number;
  nonce: string;
}

class AssetVerificationSystem {
  private merkleTree: MerkleTree;
  private assetCache: Map = new Map();

  constructor(private readonly contractAddress: string) {
    this.initializeMerkleTree();
  }

  /**
   * Generate unique asset fingerprint using SHA-224
   */
  generateAssetFingerprint(asset: GameAsset): string {
    // Create deterministic representation
    const fingerprint = {
      id: asset.id,
      type: asset.type,
      rarity: asset.rarity,
      // Sort attributes for consistency
      attributes: Object.keys(asset.attributes)
        .sort()
        .reduce((acc, key) => {
          acc[key] = asset.attributes[key];
          return acc;
        }, {} as Record),
      created: asset.created,
      nonce: asset.nonce
    };

    // Generate SHA-224 hash
    const hash = createHash('sha224')
      .update(JSON.stringify(fingerprint))
      .digest('hex');

    // Cache for performance
    this.assetCache.set(asset.id, hash);

    return hash;
  }

  /**
   * Batch verify assets using Merkle tree
   */
  async batchVerifyAssets(assets: GameAsset[]): Promise {
    const leaves = assets.map(asset =>
      Buffer.from(this.generateAssetFingerprint(asset), 'hex')
    );

    const tree = new MerkleTree(leaves, this.sha224Hash, {
      sortPairs: true
    });

    // Verify against on-chain root
    const onChainRoot = await this.getOnChainMerkleRoot();
    const calculatedRoot = tree.getHexRoot();

    if (onChainRoot !== calculatedRoot) {
      // Check individual assets
      return assets.map(asset => {
        const leaf = Buffer.from(
          this.generateAssetFingerprint(asset),
          'hex'
        );
        const proof = tree.getHexProof(leaf);
        return tree.verify(proof, leaf, onChainRoot);
      });
    }

    return assets.map(() => true);
  }

  /**
   * Custom SHA-224 hash function for Merkle tree
   */
  private sha224Hash(data: Buffer): Buffer {
    return createHash('sha224').update(data).digest();
  }

  /**
   * Prevent item duplication
   */
  async preventDuplication(
    asset: GameAsset,
    transaction: any
  ): Promise {
    const fingerprint = this.generateAssetFingerprint(asset);

    // Check local cache first
    if (this.isDuplicateInCache(fingerprint, asset.id)) {
      return false;
    }

    // Verify on-chain uniqueness
    const exists = await this.checkOnChain(fingerprint);
    if (exists) {
      console.log(`Duplication attempt detected for asset ${asset.id}`);
      await this.reportDuplication(asset, transaction);
      return false;
    }

    // Register new asset
    await this.registerAsset(fingerprint, asset);
    return true;
  }

  /**
   * Efficient asset transfer verification
   */
  async verifyTransfer(
    asset: GameAsset,
    fromPlayer: string,
    toPlayer: string,
    signature: string
  ): Promise {
    // Generate transfer hash
    const transferData = {
      assetFingerprint: this.generateAssetFingerprint(asset),
      from: fromPlayer,
      to: toPlayer,
      timestamp: Date.now(),
      nonce: crypto.randomBytes(16).toString('hex')
    };

    const transferHash = createHash('sha224')
      .update(JSON.stringify(transferData))
      .digest('hex');

    // Verify signature
    const signatureValid = await this.verifySignature(
      transferHash,
      signature,
      fromPlayer
    );

    if (!signatureValid) {
      return false;
    }

    // Update ownership
    asset.owner = toPlayer;
    const newFingerprint = this.generateAssetFingerprint(asset);

    // Update on-chain state (batched for efficiency)
    await this.queueOwnershipUpdate(asset.id, newFingerprint);

    return true;
  }

  /**
   * Generate compact proofs for light clients
   */
  generateCompactProof(asset: GameAsset): string {
    const fingerprint = this.generateAssetFingerprint(asset);

    // Create proof data
    const proof = {
      f: fingerprint.substring(0, 16), // First 64 bits
      t: Math.floor(Date.now() / 1000), // Timestamp
      n: asset.nonce.substring(0, 8)   // Nonce prefix
    };

    // Further compress with SHA-224
    return createHash('sha224')
      .update(JSON.stringify(proof))
      .digest('base64')
      .substring(0, 32); // Truncate for efficiency
  }

  /**
   * Performance monitoring
   */
  async getPerformanceMetrics(): Promise {
    return {
      cacheSize: this.assetCache.size,
      cacheHitRate: this.calculateCacheHitRate(),
      avgVerificationTime: this.getAverageVerificationTime(),
      merkleTreeDepth: this.merkleTree?.getDepth() || 0,
      dailyVerifications: await this.getDailyVerificationCount()
    };
  }
}

// Smart contract interaction for on-chain verification
class AssetSmartContract {
  /**
   * Minimal on-chain storage using SHA-224
   */
  async storeAssetHash(hash: string): Promise {
    // SHA-224 is 28 bytes, more efficient than SHA-256 (32 bytes)
    // Saves ~12.5% in storage costs
    const tx = await this.contract.methods
      .registerAsset(hash)
      .send({ from: this.account });

    return tx.transactionHash;
  }

  /**
   * Batch registration for gas optimization
   */
  async batchRegister(hashes: string[]): Promise {
    // Merkle root of SHA-224 hashes
    const leaves = hashes.map(h => Buffer.from(h, 'hex'));
    const tree = new MerkleTree(leaves, SHA224, { sortPairs: true });
    const root = tree.getHexRoot();

    // Store only root on-chain (massive gas savings)
    const tx = await this.contract.methods
      .registerMerkleRoot(root, hashes.length)
      .send({ from: this.account });

    return tx.transactionHash;
  }
}

export { AssetVerificationSystem, GameAsset };

package main

import (
    "crypto/sha256"
    "encoding/hex"
    "encoding/json"
    "sync"
    "time"
)

// SHA224 implementation for IoT devices
func sha224Hash(data []byte) string {
    h := sha256.Sum224(data)
    return hex.EncodeToString(h[:])
}

type SensorData struct {
    DeviceID    string    `json:"device_id"`
    Timestamp   int64     `json:"timestamp"`
    Temperature float64   `json:"temperature"`
    Pressure    float64   `json:"pressure"`
    Vibration   float64   `json:"vibration"`
    Hash        string    `json:"hash"`
    PrevHash    string    `json:"prev_hash"`
}

type DataPipeline struct {
    mu         sync.RWMutex
    lastHashes map[string]string
    buffer     chan SensorData
}

func (dp *DataPipeline) ProcessSensorData(data SensorData) error {
    // Get previous hash for chain
    dp.mu.RLock()
    prevHash := dp.lastHashes[data.DeviceID]
    dp.mu.RUnlock()

    data.PrevHash = prevHash

    // Calculate hash
    hashData := struct {
        DeviceID    string  `json:"d"`
        Timestamp   int64   `json:"t"`
        Temperature float64 `json:"temp"`
        Pressure    float64 `json:"p"`
        Vibration   float64 `json:"v"`
        PrevHash    string  `json:"ph"`
    }{
        DeviceID:    data.DeviceID,
        Timestamp:   data.Timestamp / 1000, // Remove milliseconds
        Temperature: float64(int(data.Temperature*100)) / 100,
        Pressure:    float64(int(data.Pressure*100)) / 100,
        Vibration:   float64(int(data.Vibration*100)) / 100,
        PrevHash:    prevHash,
    }

    jsonData, _ := json.Marshal(hashData)
    data.Hash = sha224Hash(jsonData)

    // Update last hash
    dp.mu.Lock()
    dp.lastHashes[data.DeviceID] = data.Hash
    dp.mu.Unlock()

    // Send to buffer for batch processing
    dp.buffer <- data

    return nil
}

// Batch verification for efficiency
func (dp *DataPipeline) BatchVerify(batch []SensorData) []bool {
    results := make([]bool, len(batch))

    for i, data := range batch {
        // Recalculate hash
        hashData := struct {
            DeviceID    string  `json:"d"`
            Timestamp   int64   `json:"t"`
            Temperature float64 `json:"temp"`
            Pressure    float64 `json:"p"`
            Vibration   float64 `json:"v"`
            PrevHash    string  `json:"ph"`
        }{
            DeviceID:    data.DeviceID,
            Timestamp:   data.Timestamp / 1000,
            Temperature: float64(int(data.Temperature*100)) / 100,
            Pressure:    float64(int(data.Pressure*100)) / 100,
            Vibration:   float64(int(data.Vibration*100)) / 100,
            PrevHash:    data.PrevHash,
        }

        jsonData, _ := json.Marshal(hashData)
        calculatedHash := sha224Hash(jsonData)

        results[i] = (calculatedHash == data.Hash)
    }

    return results
}